C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_imatrix.hpp
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: l_imatrix.hpp,v 1.22 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LIMATRIX_HPP_INCLUDED
27 #define _CXSC_LIMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "idot.hpp"
31 #include "l_ivector.hpp"
32 #include "except.hpp"
33 #include "matrix.hpp"
34 #include "imatrix.hpp"
35 #include "l_rmatrix.hpp"
36 
37 namespace cxsc {
38 
39 class l_imatrix;
40 class l_imatrix_slice;
41 
43 
47 {
48  friend class l_ivector;
49  friend class l_imatrix;
50  friend class l_imatrix_slice;
51  private:
52  l_interval *dat;
53  int lb,ub;
54  int size,start,offset; // start=first element index 0..n-1
55 
56  public:
58  friend INLINE l_imatrix_subv Row(l_imatrix &m,const int &i)
59 #if(CXSC_INDEX_CHECK)
60  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
61 #else
62  throw();
63 #endif
64  friend INLINE l_imatrix_subv Col(l_imatrix &m,const int &i)
66 #if(CXSC_INDEX_CHECK)
67  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
68 #else
69  throw();
70 #endif
71  friend INLINE l_imatrix_subv Row(const l_imatrix &m,const int &i)
73 #if(CXSC_INDEX_CHECK)
74  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
75 #else
76  throw();
77 #endif
78  friend INLINE l_imatrix_subv Col(const l_imatrix &m,const int &i)
80 #if(CXSC_INDEX_CHECK)
81  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
82 #else
83  throw();
84 #endif
85 //#if(CXSC_INDEX_CHECK)
86 #ifdef _CXSC_FRIEND_TPL
87  //----------------- Templates ---------------------------------------
88 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
89 #if(CXSC_INDEX_CHECK)
90  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
91 #else
92  throw();
93 #endif
94 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
95 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
96 #if(CXSC_INDEX_CHECK)
97  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
98 #else
99  throw();
100 #endif
101 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
102 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
105 #else
106  throw();
107 #endif
108 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
109 #if(CXSC_INDEX_CHECK)
110  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
111 #else
112  throw();
113 #endif
114 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
115 #if(CXSC_INDEX_CHECK)
116  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
117 #else
118  throw();
119 #endif
120 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
121 #if(CXSC_INDEX_CHECK)
122  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
123 #else
124  throw();
125 #endif
126 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
127 #if(CXSC_INDEX_CHECK)
128  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
129 #else
130  throw();
131 #endif
132 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
133 #if(CXSC_INDEX_CHECK)
134  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
135 #else
136  throw();
137 #endif
138 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
139 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
140 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
141 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
142 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
143 
144  template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) throw();
145  template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) throw();
146  template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) throw();
147  template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) throw();
148 
149 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
150 #if(CXSC_INDEX_CHECK)
151  throw(OP_WITH_WRONG_DIM);
152 #else
153  throw();
154 #endif
155 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
156 #if(CXSC_INDEX_CHECK)
157  throw(OP_WITH_WRONG_DIM);
158 #else
159  throw();
160 #endif
161  template <class MV1,class MV2,class S> friend S _mvmvlimult(const MV1 & rv1, const MV2 &rv2)
162 #if(CXSC_INDEX_CHECK)
163  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
164 #else
165  throw();
166 #endif
167  template <class V,class MV,class S> friend S _vmvlimult(const V &rv1, const MV &rv2)
168 #if(CXSC_INDEX_CHECK)
169  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
170 #else
171  throw();
172 #endif
173  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
174  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
175 #if(CXSC_INDEX_CHECK)
176  throw(ERROR__OP_WITH_WRONG_DIM<E>);
177 #else
178  throw();
179 #endif
180  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
181 #if(CXSC_INDEX_CHECK)
182  throw(ERROR__OP_WITH_WRONG_DIM<E>);
183 #else
184  throw();
185 #endif
186  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
187 #if(CXSC_INDEX_CHECK)
188  throw(ERROR__OP_WITH_WRONG_DIM<E>);
189 #else
190  throw();
191 #endif
192  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
193 #if(CXSC_INDEX_CHECK)
194  throw(ERROR__OP_WITH_WRONG_DIM<E>);
195 #else
196  throw();
197 #endif
198  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
199 #if(CXSC_INDEX_CHECK)
200  throw(ERROR__OP_WITH_WRONG_DIM<E>);
201 #else
202  throw();
203 #endif
204  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
205 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
206 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
207 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
208 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
209 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
210 #if(CXSC_INDEX_CHECK)
211  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
212 #else
213  throw();
214 #endif
215 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
216 #if(CXSC_INDEX_CHECK)
217  throw(ERROR__OP_WITH_WRONG_DIM<V>);
218 #else
219  throw();
220 #endif
221 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
222 #if(CXSC_INDEX_CHECK)
223  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
224 #else
225  throw();
226 #endif
227 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
228 #if(CXSC_INDEX_CHECK)
229  throw(ERROR__OP_WITH_WRONG_DIM<V>);
230 #else
231  throw();
232 #endif
233  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
234 #if(CXSC_INDEX_CHECK)
235  throw(ERROR__OP_WITH_WRONG_DIM<E>);
236 #else
237  throw();
238 #endif
239  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
240 #if(CXSC_INDEX_CHECK)
241  throw(ERROR__OP_WITH_WRONG_DIM<E>);
242 #else
243  throw();
244 #endif
245 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
246 #if(CXSC_INDEX_CHECK)
247  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
248 #else
249  throw();
250 #endif
251  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
252 #if(CXSC_INDEX_CHECK)
253  throw(ERROR__OP_WITH_WRONG_DIM<E>);
254 #else
255  throw();
256 #endif
257  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
258 #if(CXSC_INDEX_CHECK)
259  throw(ERROR__OP_WITH_WRONG_DIM<E>);
260 #else
261  throw();
262 #endif
263 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
264 #if(CXSC_INDEX_CHECK)
265  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
266 #else
267  throw();
268 #endif
269 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
270 #if(CXSC_INDEX_CHECK)
271  throw(ERROR__OP_WITH_WRONG_DIM<V>);
272 #else
273  throw();
274 #endif
275 
276 
277 #endif
278 
279  //----------------- Konstruktoren ----------------------------------
280 
282  explicit INLINE l_imatrix_subv (l_interval *d, const int &l, const int &u, const int &s, const int &st, const int &o) throw():dat(d),lb(l),ub(u),size(s),start(st),offset(o) { }
283  public:
285  INLINE l_imatrix_subv(const l_imatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
286  public:
287 
288  //---------------------- Standardfunktionen ------------------------
289 
291  INLINE l_imatrix_subv &operator =(const l_imatrix_subv &rv) throw();
293  INLINE l_imatrix_subv &operator =(const l_interval &r) throw();
295  INLINE l_imatrix_subv &operator =(const l_imatrix &m)
296 #if(CXSC_INDEX_CHECK)
297  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
298 #else
299  throw();
300 #endif
301  INLINE l_imatrix_subv &operator =(const l_imatrix_slice &m)
303 #if(CXSC_INDEX_CHECK)
304  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
305 #else
306  throw();
307 #endif
308  INLINE l_imatrix_subv &operator =(const l_ivector &v)
310 #if(CXSC_INDEX_CHECK)
311  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
312 #else
313  throw();
314 #endif
315  INLINE l_imatrix_subv &operator =(const l_ivector_slice &v)
317 #if(CXSC_INDEX_CHECK)
318  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
319 #else
320  throw();
321 #endif
322  // Real
324  INLINE l_imatrix_subv &operator =(const real &r) throw();
326  INLINE l_imatrix_subv &operator =(const rmatrix &m)
327 #if(CXSC_INDEX_CHECK)
328  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
329 #else
330  throw();
331 #endif
332  INLINE l_imatrix_subv &operator =(const rmatrix_slice &m)
334 #if(CXSC_INDEX_CHECK)
335  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
336 #else
337  throw();
338 #endif
339  INLINE l_imatrix_subv &operator =(const rvector &v)
341 #if(CXSC_INDEX_CHECK)
342  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
343 #else
344  throw();
345 #endif
346  INLINE l_imatrix_subv &operator =(const rvector_slice &v)
348 #if(CXSC_INDEX_CHECK)
349  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
350 #else
351  throw();
352 #endif
353  INLINE l_imatrix_subv &operator =(const rmatrix_subv &rv) throw();
355 
356  // l_real
358  INLINE l_imatrix_subv &operator =(const l_real &r) throw();
360  INLINE l_imatrix_subv &operator =(const l_rmatrix &m)
361 #if(CXSC_INDEX_CHECK)
362  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
363 #else
364  throw();
365 #endif
366  INLINE l_imatrix_subv &operator =(const l_rmatrix_slice &m)
368 #if(CXSC_INDEX_CHECK)
369  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
370 #else
371  throw();
372 #endif
373  INLINE l_imatrix_subv &operator =(const l_rvector &v)
375 #if(CXSC_INDEX_CHECK)
376  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
377 #else
378  throw();
379 #endif
380  INLINE l_imatrix_subv &operator =(const l_rvector_slice &v)
382 #if(CXSC_INDEX_CHECK)
383  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
384 #else
385  throw();
386 #endif
387  INLINE l_imatrix_subv &operator =(const l_rmatrix_subv &rv) throw();
389 
390  // interval
392  INLINE l_imatrix_subv &operator =(const interval &r) throw();
394  INLINE l_imatrix_subv &operator =(const imatrix &m)
395 #if(CXSC_INDEX_CHECK)
396  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
397 #else
398  throw();
399 #endif
400  INLINE l_imatrix_subv &operator =(const imatrix_slice &m)
402 #if(CXSC_INDEX_CHECK)
403  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
404 #else
405  throw();
406 #endif
407  INLINE l_imatrix_subv &operator =(const ivector &v)
409 #if(CXSC_INDEX_CHECK)
410  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
411 #else
412  throw();
413 #endif
414  INLINE l_imatrix_subv &operator =(const ivector_slice &v)
416 #if(CXSC_INDEX_CHECK)
417  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
418 #else
419  throw();
420 #endif
421  INLINE l_imatrix_subv &operator =(const imatrix_subv &rv) throw();
423 
425  friend INLINE int Lb(const l_imatrix_subv &rv) throw() { return rv.lb; }
427  friend INLINE int Ub(const l_imatrix_subv &rv) throw() { return rv.ub; }
429  INLINE l_interval &operator [](const int &i) const
430 #if(CXSC_INDEX_CHECK)
431  throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
432 #else
433  throw();
434 #endif
435  INLINE l_imatrix_subv &operator ()() throw() { return *this; }
438  INLINE l_imatrix_subv operator ()(const int &i)
439 #if(CXSC_INDEX_CHECK)
440  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
441 #else
442  throw();
443 #endif
444  INLINE l_imatrix_subv operator ()(const int &i1,const int &i2)
446 #if(CXSC_INDEX_CHECK)
447  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
448 #else
449  throw();
450 #endif
451 
453  INLINE l_imatrix_subv &operator *=(const l_interval &c) throw();
455  INLINE l_imatrix_subv &operator +=(const l_interval &c) throw();
457  INLINE l_imatrix_subv &operator -=(const l_interval &c) throw();
459  INLINE l_imatrix_subv &operator /=(const l_interval &c) throw();
461  INLINE l_imatrix_subv &operator -=(const l_ivector &rv)
462 #if(CXSC_INDEX_CHECK)
463  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
464 #else
465  throw();
466 #endif
467  INLINE l_imatrix_subv &operator +=(const l_ivector &rv)
469 #if(CXSC_INDEX_CHECK)
470  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
471 #else
472  throw();
473 #endif
474  INLINE l_imatrix_subv &operator -=(const l_ivector_slice &rv)
476 #if(CXSC_INDEX_CHECK)
477  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
478 #else
479  throw();
480 #endif
481  INLINE l_imatrix_subv &operator +=(const l_ivector_slice &rv)
483 #if(CXSC_INDEX_CHECK)
484  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
485 #else
486  throw();
487 #endif
488  INLINE l_imatrix_subv &operator |=(const l_ivector &rv)
490 #if(CXSC_INDEX_CHECK)
491  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
492 #else
493  throw();
494 #endif
495  INLINE l_imatrix_subv &operator |=(const l_ivector_slice &rv)
497 #if(CXSC_INDEX_CHECK)
498  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
499 #else
500  throw();
501 #endif
502  INLINE l_imatrix_subv &operator &=(const l_ivector &rv)
504 #if(CXSC_INDEX_CHECK)
505  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
506 #else
507  throw();
508 #endif
509  INLINE l_imatrix_subv &operator &=(const l_ivector_slice &rv)
511 #if(CXSC_INDEX_CHECK)
512  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
513 #else
514  throw();
515 #endif
516  // real
518  INLINE l_imatrix_subv &operator *=(const real &c) throw();
520  INLINE l_imatrix_subv &operator +=(const real &c) throw();
522  INLINE l_imatrix_subv &operator -=(const real &c) throw();
524  INLINE l_imatrix_subv &operator /=(const real &c) throw();
526  INLINE l_imatrix_subv &operator -=(const rvector &rv)
527 #if(CXSC_INDEX_CHECK)
528  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
529 #else
530  throw();
531 #endif
532  INLINE l_imatrix_subv &operator +=(const rvector &rv)
534 #if(CXSC_INDEX_CHECK)
535  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
536 #else
537  throw();
538 #endif
539  INLINE l_imatrix_subv &operator -=(const rvector_slice &rv)
541 #if(CXSC_INDEX_CHECK)
542  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
543 #else
544  throw();
545 #endif
546  INLINE l_imatrix_subv &operator +=(const rvector_slice &rv)
548 #if(CXSC_INDEX_CHECK)
549  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
550 #else
551  throw();
552 #endif
553  INLINE l_imatrix_subv &operator |=(const rvector &rv)
555 #if(CXSC_INDEX_CHECK)
556  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
557 #else
558  throw();
559 #endif
560  INLINE l_imatrix_subv &operator |=(const rvector_slice &rv)
562 #if(CXSC_INDEX_CHECK)
563  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
564 #else
565  throw();
566 #endif
567  INLINE l_imatrix_subv &operator &=(const rvector &rv)
569 #if(CXSC_INDEX_CHECK)
570  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
571 #else
572  throw();
573 #endif
574  INLINE l_imatrix_subv &operator &=(const rvector_slice &rv)
576 #if(CXSC_INDEX_CHECK)
577  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
578 #else
579  throw();
580 #endif
581  // l_real
583  INLINE l_imatrix_subv &operator *=(const l_real &c) throw();
585  INLINE l_imatrix_subv &operator +=(const l_real &c) throw();
587  INLINE l_imatrix_subv &operator -=(const l_real &c) throw();
589  INLINE l_imatrix_subv &operator /=(const l_real &c) throw();
591  INLINE l_imatrix_subv &operator -=(const l_rvector &rv)
592 #if(CXSC_INDEX_CHECK)
593  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
594 #else
595  throw();
596 #endif
597  INLINE l_imatrix_subv &operator +=(const l_rvector &rv)
599 #if(CXSC_INDEX_CHECK)
600  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
601 #else
602  throw();
603 #endif
604  INLINE l_imatrix_subv &operator -=(const l_rvector_slice &rv)
606 #if(CXSC_INDEX_CHECK)
607  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
608 #else
609  throw();
610 #endif
611  INLINE l_imatrix_subv &operator +=(const l_rvector_slice &rv)
613 #if(CXSC_INDEX_CHECK)
614  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
615 #else
616  throw();
617 #endif
618  INLINE l_imatrix_subv &operator |=(const l_rvector &rv)
620 #if(CXSC_INDEX_CHECK)
621  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
622 #else
623  throw();
624 #endif
625  INLINE l_imatrix_subv &operator |=(const l_rvector_slice &rv)
627 #if(CXSC_INDEX_CHECK)
628  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
629 #else
630  throw();
631 #endif
632  INLINE l_imatrix_subv &operator &=(const l_rvector &rv)
634 #if(CXSC_INDEX_CHECK)
635  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
636 #else
637  throw();
638 #endif
639  INLINE l_imatrix_subv &operator &=(const l_rvector_slice &rv)
641 #if(CXSC_INDEX_CHECK)
642  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
643 #else
644  throw();
645 #endif
646  // interval
648  INLINE l_imatrix_subv &operator *=(const interval &c) throw();
650  INLINE l_imatrix_subv &operator +=(const interval &c) throw();
652  INLINE l_imatrix_subv &operator -=(const interval &c) throw();
654  INLINE l_imatrix_subv &operator /=(const interval &c) throw();
656  INLINE l_imatrix_subv &operator -=(const ivector &rv)
657 #if(CXSC_INDEX_CHECK)
658  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
659 #else
660  throw();
661 #endif
662  INLINE l_imatrix_subv &operator +=(const ivector &rv)
664 #if(CXSC_INDEX_CHECK)
665  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
666 #else
667  throw();
668 #endif
669  INLINE l_imatrix_subv &operator -=(const ivector_slice &rv)
671 #if(CXSC_INDEX_CHECK)
672  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
673 #else
674  throw();
675 #endif
676  INLINE l_imatrix_subv &operator +=(const ivector_slice &rv)
678 #if(CXSC_INDEX_CHECK)
679  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
680 #else
681  throw();
682 #endif
683  INLINE l_imatrix_subv &operator |=(const ivector &rv)
685 #if(CXSC_INDEX_CHECK)
686  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
687 #else
688  throw();
689 #endif
690  INLINE l_imatrix_subv &operator |=(const ivector_slice &rv)
692 #if(CXSC_INDEX_CHECK)
693  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
694 #else
695  throw();
696 #endif
697  INLINE l_imatrix_subv &operator &=(const ivector &rv)
699 #if(CXSC_INDEX_CHECK)
700  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
701 #else
702  throw();
703 #endif
704  INLINE l_imatrix_subv &operator &=(const ivector_slice &rv)
706 #if(CXSC_INDEX_CHECK)
707  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
708 #else
709  throw();
710 #endif
711 //#else
712 //#endif
713 
714 };
715 
716 
717 //----------------------- Matrix -----------------------------------------------
718 
719 class l_imatrix_slice;
720 
722 
726 {
727  friend class l_imatrix_slice;
728  friend class l_imatrix_subv;
729  private:
730  l_interval *dat;
731  int lb1,ub1,lb2,ub2,xsize,ysize;
732 
733  public:
734 //#if(CXSC_INDEX_CHECK)
735 #ifdef _CXSC_FRIEND_TPL
736  //----------------- Templates ---------------------------------------
737 template <class S,class M> friend void _smconstr(S &s,const M &m)
738 #if(CXSC_INDEX_CHECK)
739  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
740 #else
741  throw();
742 #endif
743 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
744 #if(CXSC_INDEX_CHECK)
745  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
746 #else
747  throw();
748 #endif
749  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
750  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
751  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
752 #if(CXSC_INDEX_CHECK)
753  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
754 #else
755  throw();
756 #endif
757  template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
758 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
759 #if(CXSC_INDEX_CHECK)
760  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
761 #else
762  throw();
763 #endif
764 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
765  template <class M> friend int _mlb(const M &m, const int &i)
766 #if(CXSC_INDEX_CHECK)
767  throw(ERROR__WRONG_ROW_OR_COL<M>);
768 #else
769  throw();
770 #endif
771  template <class M> friend int _mub(const M &m, const int &i)
772 #if(CXSC_INDEX_CHECK)
773  throw(ERROR__WRONG_ROW_OR_COL<M>);
774 #else
775  throw();
776 #endif
777  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
778 #if(CXSC_INDEX_CHECK)
779  throw(ERROR__WRONG_ROW_OR_COL<M>);
780 #else
781  throw();
782 #endif
783  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
784 #if(CXSC_INDEX_CHECK)
785  throw(ERROR__WRONG_ROW_OR_COL<M>);
786 #else
787  throw();
788 #endif
789  template <class M> friend void _mresize(M &A) throw();
790  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
791 #if(CXSC_INDEX_CHECK)
792  throw(ERROR__WRONG_BOUNDARIES<M>);
793 #else
794  throw();
795 #endif
796  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
797 #if(CXSC_INDEX_CHECK)
798  throw(ERROR__WRONG_BOUNDARIES<M>);
799 #else
800  throw();
801 #endif
802  template <class M,class E> friend E _mabs(const M &m) throw();
803  template <class MS,class E> friend E _msabs(const MS &ms) throw();
804  template <class M,class E> friend E _mdiam(const M &m) throw();
805  template <class M,class E> friend E _mmid(const M &m) throw();
806  template <class M,class E> friend E _minf(const M &m) throw();
807  template <class M,class E> friend E _msup(const M &m) throw();
808  template <class M1,class M2> friend M1 &_mmsetinf(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 M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
815 #if(CXSC_INDEX_CHECK)
816  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
817 #else
818  throw();
819 #endif
820  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
821 #if(CXSC_INDEX_CHECK)
822  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
823 #else
824  throw();
825 #endif
826  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
827 #if(CXSC_INDEX_CHECK)
828  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
829 #else
830  throw();
831 #endif
832  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
833 #if(CXSC_INDEX_CHECK)
834  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
835 #else
836  throw();
837 #endif
838  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
839 #if(CXSC_INDEX_CHECK)
840  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
841 #else
842  throw();
843 #endif
844  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
845 #if(CXSC_INDEX_CHECK)
846  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
847 #else
848  throw();
849 #endif
850  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
851 #if(CXSC_INDEX_CHECK)
852  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
853 #else
854  throw();
855 #endif
856  //-------------- matrix-matrix -------------
857  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
858 #if(CXSC_INDEX_CHECK)
859  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
860 #else
861  throw();
862 #endif
863  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
864 #if(CXSC_INDEX_CHECK)
865  throw(ERROR__OP_WITH_WRONG_DIM<M>);
866 #else
867  throw();
868 #endif
869  template <class M> friend M _mminus(const M &m) throw();
870  template <class MS,class E> friend E _msminus(const MS &ms) throw();
871  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
872 #if(CXSC_INDEX_CHECK)
873  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
874 #else
875  throw();
876 #endif
877  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
878 #if(CXSC_INDEX_CHECK)
879  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
880 #else
881  throw();
882 #endif
883  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
884 #if(CXSC_INDEX_CHECK)
885  throw(ERROR__OP_WITH_WRONG_DIM<M>);
886 #else
887  throw();
888 #endif
889  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
890 #if(CXSC_INDEX_CHECK)
891  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
892 #else
893  throw();
894 #endif
895  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
896 #if(CXSC_INDEX_CHECK)
897  throw(ERROR__OP_WITH_WRONG_DIM<E>);
898 #else
899  throw();
900 #endif
901  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
902 #if(CXSC_INDEX_CHECK)
903  throw(ERROR__OP_WITH_WRONG_DIM<E>);
904 #else
905  throw();
906 #endif
907  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
908 #if(CXSC_INDEX_CHECK)
909  throw(ERROR__OP_WITH_WRONG_DIM<E>);
910 #else
911  throw();
912 #endif
913  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
914 #if(CXSC_INDEX_CHECK)
915  throw(ERROR__OP_WITH_WRONG_DIM<E>);
916 #else
917  throw();
918 #endif
919  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
920 #if(CXSC_INDEX_CHECK)
921  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
922 #else
923  throw();
924 #endif
925  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
926 #if(CXSC_INDEX_CHECK)
927  throw(ERROR__OP_WITH_WRONG_DIM<M>);
928 #else
929  throw();
930 #endif
931  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
932 #if(CXSC_INDEX_CHECK)
933  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
934 #else
935  throw();
936 #endif
937  template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
938 #if(CXSC_INDEX_CHECK)
939  throw(ERROR__OP_WITH_WRONG_DIM<E>);
940 #else
941  throw();
942 #endif
943  template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
944 #if(CXSC_INDEX_CHECK)
945  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
946 #else
947  throw();
948 #endif
949  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
950 #if(CXSC_INDEX_CHECK)
951  throw(ERROR__OP_WITH_WRONG_DIM<E>);
952 #else
953  throw();
954 #endif
955  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
956 #if(CXSC_INDEX_CHECK)
957  throw(ERROR__OP_WITH_WRONG_DIM<E>);
958 #else
959  throw();
960 #endif
961  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
962 #if(CXSC_INDEX_CHECK)
963  throw(ERROR__OP_WITH_WRONG_DIM<M>);
964 #else
965  throw();
966 #endif
967  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
968 #if(CXSC_INDEX_CHECK)
969  throw(ERROR__OP_WITH_WRONG_DIM<E>);
970 #else
971  throw();
972 #endif
973  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
974 #if(CXSC_INDEX_CHECK)
975  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
976 #else
977  throw();
978 #endif
979  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
980 #if(CXSC_INDEX_CHECK)
981  throw(ERROR__OP_WITH_WRONG_DIM<M>);
982 #else
983  throw();
984 #endif
985  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
986 #if(CXSC_INDEX_CHECK)
987  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
988 #else
989  throw();
990 #endif
991  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
992 #if(CXSC_INDEX_CHECK)
993  throw(ERROR__OP_WITH_WRONG_DIM<M>);
994 #else
995  throw();
996 #endif
997  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
998 #if(CXSC_INDEX_CHECK)
999  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1000 #else
1001  throw();
1002 #endif
1003  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1004 #if(CXSC_INDEX_CHECK)
1005  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1006 #else
1007  throw();
1008 #endif
1009  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
1010 #if(CXSC_INDEX_CHECK)
1011  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1012 #else
1013  throw();
1014 #endif
1015  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1016 #if(CXSC_INDEX_CHECK)
1017  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1018 #else
1019  throw();
1020 #endif
1021  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
1022 #if(CXSC_INDEX_CHECK)
1023  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1024 #else
1025  throw();
1026 #endif
1027  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1028 #if(CXSC_INDEX_CHECK)
1029  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1030 #else
1031  throw();
1032 #endif
1033  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1034 #if(CXSC_INDEX_CHECK)
1035  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1036 #else
1037  throw();
1038 #endif
1039  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1040 #if(CXSC_INDEX_CHECK)
1041  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1042 #else
1043  throw();
1044 #endif
1045  //-------- matrix-scalar -----------------
1046  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
1047  template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
1048  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1049  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
1050  template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
1051  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1052  //-------- matrix-vector ---------------------
1053  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1054 #if(CXSC_INDEX_CHECK)
1055  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1056 #else
1057  throw();
1058 #endif
1059  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1060 #if(CXSC_INDEX_CHECK)
1061  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1062 #else
1063  throw();
1064 #endif
1065  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1066 #if(CXSC_INDEX_CHECK)
1067  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1068 #else
1069  throw();
1070 #endif
1071  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1072 #if(CXSC_INDEX_CHECK)
1073  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1074 #else
1075  throw();
1076 #endif
1077 
1078  template <class M> friend void *_mvoid(const M &m) throw();
1079  template <class M> friend bool _mnot(const M &m) throw();
1080  template <class MS> friend void *_msvoid(const MS &ms) throw();
1081  template <class MS> friend bool _msnot(const MS &ms) throw();
1082  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
1083  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
1084  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
1085  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
1086  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1087  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1088  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1089  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1090  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1091  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1092  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
1093  template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
1094 
1095  //--- Real --------- matrix-scalar ----------------------
1096  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1097 #if(CXSC_INDEX_CHECK)
1098  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1099 #else
1100  throw();
1101 #endif
1102  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1103 #if(CXSC_INDEX_CHECK)
1104  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1105 #else
1106  throw();
1107 #endif
1108 
1109  //--- Real --------- matrix-vector ----------------------
1110  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1111 #if(CXSC_INDEX_CHECK)
1112  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1113 #else
1114  throw();
1115 #endif
1116  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1117 #if(CXSC_INDEX_CHECK)
1118  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1119 #else
1120  throw();
1121 #endif
1122 
1123 
1124 #endif
1125 
1126  //-------------------------- Konstruktoren ----------------------------
1127 
1128 // l_interval
1130  INLINE l_imatrix(const l_imatrix &rm) throw();
1132  INLINE l_imatrix(const l_imatrix_slice &rm) throw();
1134  INLINE l_imatrix() throw();
1136  explicit INLINE l_imatrix(const int &m, const int &n)
1137 #if(CXSC_INDEX_CHECK)
1138  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
1139 #else
1140  throw();
1141 #endif
1142  explicit INLINE l_imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1144 #if(CXSC_INDEX_CHECK)
1145  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
1146 #else
1147  throw();
1148 #endif
1149  explicit INLINE l_imatrix(const l_ivector &v) throw();
1152  explicit INLINE l_imatrix(const l_ivector_slice &v) throw();
1154  explicit INLINE l_imatrix(const l_interval &r) throw();
1156  INLINE l_imatrix &operator =(const l_interval &r) throw();
1158  INLINE l_imatrix &operator =(const l_imatrix &m) throw();
1160  INLINE l_imatrix &operator =(const l_imatrix_slice &ms) throw();
1162  INLINE l_imatrix &operator =(const l_ivector &v) throw();
1164  INLINE l_imatrix &operator =(const l_ivector_slice &v) throw();
1165 // real
1167  explicit INLINE l_imatrix(const real &r) throw();
1169  explicit INLINE l_imatrix(const rmatrix &rm) throw();
1171  explicit INLINE l_imatrix(const rmatrix_slice &rm) throw();
1173  explicit INLINE l_imatrix(const rvector &v) throw();
1175  explicit INLINE l_imatrix(const rvector_slice &v) throw();
1177  INLINE l_imatrix &operator =(const real &r) throw();
1179  INLINE l_imatrix &operator =(const rmatrix &m) throw();
1181  INLINE l_imatrix &operator =(const rmatrix_slice &ms) throw();
1183  INLINE l_imatrix &operator =(const rvector &v) throw();
1185  INLINE l_imatrix &operator =(const rvector_slice &v) throw();
1186 
1187 // l_real
1189  explicit INLINE l_imatrix(const l_real &r) throw();
1191  explicit INLINE l_imatrix(const l_rmatrix &rm) throw();
1193  explicit INLINE l_imatrix(const l_rmatrix_slice &rm) throw();
1195  explicit INLINE l_imatrix(const l_rvector &v) throw();
1197  explicit INLINE l_imatrix(const l_rvector_slice &v) throw();
1199  INLINE l_imatrix &operator =(const l_real &r) throw();
1201  INLINE l_imatrix &operator =(const l_rmatrix &m) throw();
1203  INLINE l_imatrix &operator =(const l_rmatrix_slice &ms) throw();
1205  INLINE l_imatrix &operator =(const l_rvector &v) throw();
1207  INLINE l_imatrix &operator =(const l_rvector_slice &v) throw();
1208 
1209 // interval
1211  explicit INLINE l_imatrix(const interval &r) throw();
1213  explicit INLINE l_imatrix(const imatrix &rm) throw();
1215  explicit INLINE l_imatrix(const imatrix_slice &rm) throw();
1217  explicit INLINE l_imatrix(const ivector &v) throw();
1219  explicit INLINE l_imatrix(const ivector_slice &v) throw();
1221  INLINE l_imatrix &operator =(const interval &r) throw();
1223  INLINE l_imatrix &operator =(const imatrix &m) throw();
1225  INLINE l_imatrix &operator =(const imatrix_slice &ms) throw();
1227  INLINE l_imatrix &operator =(const ivector &v) throw();
1229  INLINE l_imatrix &operator =(const ivector_slice &v) throw();
1230 
1231  //--------------------------- Destruktoren -----------------------------
1232 
1233  INLINE ~l_imatrix() throw() { delete [] dat; }
1234 
1235  //------------------------- Standardfunktionen -------------------------
1236 
1238  INLINE l_imatrix_subv operator [](const int &i) const
1239 #if(CXSC_INDEX_CHECK)
1240  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1241 #else
1242  throw();
1243 #endif
1244  INLINE l_imatrix_subv operator [](const cxscmatrix_column &i) const
1246 #if(CXSC_INDEX_CHECK)
1247  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1248 #else
1249  throw();
1250 #endif
1251  INLINE l_imatrix &operator ()() throw() { return *this; }
1254  INLINE l_imatrix_slice operator ()(const int &m, const int &n)
1255 #if(CXSC_INDEX_CHECK)
1256  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
1257 #else
1258  throw();
1259 #endif
1260  INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1262 #if(CXSC_INDEX_CHECK)
1263  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
1264 #else
1265  throw();
1266 #endif
1267  INLINE operator void*() throw();
1268 //#else
1269 //#endif
1270 };
1271 
1272 
1274 
1280 {
1281  friend class l_imatrix;
1282  private:
1283  l_interval *dat;
1284  int offset1,offset2,mxsize,mysize;
1285  int start1,end1,start2,end2,sxsize,sysize; // slice size
1286 
1287  public:
1288 //#if(CXSC_INDEX_CHECK)
1289 #ifdef _CXSC_FRIEND_TPL
1290  //----------------- Templates ---------------------------------------
1291 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1292 #if(CXSC_INDEX_CHECK)
1293  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1294 #else
1295  throw();
1296 #endif
1297  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1298 #if(CXSC_INDEX_CHECK)
1299  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1300 #else
1301  throw();
1302 #endif
1303  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1304 #if(CXSC_INDEX_CHECK)
1305  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1306 #else
1307  throw();
1308 #endif
1309  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
1310  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
1311  template <class MS> friend int _mslb(const MS &ms, const int &i)
1312 #if(CXSC_INDEX_CHECK)
1313  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1314 #else
1315  throw();
1316 #endif
1317  template <class MS> friend int _msub(const MS &ms, const int &i)
1318 #if(CXSC_INDEX_CHECK)
1319  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1320 #else
1321  throw();
1322 #endif
1323  template <class MS,class E> friend E _msabs(const MS &ms) throw();
1324  template <class MS,class E> friend E _msinf(const MS &ms) throw();
1325  template <class MS,class E> friend E _mssup(const MS &ms) throw();
1326  template <class MS,class E> friend E _msdiam(const MS &ms) throw();
1327  template <class MS,class E> friend E _msmid(const MS &ms) throw();
1328  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
1329 #if(CXSC_INDEX_CHECK)
1330  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1331 #else
1332  throw();
1333 #endif
1334  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
1335 #if(CXSC_INDEX_CHECK)
1336  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1337 #else
1338  throw();
1339 #endif
1340  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1341 #if(CXSC_INDEX_CHECK)
1342  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1343 #else
1344  throw();
1345 #endif
1346  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1347 #if(CXSC_INDEX_CHECK)
1348  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1349 #else
1350  throw();
1351 #endif
1352  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
1353 #if(CXSC_INDEX_CHECK)
1354  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1355 #else
1356  throw();
1357 #endif
1358  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
1359 #if(CXSC_INDEX_CHECK)
1360  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1361 #else
1362  throw();
1363 #endif
1364  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1365 #if(CXSC_INDEX_CHECK)
1366  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1367 #else
1368  throw();
1369 #endif
1370  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1371 #if(CXSC_INDEX_CHECK)
1372  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1373 #else
1374  throw();
1375 #endif
1376  //-------- matrix-matrix --------------
1377  template <class MS,class E> friend E _msminus(const MS &ms) throw();
1378  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1379 #if(CXSC_INDEX_CHECK)
1380  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1381 #else
1382  throw();
1383 #endif
1384  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1385 #if(CXSC_INDEX_CHECK)
1386  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1387 #else
1388  throw();
1389 #endif
1390  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1391 #if(CXSC_INDEX_CHECK)
1392  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1393 #else
1394  throw();
1395 #endif
1396  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1397 #if(CXSC_INDEX_CHECK)
1398  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1399 #else
1400  throw();
1401 #endif
1402  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1403 #if(CXSC_INDEX_CHECK)
1404  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1405 #else
1406  throw();
1407 #endif
1408  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1409 #if(CXSC_INDEX_CHECK)
1410  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1411 #else
1412  throw();
1413 #endif
1414  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1415 #if(CXSC_INDEX_CHECK)
1416  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1417 #else
1418  throw();
1419 #endif
1420  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1421 #if(CXSC_INDEX_CHECK)
1422  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1423 #else
1424  throw();
1425 #endif
1426  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1427 #if(CXSC_INDEX_CHECK)
1428  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1429 #else
1430  throw();
1431 #endif
1432  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1433 #if(CXSC_INDEX_CHECK)
1434  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1435 #else
1436  throw();
1437 #endif
1438  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1439 #if(CXSC_INDEX_CHECK)
1440  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1441 #else
1442  throw();
1443 #endif
1444  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1445 #if(CXSC_INDEX_CHECK)
1446  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1447 #else
1448  throw();
1449 #endif
1450  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1451 #if(CXSC_INDEX_CHECK)
1452  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1453 #else
1454  throw();
1455 #endif
1456  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1457 #if(CXSC_INDEX_CHECK)
1458  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1459 #else
1460  throw();
1461 #endif
1462  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1463 #if(CXSC_INDEX_CHECK)
1464  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1465 #else
1466  throw();
1467 #endif
1468  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1469 #if(CXSC_INDEX_CHECK)
1470  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1471 #else
1472  throw();
1473 #endif
1474  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1475 #if(CXSC_INDEX_CHECK)
1476  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1477 #else
1478  throw();
1479 #endif
1480  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1481 #if(CXSC_INDEX_CHECK)
1482  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1483 #else
1484  throw();
1485 #endif
1486  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1487 #if(CXSC_INDEX_CHECK)
1488  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1489 #else
1490  throw();
1491 #endif
1492  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1493 #if(CXSC_INDEX_CHECK)
1494  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1495 #else
1496  throw();
1497 #endif
1498  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1499 #if(CXSC_INDEX_CHECK)
1500  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1501 #else
1502  throw();
1503 #endif
1504  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1505 #if(CXSC_INDEX_CHECK)
1506  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1507 #else
1508  throw();
1509 #endif
1510  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1511 #if(CXSC_INDEX_CHECK)
1512  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1513 #else
1514  throw();
1515 #endif
1516  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1517 #if(CXSC_INDEX_CHECK)
1518  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1519 #else
1520  throw();
1521 #endif
1522  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1523 #if(CXSC_INDEX_CHECK)
1524  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1525 #else
1526  throw();
1527 #endif
1528  //--------- matrix-vector --------------
1529  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1530 #if(CXSC_INDEX_CHECK)
1531  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1532 #else
1533  throw();
1534 #endif
1535  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1536 #if(CXSC_INDEX_CHECK)
1537  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1538 #else
1539  throw();
1540 #endif
1541  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1542 #if(CXSC_INDEX_CHECK)
1543  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1544 #else
1545  throw();
1546 #endif
1547  //--------- matrix-scalar --------------
1548  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1549  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
1550  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1551  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
1552 
1553  template <class MS> friend void *_msvoid(const MS &ms) throw();
1554  template <class MS> friend bool _msnot(const MS &ms) throw();
1555  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1556  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1557  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1558  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1559  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1560  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1561  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
1562  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
1563  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
1564  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
1565  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
1566  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
1567 
1568 
1569 #endif
1570 
1571  //--------------- Konstruktoren ----------------------------------------
1572 
1574  explicit INLINE l_imatrix_slice(l_imatrix &a,const int &l1,const int &u1,const int &l2, const int &u2) 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) { }
1576  explicit INLINE l_imatrix_slice(l_imatrix_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) { }
1577  public:
1579  INLINE l_imatrix_slice(const l_imatrix_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) { }
1580  public:
1581 
1582  //---------------- Standardfunktionen -----------------------------------
1583 
1584  friend INLINE l_ivector::l_ivector(const l_imatrix_slice &sl)
1585 #if(CXSC_INDEX_CHECK)
1586  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1587 #else
1588  throw();
1589 #endif
1590  friend INLINE l_imatrix::l_imatrix(const l_imatrix_slice &) throw();
1592  INLINE l_imatrix_slice &operator =(const l_imatrix &m)
1593 #if(CXSC_INDEX_CHECK)
1594  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1595 #else
1596  throw();
1597 #endif
1598  INLINE l_imatrix_slice &operator =(const l_imatrix_slice &ms)
1600 #if(CXSC_INDEX_CHECK)
1601  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1602 #else
1603  throw();
1604 #endif
1605  INLINE l_imatrix_slice &operator =(const l_interval &r) throw();
1608  INLINE l_imatrix_slice &operator =(const l_ivector &v)
1609 #if(CXSC_INDEX_CHECK)
1610  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1611 #else
1612  throw();
1613 #endif
1614  INLINE l_imatrix_slice &operator =(const l_ivector_slice &v)
1616 #if(CXSC_INDEX_CHECK)
1617  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1618 #else
1619  throw();
1620 #endif
1621  INLINE l_imatrix_slice &operator =(const l_imatrix_subv &v)
1623 #if(CXSC_INDEX_CHECK)
1624  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1625 #else
1626  throw();
1627 #endif
1628  // real
1630  INLINE l_imatrix_slice &operator =(const rmatrix &m)
1631 #if(CXSC_INDEX_CHECK)
1632  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1633 #else
1634  throw();
1635 #endif
1636  INLINE l_imatrix_slice &operator =(const rmatrix_slice &ms)
1638 #if(CXSC_INDEX_CHECK)
1639  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1640 #else
1641  throw();
1642 #endif
1643  INLINE l_imatrix_slice &operator =(const real &r) throw();
1646  INLINE l_imatrix_slice &operator =(const rvector &v)
1647 #if(CXSC_INDEX_CHECK)
1648  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1649 #else
1650  throw();
1651 #endif
1652  INLINE l_imatrix_slice &operator =(const rvector_slice &v)
1654 #if(CXSC_INDEX_CHECK)
1655  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1656 #else
1657  throw();
1658 #endif
1659  INLINE l_imatrix_slice &operator =(const rmatrix_subv &v)
1661 #if(CXSC_INDEX_CHECK)
1662  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1663 #else
1664  throw();
1665 #endif
1666 
1667  // interval
1669  INLINE l_imatrix_slice &operator =(const imatrix &m)
1670 #if(CXSC_INDEX_CHECK)
1671  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1672 #else
1673  throw();
1674 #endif
1675  INLINE l_imatrix_slice &operator =(const imatrix_slice &ms)
1677 #if(CXSC_INDEX_CHECK)
1678  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1679 #else
1680  throw();
1681 #endif
1682  INLINE l_imatrix_slice &operator =(const interval &r) throw();
1685  INLINE l_imatrix_slice &operator =(const ivector &v)
1686 #if(CXSC_INDEX_CHECK)
1687  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1688 #else
1689  throw();
1690 #endif
1691  INLINE l_imatrix_slice &operator =(const ivector_slice &v)
1693 #if(CXSC_INDEX_CHECK)
1694  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1695 #else
1696  throw();
1697 #endif
1698  INLINE l_imatrix_slice &operator =(const imatrix_subv &v)
1700 #if(CXSC_INDEX_CHECK)
1701  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1702 #else
1703  throw();
1704 #endif
1705 
1706  // l_real
1708  INLINE l_imatrix_slice &operator =(const l_rmatrix &m)
1709 #if(CXSC_INDEX_CHECK)
1710  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1711 #else
1712  throw();
1713 #endif
1714  INLINE l_imatrix_slice &operator =(const l_rmatrix_slice &ms)
1716 #if(CXSC_INDEX_CHECK)
1717  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1718 #else
1719  throw();
1720 #endif
1721  INLINE l_imatrix_slice &operator =(const l_real &r) throw();
1724  INLINE l_imatrix_slice &operator =(const l_rvector &v)
1725 #if(CXSC_INDEX_CHECK)
1726  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1727 #else
1728  throw();
1729 #endif
1730  INLINE l_imatrix_slice &operator =(const l_rvector_slice &v)
1732 #if(CXSC_INDEX_CHECK)
1733  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1734 #else
1735  throw();
1736 #endif
1737  INLINE l_imatrix_slice &operator =(const l_rmatrix_subv &v)
1739 #if(CXSC_INDEX_CHECK)
1740  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1741 #else
1742  throw();
1743 #endif
1744 
1746  INLINE l_imatrix_subv operator [](const int &i)
1747 #if(CXSC_INDEX_CHECK)
1748  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1749 #else
1750  throw();
1751 #endif
1752  INLINE l_imatrix_subv operator [](const cxscmatrix_column &i)
1754 #if(CXSC_INDEX_CHECK)
1755  throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1756 #else
1757  throw();
1758 #endif
1759  INLINE l_imatrix_slice &operator ()() throw() { return *this; }
1762  INLINE l_imatrix_slice operator ()(const int &m, const int &n)
1763 #if(CXSC_INDEX_CHECK)
1764  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
1765 #else
1766  throw();
1767 #endif
1768  INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1770 #if(CXSC_INDEX_CHECK)
1771  throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
1772 #else
1773  throw();
1774 #endif
1775  INLINE operator void*() throw();
1776 
1778  INLINE l_imatrix_slice &operator +=(const l_interval &c) throw();
1780  INLINE l_imatrix_slice &operator -=(const l_interval &c) throw();
1782  INLINE l_imatrix_slice &operator *=(const l_interval &c) throw();
1784  INLINE l_imatrix_slice &operator /=(const l_interval &c) throw();
1786  INLINE l_imatrix_slice &operator +=(const l_imatrix &m1)
1787 #if(CXSC_INDEX_CHECK)
1788  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1789 #else
1790  throw();
1791 #endif
1792  INLINE l_imatrix_slice &operator +=(const l_imatrix_slice &ms2)
1794 #if(CXSC_INDEX_CHECK)
1795  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1796 #else
1797  throw();
1798 #endif
1799  INLINE l_imatrix_slice &operator -=(const l_imatrix &m1)
1801 #if(CXSC_INDEX_CHECK)
1802  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1803 #else
1804  throw();
1805 #endif
1806  INLINE l_imatrix_slice &operator -=(const l_imatrix_slice &ms2)
1808 #if(CXSC_INDEX_CHECK)
1809  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1810 #else
1811  throw();
1812 #endif
1813  INLINE l_imatrix_slice &operator |=(const l_imatrix &m1)
1815 #if(CXSC_INDEX_CHECK)
1816  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1817 #else
1818  throw();
1819 #endif
1820  INLINE l_imatrix_slice &operator |=(const l_imatrix_slice &ms2)
1822 #if(CXSC_INDEX_CHECK)
1823  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1824 #else
1825  throw();
1826 #endif
1827  INLINE l_imatrix_slice &operator &=(const l_imatrix &m1)
1829 #if(CXSC_INDEX_CHECK)
1830  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1831 #else
1832  throw();
1833 #endif
1834  INLINE l_imatrix_slice &operator &=(const l_imatrix_slice &ms2)
1836 #if(CXSC_INDEX_CHECK)
1837  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1838 #else
1839  throw();
1840 #endif
1841  INLINE l_imatrix_slice &operator *=(const l_imatrix &m)
1843 #if(CXSC_INDEX_CHECK)
1844  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1845 #else
1846  throw();
1847 #endif
1848  INLINE l_imatrix_slice &operator *=(const l_imatrix_slice &ms2)
1850 #if(CXSC_INDEX_CHECK)
1851  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1852 #else
1853  throw();
1854 #endif
1855 
1857  INLINE l_imatrix_slice &operator +=(const real &c) throw();
1859  INLINE l_imatrix_slice &operator -=(const real &c) throw();
1861  INLINE l_imatrix_slice &operator *=(const real &c) throw();
1863  INLINE l_imatrix_slice &operator /=(const real &c) throw();
1865  INLINE l_imatrix_slice &operator +=(const rmatrix_slice &ms2)
1866 #if(CXSC_INDEX_CHECK)
1867  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1868 #else
1869  throw();
1870 #endif
1871  INLINE l_imatrix_slice &operator +=(const rmatrix &m1)
1873 #if(CXSC_INDEX_CHECK)
1874  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1875 #else
1876  throw();
1877 #endif
1878  INLINE l_imatrix_slice &operator -=(const rmatrix &m1)
1880 #if(CXSC_INDEX_CHECK)
1881  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1882 #else
1883  throw();
1884 #endif
1885  INLINE l_imatrix_slice &operator -=(const rmatrix_slice &ms2)
1887 #if(CXSC_INDEX_CHECK)
1888  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1889 #else
1890  throw();
1891 #endif
1892  INLINE l_imatrix_slice &operator |=(const rmatrix &m1)
1894 #if(CXSC_INDEX_CHECK)
1895  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1896 #else
1897  throw();
1898 #endif
1899  INLINE l_imatrix_slice &operator |=(const rmatrix_slice &ms2)
1901 #if(CXSC_INDEX_CHECK)
1902  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1903 #else
1904  throw();
1905 #endif
1906  INLINE l_imatrix_slice &operator &=(const rmatrix &m1)
1908 #if(CXSC_INDEX_CHECK)
1909  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1910 #else
1911  throw();
1912 #endif
1913  INLINE l_imatrix_slice &operator &=(const rmatrix_slice &ms2)
1915 #if(CXSC_INDEX_CHECK)
1916  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1917 #else
1918  throw();
1919 #endif
1920  INLINE l_imatrix_slice &operator *=(const rmatrix &m)
1922 #if(CXSC_INDEX_CHECK)
1923  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1924 #else
1925  throw();
1926 #endif
1927  INLINE l_imatrix_slice &operator *=(const rmatrix_slice &ms2)
1929 #if(CXSC_INDEX_CHECK)
1930  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1931 #else
1932  throw();
1933 #endif
1934 
1936  INLINE l_imatrix_slice &operator +=(const l_real &c) throw();
1938  INLINE l_imatrix_slice &operator -=(const l_real &c) throw();
1940  INLINE l_imatrix_slice &operator *=(const l_real &c) throw();
1942  INLINE l_imatrix_slice &operator /=(const l_real &c) throw();
1944  INLINE l_imatrix_slice &operator +=(const l_rmatrix_slice &ms2)
1945 #if(CXSC_INDEX_CHECK)
1946  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1947 #else
1948  throw();
1949 #endif
1950  INLINE l_imatrix_slice &operator +=(const l_rmatrix &m1)
1952 #if(CXSC_INDEX_CHECK)
1953  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1954 #else
1955  throw();
1956 #endif
1957  INLINE l_imatrix_slice &operator -=(const l_rmatrix &m1)
1959 #if(CXSC_INDEX_CHECK)
1960  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1961 #else
1962  throw();
1963 #endif
1964  INLINE l_imatrix_slice &operator -=(const l_rmatrix_slice &ms2)
1966 #if(CXSC_INDEX_CHECK)
1967  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1968 #else
1969  throw();
1970 #endif
1971  INLINE l_imatrix_slice &operator |=(const l_rmatrix &m1)
1973 #if(CXSC_INDEX_CHECK)
1974  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1975 #else
1976  throw();
1977 #endif
1978  INLINE l_imatrix_slice &operator |=(const l_rmatrix_slice &ms2)
1980 #if(CXSC_INDEX_CHECK)
1981  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1982 #else
1983  throw();
1984 #endif
1985  INLINE l_imatrix_slice &operator &=(const l_rmatrix &m1)
1987 #if(CXSC_INDEX_CHECK)
1988  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1989 #else
1990  throw();
1991 #endif
1992  INLINE l_imatrix_slice &operator &=(const l_rmatrix_slice &ms2)
1994 #if(CXSC_INDEX_CHECK)
1995  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1996 #else
1997  throw();
1998 #endif
1999  INLINE l_imatrix_slice &operator *=(const l_rmatrix &m)
2001 #if(CXSC_INDEX_CHECK)
2002  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2003 #else
2004  throw();
2005 #endif
2006  INLINE l_imatrix_slice &operator *=(const l_rmatrix_slice &ms2)
2008 #if(CXSC_INDEX_CHECK)
2009  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2010 #else
2011  throw();
2012 #endif
2013 
2015  INLINE l_imatrix_slice &operator +=(const interval &c) throw();
2017  INLINE l_imatrix_slice &operator -=(const interval &c) throw();
2019  INLINE l_imatrix_slice &operator *=(const interval &c) throw();
2021  INLINE l_imatrix_slice &operator /=(const interval &c) throw();
2023  INLINE l_imatrix_slice &operator +=(const imatrix_slice &ms2)
2024 #if(CXSC_INDEX_CHECK)
2025  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2026 #else
2027  throw();
2028 #endif
2029  INLINE l_imatrix_slice &operator +=(const imatrix &m1)
2031 #if(CXSC_INDEX_CHECK)
2032  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2033 #else
2034  throw();
2035 #endif
2036  INLINE l_imatrix_slice &operator -=(const imatrix &m1)
2038 #if(CXSC_INDEX_CHECK)
2039  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2040 #else
2041  throw();
2042 #endif
2043  INLINE l_imatrix_slice &operator -=(const imatrix_slice &ms2)
2045 #if(CXSC_INDEX_CHECK)
2046  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2047 #else
2048  throw();
2049 #endif
2050  INLINE l_imatrix_slice &operator |=(const imatrix &m1)
2052 #if(CXSC_INDEX_CHECK)
2053  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2054 #else
2055  throw();
2056 #endif
2057  INLINE l_imatrix_slice &operator |=(const imatrix_slice &ms2)
2059 #if(CXSC_INDEX_CHECK)
2060  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2061 #else
2062  throw();
2063 #endif
2064  INLINE l_imatrix_slice &operator &=(const imatrix &m1)
2066 #if(CXSC_INDEX_CHECK)
2067  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2068 #else
2069  throw();
2070 #endif
2071  INLINE l_imatrix_slice &operator &=(const imatrix_slice &ms2)
2073 #if(CXSC_INDEX_CHECK)
2074  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2075 #else
2076  throw();
2077 #endif
2078  INLINE l_imatrix_slice &operator *=(const imatrix &m)
2080 #if(CXSC_INDEX_CHECK)
2081  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2082 #else
2083  throw();
2084 #endif
2085  INLINE l_imatrix_slice &operator *=(const imatrix_slice &ms2)
2087 #if(CXSC_INDEX_CHECK)
2088  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2089 #else
2090  throw();
2091 #endif
2092 
2093 //#else
2094 //#endif
2095 };
2096 
2097 //================================================================
2098 //====================== Subvector Functions =====================
2099 
2100 //=======================Vector / Scalar =========================
2101 
2103  INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) throw();
2105  INLINE l_ivector operator *(const l_imatrix_subv &rv, const l_interval &s) throw();
2107  INLINE l_ivector operator *(const l_interval &s, const l_imatrix_subv &rv) throw();
2109  INLINE l_ivector abs(const l_imatrix_subv &mv) throw();
2111  INLINE l_rvector diam(const l_imatrix_subv &mv) throw();
2113  INLINE l_rvector mid(const l_imatrix_subv &mv) throw();
2115  INLINE l_rvector Inf(const l_imatrix_subv &mv) throw();
2117  INLINE l_rvector Sup(const l_imatrix_subv &mv) throw();
2119  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_rvector &rv)
2120 #if(CXSC_INDEX_CHECK)
2121  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2122 #else
2123  throw();
2124 #endif
2125  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_rvector &rv)
2127 #if(CXSC_INDEX_CHECK)
2128  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2129 #else
2130  throw();
2131 #endif
2132  INLINE l_imatrix_subv &UncheckedSetInf(l_imatrix_subv &iv,const l_rvector &rv)
2134 #if(CXSC_INDEX_CHECK)
2135  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2136 #else
2137  throw();
2138 #endif
2139  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_rvector &rv)
2141 #if(CXSC_INDEX_CHECK)
2142  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2143 #else
2144  throw();
2145 #endif
2146 
2148  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) throw();
2150  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) throw();
2152  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) throw();
2154  INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) throw();
2155 
2156 //======================== Vector / Vector ========================
2157 
2158 
2160  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2161 #if(CXSC_INDEX_CHECK)
2162  throw(OP_WITH_WRONG_DIM);
2163 #else
2164  throw();
2165 #endif
2166  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
2168 #if(CXSC_INDEX_CHECK)
2169  throw(OP_WITH_WRONG_DIM);
2170 #else
2171  throw();
2172 #endif
2173  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
2175 #if(CXSC_INDEX_CHECK)
2176  throw(OP_WITH_WRONG_DIM);
2177 #else
2178  throw();
2179 #endif
2180  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_imatrix_subv &rv2)
2182 #if(CXSC_INDEX_CHECK)
2183  throw(OP_WITH_WRONG_DIM);
2184 #else
2185  throw();
2186 #endif
2187  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector_slice &sl2)
2189 #if(CXSC_INDEX_CHECK)
2190  throw(OP_WITH_WRONG_DIM);
2191 #else
2192  throw();
2193 #endif
2194 
2196  INLINE l_interval operator *(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2197 #if(CXSC_INDEX_CHECK)
2198  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2199 #else
2200  throw();
2201 #endif
2202  INLINE l_interval operator *(const l_ivector & rv1, const l_imatrix_subv &rv2)
2204 #if(CXSC_INDEX_CHECK)
2205  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2206 #else
2207  throw();
2208 #endif
2209  INLINE l_interval operator *(const l_imatrix_subv &rv1,const l_ivector &rv2)
2211 #if(CXSC_INDEX_CHECK)
2212  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2213 #else
2214  throw();
2215 #endif
2216  INLINE l_interval operator *(const l_ivector_slice &sl,const l_imatrix_subv &sv)
2218 #if(CXSC_INDEX_CHECK)
2219  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2220 #else
2221  throw();
2222 #endif
2223  INLINE l_interval operator *(const l_imatrix_subv &mv,const l_ivector_slice &vs)
2225 #if(CXSC_INDEX_CHECK)
2226  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2227 #else
2228  throw();
2229 #endif
2230 
2232  INLINE l_ivector operator +(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2233 #if(CXSC_INDEX_CHECK)
2234  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2235 #else
2236  throw();
2237 #endif
2238  INLINE l_ivector operator +(const l_imatrix_subv &rv1,const l_ivector &rv2)
2240 #if(CXSC_INDEX_CHECK)
2241  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2242 #else
2243  throw();
2244 #endif
2245  INLINE l_ivector operator +(const l_ivector & rv1, const l_imatrix_subv &rv2)
2247 #if(CXSC_INDEX_CHECK)
2248  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2249 #else
2250  throw();
2251 #endif
2252  INLINE l_ivector operator +(const l_ivector_slice &sl,const l_imatrix_subv &mv)
2254 #if(CXSC_INDEX_CHECK)
2255  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2256 #else
2257  throw();
2258 #endif
2259  INLINE l_ivector operator +(const l_imatrix_subv &mv,const l_ivector_slice &sl)
2261 #if(CXSC_INDEX_CHECK)
2262  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2263 #else
2264  throw();
2265 #endif
2266 
2268  INLINE l_ivector operator -(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2269 #if(CXSC_INDEX_CHECK)
2270  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2271 #else
2272  throw();
2273 #endif
2274  INLINE l_ivector operator -(const l_ivector & rv1, const l_imatrix_subv &rv2)
2276 #if(CXSC_INDEX_CHECK)
2277  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2278 #else
2279  throw();
2280 #endif
2281  INLINE l_ivector operator -(const l_imatrix_subv &rv1,const l_ivector &rv2)
2283 #if(CXSC_INDEX_CHECK)
2284  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2285 #else
2286  throw();
2287 #endif
2288  INLINE l_ivector operator -(const l_ivector_slice &sl,const l_imatrix_subv &mv)
2290 #if(CXSC_INDEX_CHECK)
2291  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2292 #else
2293  throw();
2294 #endif
2295  INLINE l_ivector operator -(const l_imatrix_subv &mv,const l_ivector_slice &sl)
2297 #if(CXSC_INDEX_CHECK)
2298  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
2299 #else
2300  throw();
2301 #endif
2302 
2303 // real
2304 
2306  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rmatrix_subv &rv2)
2307 #if(CXSC_INDEX_CHECK)
2308  throw(OP_WITH_WRONG_DIM);
2309 #else
2310  throw();
2311 #endif
2312  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector_slice &sl2)
2314 #if(CXSC_INDEX_CHECK)
2315  throw(OP_WITH_WRONG_DIM);
2316 #else
2317  throw();
2318 #endif
2319  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
2321 #if(CXSC_INDEX_CHECK)
2322  throw(OP_WITH_WRONG_DIM);
2323 #else
2324  throw();
2325 #endif
2326  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
2328 #if(CXSC_INDEX_CHECK)
2329  throw(OP_WITH_WRONG_DIM);
2330 #else
2331  throw();
2332 #endif
2333  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_imatrix_subv &rv2)
2335 #if(CXSC_INDEX_CHECK)
2336  throw(OP_WITH_WRONG_DIM);
2337 #else
2338  throw();
2339 #endif
2340  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_imatrix_subv &rv2)
2342 #if(CXSC_INDEX_CHECK)
2343  throw(OP_WITH_WRONG_DIM);
2344 #else
2345  throw();
2346 #endif
2347 
2348 // l_real
2349 
2351  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rmatrix_subv &rv2)
2352 #if(CXSC_INDEX_CHECK)
2353  throw(OP_WITH_WRONG_DIM);
2354 #else
2355  throw();
2356 #endif
2357  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector_slice &sl2)
2359 #if(CXSC_INDEX_CHECK)
2360  throw(OP_WITH_WRONG_DIM);
2361 #else
2362  throw();
2363 #endif
2364  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
2366 #if(CXSC_INDEX_CHECK)
2367  throw(OP_WITH_WRONG_DIM);
2368 #else
2369  throw();
2370 #endif
2371  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
2373 #if(CXSC_INDEX_CHECK)
2374  throw(OP_WITH_WRONG_DIM);
2375 #else
2376  throw();
2377 #endif
2378  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_imatrix_subv &rv2)
2380 #if(CXSC_INDEX_CHECK)
2381  throw(OP_WITH_WRONG_DIM);
2382 #else
2383  throw();
2384 #endif
2385  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_imatrix_subv &rv2)
2387 #if(CXSC_INDEX_CHECK)
2388  throw(OP_WITH_WRONG_DIM);
2389 #else
2390  throw();
2391 #endif
2392 
2393 // interval
2394 
2396  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const imatrix_subv &rv2)
2397 #if(CXSC_INDEX_CHECK)
2398  throw(OP_WITH_WRONG_DIM);
2399 #else
2400  throw();
2401 #endif
2402  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector_slice &sl2)
2404 #if(CXSC_INDEX_CHECK)
2405  throw(OP_WITH_WRONG_DIM);
2406 #else
2407  throw();
2408 #endif
2409  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
2411 #if(CXSC_INDEX_CHECK)
2412  throw(OP_WITH_WRONG_DIM);
2413 #else
2414  throw();
2415 #endif
2416  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
2418 #if(CXSC_INDEX_CHECK)
2419  throw(OP_WITH_WRONG_DIM);
2420 #else
2421  throw();
2422 #endif
2423  INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_imatrix_subv &rv2)
2425 #if(CXSC_INDEX_CHECK)
2426  throw(OP_WITH_WRONG_DIM);
2427 #else
2428  throw();
2429 #endif
2430  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_imatrix_subv &rv2)
2432 #if(CXSC_INDEX_CHECK)
2433  throw(OP_WITH_WRONG_DIM);
2434 #else
2435  throw();
2436 #endif
2437 
2438 
2439 //====================================================================
2440 //===================== Matrix Functions =============================
2441 
2443  INLINE l_imatrix _imatrix(const l_imatrix &rm) throw();
2445  INLINE l_imatrix _imatrix(const l_ivector &v) throw();
2447  INLINE l_imatrix _imatrix(const l_ivector_slice &v) throw();
2449  INLINE l_imatrix _imatrix(const l_interval &r) throw();
2450 
2452  INLINE int Lb(const l_imatrix &rm, const int &i)
2453 #if(CXSC_INDEX_CHECK)
2454  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
2455 #else
2456  throw();
2457 #endif
2458  INLINE int Ub(const l_imatrix &rm, const int &i)
2460 #if(CXSC_INDEX_CHECK)
2461  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
2462 #else
2463  throw();
2464 #endif
2465  INLINE int Lb(const l_imatrix_slice &rm, const int &i)
2467 #if(CXSC_INDEX_CHECK)
2468  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
2469 #else
2470  throw();
2471 #endif
2472  INLINE int Ub(const l_imatrix_slice &rm, const int &i)
2474 #if(CXSC_INDEX_CHECK)
2475  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
2476 #else
2477  throw();
2478 #endif
2479  INLINE l_imatrix &SetLb(l_imatrix &m, const int &i,const int &j)
2481 #if(CXSC_INDEX_CHECK)
2482  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
2483 #else
2484  throw();
2485 #endif
2486  INLINE l_imatrix &SetUb(l_imatrix &m, const int &i,const int &j)
2488 #if(CXSC_INDEX_CHECK)
2489  throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
2490 #else
2491  throw();
2492 #endif
2493  INLINE void Resize(l_imatrix &A) throw();
2496  INLINE void Resize(l_imatrix &A,const int &m, const int &n)
2497 #if(CXSC_INDEX_CHECK)
2498  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
2499 #else
2500  throw();
2501 #endif
2502  INLINE void Resize(l_imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2504 #if(CXSC_INDEX_CHECK)
2505  throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
2506 #else
2507  throw();
2508 #endif
2509 
2511  INLINE l_imatrix abs(const l_imatrix &m) throw();
2513  INLINE l_imatrix abs(const l_imatrix_slice &ms) throw();
2515  INLINE l_rmatrix diam(const l_imatrix &m) throw();
2517  INLINE l_rmatrix diam(const l_imatrix_slice &m) throw();
2519  INLINE l_rmatrix mid(const l_imatrix &m) throw();
2521  INLINE l_rmatrix mid(const l_imatrix_slice &m) throw();
2523  INLINE l_rmatrix Inf(const l_imatrix &m) throw();
2525  INLINE l_rmatrix Sup(const l_imatrix &m) throw();
2527  INLINE l_rmatrix Inf(const l_imatrix_slice &m) throw();
2529  INLINE l_rmatrix Sup(const l_imatrix_slice &m) throw();
2531  INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix &rm)
2532 #if(CXSC_INDEX_CHECK)
2533  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2534 #else
2535  throw();
2536 #endif
2537  INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
2539 #if(CXSC_INDEX_CHECK)
2540  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2541 #else
2542  throw();
2543 #endif
2544  INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
2546 #if(CXSC_INDEX_CHECK)
2547  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2548 #else
2549  throw();
2550 #endif
2551  INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2553 #if(CXSC_INDEX_CHECK)
2554  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2555 #else
2556  throw();
2557 #endif
2558  INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix &rm)
2560 #if(CXSC_INDEX_CHECK)
2561  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2562 #else
2563  throw();
2564 #endif
2565  INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
2567 #if(CXSC_INDEX_CHECK)
2568  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2569 #else
2570  throw();
2571 #endif
2572  INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
2574 #if(CXSC_INDEX_CHECK)
2575  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2576 #else
2577  throw();
2578 #endif
2579  INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2581 #if(CXSC_INDEX_CHECK)
2582  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2583 #else
2584  throw();
2585 #endif
2586  INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix &rm)
2588 #if(CXSC_INDEX_CHECK)
2589  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2590 #else
2591  throw();
2592 #endif
2593  INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
2595 #if(CXSC_INDEX_CHECK)
2596  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2597 #else
2598  throw();
2599 #endif
2600  INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
2602 #if(CXSC_INDEX_CHECK)
2603  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2604 #else
2605  throw();
2606 #endif
2607  INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2609 #if(CXSC_INDEX_CHECK)
2610  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2611 #else
2612  throw();
2613 #endif
2614  INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix &rm)
2616 #if(CXSC_INDEX_CHECK)
2617  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2618 #else
2619  throw();
2620 #endif
2621  INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
2623 #if(CXSC_INDEX_CHECK)
2624  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2625 #else
2626  throw();
2627 #endif
2628  INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
2630 #if(CXSC_INDEX_CHECK)
2631  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2632 #else
2633  throw();
2634 #endif
2635  INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2637 #if(CXSC_INDEX_CHECK)
2638  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2639 #else
2640  throw();
2641 #endif
2642 
2643 //===================== Matrix / Scalar ===============================
2644 
2646  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) throw();
2648  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) throw();
2650  INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) throw();
2652  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) throw();
2654  INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) throw();
2656  INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) throw();
2658  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) throw();
2660  INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) throw();
2661 
2662 //------------ real - l_imatrix -----------------------------------------------
2663 
2665  INLINE l_imatrix operator *(const real &c, const l_imatrix &m) throw();
2667  INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) throw();
2669  INLINE l_imatrix operator *(const l_imatrix &m,const real &c) throw();
2671  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) throw();
2673  INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) throw();
2675  INLINE l_imatrix operator /(const l_imatrix &m,const real &c) throw();
2677  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) throw();
2679  INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) throw();
2680 //----------------- rmatrix - l_interval ----------------
2681 
2683  INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) throw();
2685  INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) throw();
2687  INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) throw();
2689  INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) throw();
2691  INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) throw();
2693  INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) throw();
2694 
2695 //------------ l_real - l_imatrix -----------------------------------------------
2696 
2698  INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) throw();
2700  INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) throw();
2702  INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) throw();
2704  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) throw();
2706  INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) throw();
2708  INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) throw();
2710  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) throw();
2712  INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) throw();
2713 //----------------- l_rmatrix - l_interval ----------------
2714 
2716  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) throw();
2718  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) throw();
2720  INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) throw();
2722  INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) throw();
2724  INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) throw();
2726  INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) throw();
2727 
2728 //------------ interval - l_imatrix -----------------------------------------------
2729 
2731  INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) throw();
2733  INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) throw();
2735  INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) throw();
2737  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) throw();
2739  INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) throw();
2741  INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) throw();
2743  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) throw();
2745  INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) throw();
2746 //----------------- imatrix - l_interval ----------------
2747 
2749  INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) throw();
2751  INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) throw();
2753  INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) throw();
2755  INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) throw();
2757  INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) throw();
2759  INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) throw();
2760 
2761 
2762 //============================ Matrix / Vector ===================================
2763 
2764 
2766  INLINE l_ivector operator *(const l_imatrix &m,const l_ivector &v)
2767 #if(CXSC_INDEX_CHECK)
2768  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2769 #else
2770  throw();
2771 #endif
2772  INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_ivector &v)
2774 #if(CXSC_INDEX_CHECK)
2775  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2776 #else
2777  throw();
2778 #endif
2779  INLINE l_ivector operator *(const l_ivector &v,const l_imatrix &m)
2781 #if(CXSC_INDEX_CHECK)
2782  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2783 #else
2784  throw();
2785 #endif
2786  INLINE l_ivector operator *(const l_ivector &v,const l_imatrix_slice &ms)
2788 #if(CXSC_INDEX_CHECK)
2789  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2790 #else
2791  throw();
2792 #endif
2793  INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix &m)
2795 #if(CXSC_INDEX_CHECK)
2796  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2797 #else
2798  throw();
2799 #endif
2800  INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix_slice &ms)
2802 #if(CXSC_INDEX_CHECK)
2803  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2804 #else
2805  throw();
2806 #endif
2807 
2809  INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix &m)
2810 #if(CXSC_INDEX_CHECK)
2811  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2812 #else
2813  throw();
2814 #endif
2815  INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix_slice &m)
2817 #if(CXSC_INDEX_CHECK)
2818  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2819 #else
2820  throw();
2821 #endif
2822 
2823 //----------------- real -------------------------------------
2824 
2826  INLINE l_ivector operator *(const rvector &v,const l_imatrix &m)
2827 #if(CXSC_INDEX_CHECK)
2828  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2829 #else
2830  throw();
2831 #endif
2832  INLINE l_ivector operator *(const rvector &v,const l_imatrix_slice &ms)
2834 #if(CXSC_INDEX_CHECK)
2835  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2836 #else
2837  throw();
2838 #endif
2839  INLINE l_ivector operator *(const rvector_slice &v,const l_imatrix &m)
2841 #if(CXSC_INDEX_CHECK)
2842  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2843 #else
2844  throw();
2845 #endif
2846 
2848  INLINE l_ivector operator *(const l_imatrix &m,const rvector &v)
2849 #if(CXSC_INDEX_CHECK)
2850  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2851 #else
2852  throw();
2853 #endif
2854  INLINE l_ivector operator *(const l_imatrix_slice &ms,const rvector &v)
2856 #if(CXSC_INDEX_CHECK)
2857  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2858 #else
2859  throw();
2860 #endif
2861 
2862 //----------------- l_real -------------------------------------
2863 
2865  INLINE l_ivector operator *(const l_rvector &v,const l_imatrix &m)
2866 #if(CXSC_INDEX_CHECK)
2867  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2868 #else
2869  throw();
2870 #endif
2871  INLINE l_ivector operator *(const l_rvector &v,const l_imatrix_slice &ms)
2873 #if(CXSC_INDEX_CHECK)
2874  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2875 #else
2876  throw();
2877 #endif
2878  INLINE l_ivector operator *(const l_rvector_slice &v,const l_imatrix &m)
2880 #if(CXSC_INDEX_CHECK)
2881  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2882 #else
2883  throw();
2884 #endif
2885 
2887  INLINE l_ivector operator *(const l_imatrix &m,const l_rvector &v)
2888 #if(CXSC_INDEX_CHECK)
2889  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2890 #else
2891  throw();
2892 #endif
2893  INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_rvector &v)
2895 #if(CXSC_INDEX_CHECK)
2896  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2897 #else
2898  throw();
2899 #endif
2900 
2901 //----------------- interval -------------------------------------
2902 
2904  INLINE l_ivector operator *(const ivector &v,const l_imatrix &m)
2905 #if(CXSC_INDEX_CHECK)
2906  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2907 #else
2908  throw();
2909 #endif
2910  INLINE l_ivector operator *(const ivector &v,const l_imatrix_slice &ms)
2912 #if(CXSC_INDEX_CHECK)
2913  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2914 #else
2915  throw();
2916 #endif
2917  INLINE l_ivector operator *(const ivector_slice &v,const l_imatrix &m)
2919 #if(CXSC_INDEX_CHECK)
2920  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2921 #else
2922  throw();
2923 #endif
2924 
2926  INLINE l_ivector operator *(const l_imatrix &m,const ivector &v)
2927 #if(CXSC_INDEX_CHECK)
2928  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2929 #else
2930  throw();
2931 #endif
2932  INLINE l_ivector operator *(const l_imatrix_slice &ms,const ivector &v)
2934 #if(CXSC_INDEX_CHECK)
2935  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2936 #else
2937  throw();
2938 #endif
2939 
2940 
2941 //================ Matrix / Matrix ============================
2942 
2944  INLINE const l_imatrix &operator +(const l_imatrix &m1) throw();
2946  INLINE l_imatrix operator +(const l_imatrix_slice &ms) throw();
2948  INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
2949 #if(CXSC_INDEX_CHECK)
2950  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2951 #else
2952  throw();
2953 #endif
2954  INLINE l_imatrix operator +(const l_imatrix &m,const l_imatrix_slice &ms)
2956 #if(CXSC_INDEX_CHECK)
2957  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2958 #else
2959  throw();
2960 #endif
2961  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_imatrix &m)
2963 #if(CXSC_INDEX_CHECK)
2964  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2965 #else
2966  throw();
2967 #endif
2968  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
2970 #if(CXSC_INDEX_CHECK)
2971  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2972 #else
2973  throw();
2974 #endif
2975  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix &m2)
2977 #if(CXSC_INDEX_CHECK)
2978  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2979 #else
2980  throw();
2981 #endif
2982  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix_slice &ms)
2984 #if(CXSC_INDEX_CHECK)
2985  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2986 #else
2987  throw();
2988 #endif
2989 
2991  INLINE l_imatrix operator -(const l_imatrix &m) throw();
2993  INLINE l_imatrix operator -(const l_imatrix_slice &ms) throw();
2995  INLINE l_imatrix operator -(const l_imatrix &m1,const l_imatrix &m2)
2996 #if(CXSC_INDEX_CHECK)
2997  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
2998 #else
2999  throw();
3000 #endif
3001  INLINE l_imatrix operator -(const l_imatrix &m,const l_imatrix_slice &ms)
3003 #if(CXSC_INDEX_CHECK)
3004  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3005 #else
3006  throw();
3007 #endif
3008  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_imatrix &m)
3010 #if(CXSC_INDEX_CHECK)
3011  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3012 #else
3013  throw();
3014 #endif
3015  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_imatrix_slice &ms2)
3017 #if(CXSC_INDEX_CHECK)
3018  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3019 #else
3020  throw();
3021 #endif
3022  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix &m2)
3024 #if(CXSC_INDEX_CHECK)
3025  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3026 #else
3027  throw();
3028 #endif
3029  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix_slice &ms)
3031 #if(CXSC_INDEX_CHECK)
3032  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3033 #else
3034  throw();
3035 #endif
3036 
3038  INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix &m2)
3039 #if(CXSC_INDEX_CHECK)
3040  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3041 #else
3042  throw();
3043 #endif
3044  INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix_slice &ms)
3046 #if(CXSC_INDEX_CHECK)
3047  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3048 #else
3049  throw();
3050 #endif
3051  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_imatrix &m1)
3053 #if(CXSC_INDEX_CHECK)
3054  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3055 #else
3056  throw();
3057 #endif
3058  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_imatrix_slice &ms2)
3060 #if(CXSC_INDEX_CHECK)
3061  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3062 #else
3063  throw();
3064 #endif
3065  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix &m2)
3067 #if(CXSC_INDEX_CHECK)
3068  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3069 #else
3070  throw();
3071 #endif
3072  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix_slice &ms)
3074 #if(CXSC_INDEX_CHECK)
3075  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3076 #else
3077  throw();
3078 #endif
3079 
3080 
3082  INLINE l_imatrix operator |(const l_imatrix &m1,const l_imatrix &m2)
3083 #if(CXSC_INDEX_CHECK)
3084  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3085 #else
3086  throw();
3087 #endif
3088  INLINE l_imatrix operator |(const l_imatrix &m,const l_imatrix_slice &ms)
3090 #if(CXSC_INDEX_CHECK)
3091  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3092 #else
3093  throw();
3094 #endif
3095  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_imatrix &m)
3097 #if(CXSC_INDEX_CHECK)
3098  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3099 #else
3100  throw();
3101 #endif
3102  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
3104 #if(CXSC_INDEX_CHECK)
3105  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3106 #else
3107  throw();
3108 #endif
3109  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix &m2)
3111 #if(CXSC_INDEX_CHECK)
3112  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3113 #else
3114  throw();
3115 #endif
3116  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix_slice &ms)
3118 #if(CXSC_INDEX_CHECK)
3119  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3120 #else
3121  throw();
3122 #endif
3123 
3125  INLINE l_imatrix operator &(const l_imatrix &m1,const l_imatrix &m2)
3126 #if(CXSC_INDEX_CHECK)
3127  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3128 #else
3129  throw();
3130 #endif
3131  INLINE l_imatrix operator &(const l_imatrix &m,const l_imatrix_slice &ms)
3133 #if(CXSC_INDEX_CHECK)
3134  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3135 #else
3136  throw();
3137 #endif
3138  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_imatrix &m)
3140 #if(CXSC_INDEX_CHECK)
3141  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3142 #else
3143  throw();
3144 #endif
3145  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
3147 #if(CXSC_INDEX_CHECK)
3148  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3149 #else
3150  throw();
3151 #endif
3152  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix &m2)
3154 #if(CXSC_INDEX_CHECK)
3155  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3156 #else
3157  throw();
3158 #endif
3159  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix_slice &ms)
3161 #if(CXSC_INDEX_CHECK)
3162  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3163 #else
3164  throw();
3165 #endif
3166 
3167  //---------- rmatrix-l_imatrix ------------------
3169  INLINE l_imatrix operator +(const rmatrix &m1,const l_imatrix &m2)
3170 #if(CXSC_INDEX_CHECK)
3171  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3172 #else
3173  throw();
3174 #endif
3175  INLINE l_imatrix operator +(const l_imatrix &m1,const rmatrix &m2)
3177 #if(CXSC_INDEX_CHECK)
3178  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3179 #else
3180  throw();
3181 #endif
3182  INLINE l_imatrix operator +(const rmatrix &m,const l_imatrix_slice &ms)
3184 #if(CXSC_INDEX_CHECK)
3185  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3186 #else
3187  throw();
3188 #endif
3189  INLINE l_imatrix operator +(const l_imatrix &m,const rmatrix_slice &ms)
3191 #if(CXSC_INDEX_CHECK)
3192  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3193 #else
3194  throw();
3195 #endif
3196  INLINE l_imatrix operator +(const rmatrix_slice &ms,const l_imatrix &m)
3198 #if(CXSC_INDEX_CHECK)
3199  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3200 #else
3201  throw();
3202 #endif
3203  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const rmatrix &m)
3205 #if(CXSC_INDEX_CHECK)
3206  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3207 #else
3208  throw();
3209 #endif
3210  INLINE l_imatrix operator +(const rmatrix_slice &m1,const l_imatrix_slice &m2)
3212 #if(CXSC_INDEX_CHECK)
3213  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3214 #else
3215  throw();
3216 #endif
3217  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const rmatrix_slice &m2)
3219 #if(CXSC_INDEX_CHECK)
3220  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3221 #else
3222  throw();
3223 #endif
3224  INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix &m2)
3226 #if(CXSC_INDEX_CHECK)
3227  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3228 #else
3229  throw();
3230 #endif
3231  INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix_slice &ms)
3233 #if(CXSC_INDEX_CHECK)
3234  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3235 #else
3236  throw();
3237 #endif
3238 
3240  INLINE l_imatrix operator -(const rmatrix &m1,const l_imatrix &m2)
3241 #if(CXSC_INDEX_CHECK)
3242  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3243 #else
3244  throw();
3245 #endif
3246  INLINE l_imatrix operator -(const l_imatrix &m1,const rmatrix &m2)
3248 #if(CXSC_INDEX_CHECK)
3249  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3250 #else
3251  throw();
3252 #endif
3253  INLINE l_imatrix operator -(const rmatrix &m,const l_imatrix_slice &ms)
3255 #if(CXSC_INDEX_CHECK)
3256  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3257 #else
3258  throw();
3259 #endif
3260  INLINE l_imatrix operator -(const l_imatrix &m,const rmatrix_slice &ms)
3262 #if(CXSC_INDEX_CHECK)
3263  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3264 #else
3265  throw();
3266 #endif
3267  INLINE l_imatrix operator -(const rmatrix_slice &ms,const l_imatrix &m)
3269 #if(CXSC_INDEX_CHECK)
3270  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3271 #else
3272  throw();
3273 #endif
3274  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const rmatrix &m)
3276 #if(CXSC_INDEX_CHECK)
3277  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3278 #else
3279  throw();
3280 #endif
3281  INLINE l_imatrix operator -(const rmatrix_slice &ms1,const l_imatrix_slice &ms2)
3283 #if(CXSC_INDEX_CHECK)
3284  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3285 #else
3286  throw();
3287 #endif
3288  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const rmatrix_slice &ms2)
3290 #if(CXSC_INDEX_CHECK)
3291  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3292 #else
3293  throw();
3294 #endif
3295  INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix &m2)
3297 #if(CXSC_INDEX_CHECK)
3298  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3299 #else
3300  throw();
3301 #endif
3302  INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix_slice &ms)
3304 #if(CXSC_INDEX_CHECK)
3305  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3306 #else
3307  throw();
3308 #endif
3309 
3311  INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix &m2)
3312 #if(CXSC_INDEX_CHECK)
3313  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3314 #else
3315  throw();
3316 #endif
3317  INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix &m2)
3319 #if(CXSC_INDEX_CHECK)
3320  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3321 #else
3322  throw();
3323 #endif
3324  INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix_slice &ms)
3326 #if(CXSC_INDEX_CHECK)
3327  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3328 #else
3329  throw();
3330 #endif
3331  INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix_slice &ms)
3333 #if(CXSC_INDEX_CHECK)
3334  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3335 #else
3336  throw();
3337 #endif
3338  INLINE l_imatrix operator *(const rmatrix_slice &ms, const l_imatrix &m1)
3340 #if(CXSC_INDEX_CHECK)
3341  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3342 #else
3343  throw();
3344 #endif
3345  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const rmatrix &m1)
3347 #if(CXSC_INDEX_CHECK)
3348  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3349 #else
3350  throw();
3351 #endif
3352  INLINE l_imatrix operator *(const rmatrix_slice &ms1, const l_imatrix_slice &ms2)
3354 #if(CXSC_INDEX_CHECK)
3355  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3356 #else
3357  throw();
3358 #endif
3359  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const rmatrix_slice &ms2)
3361 #if(CXSC_INDEX_CHECK)
3362  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3363 #else
3364  throw();
3365 #endif
3366  INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix &m2)
3368 #if(CXSC_INDEX_CHECK)
3369  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3370 #else
3371  throw();
3372 #endif
3373  INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix_slice &ms)
3375 #if(CXSC_INDEX_CHECK)
3376  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3377 #else
3378  throw();
3379 #endif
3380 
3382  INLINE l_imatrix operator |(const rmatrix &m1,const l_imatrix &m2)
3383 #if(CXSC_INDEX_CHECK)
3384  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3385 #else
3386  throw();
3387 #endif
3388  INLINE l_imatrix operator |(const l_imatrix &m1,const rmatrix &m2)
3390 #if(CXSC_INDEX_CHECK)
3391  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3392 #else
3393  throw();
3394 #endif
3395  INLINE l_imatrix operator |(const rmatrix &m,const l_imatrix_slice &ms)
3397 #if(CXSC_INDEX_CHECK)
3398  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3399 #else
3400  throw();
3401 #endif
3402  INLINE l_imatrix operator |(const l_imatrix &m,const rmatrix_slice &ms)
3404 #if(CXSC_INDEX_CHECK)
3405  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3406 #else
3407  throw();
3408 #endif
3409  INLINE l_imatrix operator |(const rmatrix_slice &ms,const l_imatrix &m)
3411 #if(CXSC_INDEX_CHECK)
3412  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3413 #else
3414  throw();
3415 #endif
3416  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const rmatrix &m)
3418 #if(CXSC_INDEX_CHECK)
3419  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3420 #else
3421  throw();
3422 #endif
3423  INLINE l_imatrix operator |(const rmatrix_slice &m1,const l_imatrix_slice &m2)
3425 #if(CXSC_INDEX_CHECK)
3426  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3427 #else
3428  throw();
3429 #endif
3430  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const rmatrix_slice &m2)
3432 #if(CXSC_INDEX_CHECK)
3433  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3434 #else
3435  throw();
3436 #endif
3437  INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix &m2)
3439 #if(CXSC_INDEX_CHECK)
3440  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3441 #else
3442  throw();
3443 #endif
3444  INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix_slice &ms)
3446 #if(CXSC_INDEX_CHECK)
3447  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3448 #else
3449  throw();
3450 #endif
3451 
3453  INLINE l_imatrix operator &(const rmatrix &m1,const l_imatrix &m2)
3454 #if(CXSC_INDEX_CHECK)
3455  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3456 #else
3457  throw();
3458 #endif
3459  INLINE l_imatrix operator &(const l_imatrix &m1,const rmatrix &m2)
3461 #if(CXSC_INDEX_CHECK)
3462  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3463 #else
3464  throw();
3465 #endif
3466  INLINE l_imatrix operator &(const rmatrix &m,const l_imatrix_slice &ms)
3468 #if(CXSC_INDEX_CHECK)
3469  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3470 #else
3471  throw();
3472 #endif
3473  INLINE l_imatrix operator &(const l_imatrix &m,const rmatrix_slice &ms)
3475 #if(CXSC_INDEX_CHECK)
3476  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3477 #else
3478  throw();
3479 #endif
3480  INLINE l_imatrix operator &(const rmatrix_slice &ms,const l_imatrix &m)
3482 #if(CXSC_INDEX_CHECK)
3483  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3484 #else
3485  throw();
3486 #endif
3487  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const rmatrix &m)
3489 #if(CXSC_INDEX_CHECK)
3490  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3491 #else
3492  throw();
3493 #endif
3494  INLINE l_imatrix operator &(const rmatrix_slice &m1,const l_imatrix_slice &m2)
3496 #if(CXSC_INDEX_CHECK)
3497  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3498 #else
3499  throw();
3500 #endif
3501  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const rmatrix_slice &m2)
3503 #if(CXSC_INDEX_CHECK)
3504  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3505 #else
3506  throw();
3507 #endif
3508  INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix &m2)
3510 #if(CXSC_INDEX_CHECK)
3511  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3512 #else
3513  throw();
3514 #endif
3515  INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix_slice &ms)
3517 #if(CXSC_INDEX_CHECK)
3518  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3519 #else
3520  throw();
3521 #endif
3522 
3523  //---------- l_rmatrix-l_imatrix ------------------
3525  INLINE l_imatrix operator +(const l_rmatrix &m1,const l_imatrix &m2)
3526 #if(CXSC_INDEX_CHECK)
3527  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3528 #else
3529  throw();
3530 #endif
3531  INLINE l_imatrix operator +(const l_imatrix &m1,const l_rmatrix &m2)
3533 #if(CXSC_INDEX_CHECK)
3534  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3535 #else
3536  throw();
3537 #endif
3538  INLINE l_imatrix operator +(const l_rmatrix &m,const l_imatrix_slice &ms)
3540 #if(CXSC_INDEX_CHECK)
3541  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3542 #else
3543  throw();
3544 #endif
3545  INLINE l_imatrix operator +(const l_imatrix &m,const l_rmatrix_slice &ms)
3547 #if(CXSC_INDEX_CHECK)
3548  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3549 #else
3550  throw();
3551 #endif
3552  INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const l_imatrix &m)
3554 #if(CXSC_INDEX_CHECK)
3555  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3556 #else
3557  throw();
3558 #endif
3559  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_rmatrix &m)
3561 #if(CXSC_INDEX_CHECK)
3562  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3563 #else
3564  throw();
3565 #endif
3566  INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
3568 #if(CXSC_INDEX_CHECK)
3569  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3570 #else
3571  throw();
3572 #endif
3573  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
3575 #if(CXSC_INDEX_CHECK)
3576  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3577 #else
3578  throw();
3579 #endif
3580  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix &m2)
3582 #if(CXSC_INDEX_CHECK)
3583  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3584 #else
3585  throw();
3586 #endif
3587  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix_slice &ms)
3589 #if(CXSC_INDEX_CHECK)
3590  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3591 #else
3592  throw();
3593 #endif
3594 
3596  INLINE l_imatrix operator -(const l_rmatrix &m1,const l_imatrix &m2)
3597 #if(CXSC_INDEX_CHECK)
3598  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3599 #else
3600  throw();
3601 #endif
3602  INLINE l_imatrix operator -(const l_imatrix &m1,const l_rmatrix &m2)
3604 #if(CXSC_INDEX_CHECK)
3605  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3606 #else
3607  throw();
3608 #endif
3609  INLINE l_imatrix operator -(const l_rmatrix &m,const l_imatrix_slice &ms)
3611 #if(CXSC_INDEX_CHECK)
3612  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3613 #else
3614  throw();
3615 #endif
3616  INLINE l_imatrix operator -(const l_imatrix &m,const l_rmatrix_slice &ms)
3618 #if(CXSC_INDEX_CHECK)
3619  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3620 #else
3621  throw();
3622 #endif
3623  INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const l_imatrix &m)
3625 #if(CXSC_INDEX_CHECK)
3626  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3627 #else
3628  throw();
3629 #endif
3630  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_rmatrix &m)
3632 #if(CXSC_INDEX_CHECK)
3633  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3634 #else
3635  throw();
3636 #endif
3637  INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const l_imatrix_slice &ms2)
3639 #if(CXSC_INDEX_CHECK)
3640  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3641 #else
3642  throw();
3643 #endif
3644  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_rmatrix_slice &ms2)
3646 #if(CXSC_INDEX_CHECK)
3647  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3648 #else
3649  throw();
3650 #endif
3651  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix &m2)
3653 #if(CXSC_INDEX_CHECK)
3654  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3655 #else
3656  throw();
3657 #endif
3658  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix_slice &ms)
3660 #if(CXSC_INDEX_CHECK)
3661  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3662 #else
3663  throw();
3664 #endif
3665 
3667  INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix &m2)
3668 #if(CXSC_INDEX_CHECK)
3669  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3670 #else
3671  throw();
3672 #endif
3673  INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix &m2)
3675 #if(CXSC_INDEX_CHECK)
3676  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3677 #else
3678  throw();
3679 #endif
3680  INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix_slice &ms)
3682 #if(CXSC_INDEX_CHECK)
3683  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3684 #else
3685  throw();
3686 #endif
3687  INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix_slice &ms)
3689 #if(CXSC_INDEX_CHECK)
3690  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3691 #else
3692  throw();
3693 #endif
3694  INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const l_imatrix &m1)
3696 #if(CXSC_INDEX_CHECK)
3697  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3698 #else
3699  throw();
3700 #endif
3701  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_rmatrix &m1)
3703 #if(CXSC_INDEX_CHECK)
3704  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3705 #else
3706  throw();
3707 #endif
3708  INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const l_imatrix_slice &ms2)
3710 #if(CXSC_INDEX_CHECK)
3711  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3712 #else
3713  throw();
3714 #endif
3715  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_rmatrix_slice &ms2)
3717 #if(CXSC_INDEX_CHECK)
3718  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3719 #else
3720  throw();
3721 #endif
3722  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix &m2)
3724 #if(CXSC_INDEX_CHECK)
3725  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3726 #else
3727  throw();
3728 #endif
3729  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix_slice &ms)
3731 #if(CXSC_INDEX_CHECK)
3732  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3733 #else
3734  throw();
3735 #endif
3736 
3738  INLINE l_imatrix operator |(const l_rmatrix &m1,const l_imatrix &m2)
3739 #if(CXSC_INDEX_CHECK)
3740  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3741 #else
3742  throw();
3743 #endif
3744  INLINE l_imatrix operator |(const l_imatrix &m1,const l_rmatrix &m2)
3746 #if(CXSC_INDEX_CHECK)
3747  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3748 #else
3749  throw();
3750 #endif
3751  INLINE l_imatrix operator |(const l_rmatrix &m,const l_imatrix_slice &ms)
3753 #if(CXSC_INDEX_CHECK)
3754  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3755 #else
3756  throw();
3757 #endif
3758  INLINE l_imatrix operator |(const l_imatrix &m,const l_rmatrix_slice &ms)
3760 #if(CXSC_INDEX_CHECK)
3761  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3762 #else
3763  throw();
3764 #endif
3765  INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const l_imatrix &m)
3767 #if(CXSC_INDEX_CHECK)
3768  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3769 #else
3770  throw();
3771 #endif
3772  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_rmatrix &m)
3774 #if(CXSC_INDEX_CHECK)
3775  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3776 #else
3777  throw();
3778 #endif
3779  INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
3781 #if(CXSC_INDEX_CHECK)
3782  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3783 #else
3784  throw();
3785 #endif
3786  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
3788 #if(CXSC_INDEX_CHECK)
3789  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3790 #else
3791  throw();
3792 #endif
3793  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix &m2)
3795 #if(CXSC_INDEX_CHECK)
3796  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3797 #else
3798  throw();
3799 #endif
3800  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix_slice &ms)
3802 #if(CXSC_INDEX_CHECK)
3803  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3804 #else
3805  throw();
3806 #endif
3807 
3809  INLINE l_imatrix operator &(const l_rmatrix &m1,const l_imatrix &m2)
3810 #if(CXSC_INDEX_CHECK)
3811  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3812 #else
3813  throw();
3814 #endif
3815  INLINE l_imatrix operator &(const l_imatrix &m1,const l_rmatrix &m2)
3817 #if(CXSC_INDEX_CHECK)
3818  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3819 #else
3820  throw();
3821 #endif
3822  INLINE l_imatrix operator &(const l_rmatrix &m,const l_imatrix_slice &ms)
3824 #if(CXSC_INDEX_CHECK)
3825  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3826 #else
3827  throw();
3828 #endif
3829  INLINE l_imatrix operator &(const l_imatrix &m,const l_rmatrix_slice &ms)
3831 #if(CXSC_INDEX_CHECK)
3832  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3833 #else
3834  throw();
3835 #endif
3836  INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const l_imatrix &m)
3838 #if(CXSC_INDEX_CHECK)
3839  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3840 #else
3841  throw();
3842 #endif
3843  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_rmatrix &m)
3845 #if(CXSC_INDEX_CHECK)
3846  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3847 #else
3848  throw();
3849 #endif
3850  INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
3852 #if(CXSC_INDEX_CHECK)
3853  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3854 #else
3855  throw();
3856 #endif
3857  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
3859 #if(CXSC_INDEX_CHECK)
3860  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3861 #else
3862  throw();
3863 #endif
3864  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix &m2)
3866 #if(CXSC_INDEX_CHECK)
3867  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3868 #else
3869  throw();
3870 #endif
3871  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix_slice &ms)
3873 #if(CXSC_INDEX_CHECK)
3874  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3875 #else
3876  throw();
3877 #endif
3878 
3879  //---------- imatrix-l_imatrix ------------------
3881  INLINE l_imatrix operator +(const imatrix &m1,const l_imatrix &m2)
3882 #if(CXSC_INDEX_CHECK)
3883  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3884 #else
3885  throw();
3886 #endif
3887  INLINE l_imatrix operator +(const l_imatrix &m1,const imatrix &m2)
3889 #if(CXSC_INDEX_CHECK)
3890  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3891 #else
3892  throw();
3893 #endif
3894  INLINE l_imatrix operator +(const imatrix &m,const l_imatrix_slice &ms)
3896 #if(CXSC_INDEX_CHECK)
3897  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3898 #else
3899  throw();
3900 #endif
3901  INLINE l_imatrix operator +(const l_imatrix &m,const imatrix_slice &ms)
3903 #if(CXSC_INDEX_CHECK)
3904  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3905 #else
3906  throw();
3907 #endif
3908  INLINE l_imatrix operator +(const imatrix_slice &ms,const l_imatrix &m)
3910 #if(CXSC_INDEX_CHECK)
3911  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3912 #else
3913  throw();
3914 #endif
3915  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const imatrix &m)
3917 #if(CXSC_INDEX_CHECK)
3918  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3919 #else
3920  throw();
3921 #endif
3922  INLINE l_imatrix operator +(const imatrix_slice &m1,const l_imatrix_slice &m2)
3924 #if(CXSC_INDEX_CHECK)
3925  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3926 #else
3927  throw();
3928 #endif
3929  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const imatrix_slice &m2)
3931 #if(CXSC_INDEX_CHECK)
3932  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3933 #else
3934  throw();
3935 #endif
3936  INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix &m2)
3938 #if(CXSC_INDEX_CHECK)
3939  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3940 #else
3941  throw();
3942 #endif
3943  INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix_slice &ms)
3945 #if(CXSC_INDEX_CHECK)
3946  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3947 #else
3948  throw();
3949 #endif
3950 
3952  INLINE l_imatrix operator -(const imatrix &m1,const l_imatrix &m2)
3953 #if(CXSC_INDEX_CHECK)
3954  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3955 #else
3956  throw();
3957 #endif
3958  INLINE l_imatrix operator -(const l_imatrix &m1,const imatrix &m2)
3960 #if(CXSC_INDEX_CHECK)
3961  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3962 #else
3963  throw();
3964 #endif
3965  INLINE l_imatrix operator -(const imatrix &m,const l_imatrix_slice &ms)
3967 #if(CXSC_INDEX_CHECK)
3968  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3969 #else
3970  throw();
3971 #endif
3972  INLINE l_imatrix operator -(const l_imatrix &m,const imatrix_slice &ms)
3974 #if(CXSC_INDEX_CHECK)
3975  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3976 #else
3977  throw();
3978 #endif
3979  INLINE l_imatrix operator -(const imatrix_slice &ms,const l_imatrix &m)
3981 #if(CXSC_INDEX_CHECK)
3982  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3983 #else
3984  throw();
3985 #endif
3986  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const imatrix &m)
3988 #if(CXSC_INDEX_CHECK)
3989  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3990 #else
3991  throw();
3992 #endif
3993  INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_imatrix_slice &ms2)
3995 #if(CXSC_INDEX_CHECK)
3996  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
3997 #else
3998  throw();
3999 #endif
4000  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const imatrix_slice &ms2)
4002 #if(CXSC_INDEX_CHECK)
4003  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4004 #else
4005  throw();
4006 #endif
4007  INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix &m2)
4009 #if(CXSC_INDEX_CHECK)
4010  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4011 #else
4012  throw();
4013 #endif
4014  INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix_slice &ms)
4016 #if(CXSC_INDEX_CHECK)
4017  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4018 #else
4019  throw();
4020 #endif
4021 
4023  INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix &m2)
4024 #if(CXSC_INDEX_CHECK)
4025  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4026 #else
4027  throw();
4028 #endif
4029  INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix &m2)
4031 #if(CXSC_INDEX_CHECK)
4032  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4033 #else
4034  throw();
4035 #endif
4036  INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix_slice &ms)
4038 #if(CXSC_INDEX_CHECK)
4039  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4040 #else
4041  throw();
4042 #endif
4043  INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix_slice &ms)
4045 #if(CXSC_INDEX_CHECK)
4046  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4047 #else
4048  throw();
4049 #endif
4050  INLINE l_imatrix operator *(const imatrix_slice &ms, const l_imatrix &m1)
4052 #if(CXSC_INDEX_CHECK)
4053  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4054 #else
4055  throw();
4056 #endif
4057  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const imatrix &m1)
4059 #if(CXSC_INDEX_CHECK)
4060  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4061 #else
4062  throw();
4063 #endif
4064  INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_imatrix_slice &ms2)
4066 #if(CXSC_INDEX_CHECK)
4067  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4068 #else
4069  throw();
4070 #endif
4071  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const imatrix_slice &ms2)
4073 #if(CXSC_INDEX_CHECK)
4074  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4075 #else
4076  throw();
4077 #endif
4078  INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix &m2)
4080 #if(CXSC_INDEX_CHECK)
4081  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4082 #else
4083  throw();
4084 #endif
4085  INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix_slice &ms)
4087 #if(CXSC_INDEX_CHECK)
4088  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4089 #else
4090  throw();
4091 #endif
4092 
4094  INLINE l_imatrix operator |(const imatrix &m1,const l_imatrix &m2)
4095 #if(CXSC_INDEX_CHECK)
4096  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4097 #else
4098  throw();
4099 #endif
4100  INLINE l_imatrix operator |(const l_imatrix &m1,const imatrix &m2)
4102 #if(CXSC_INDEX_CHECK)
4103  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4104 #else
4105  throw();
4106 #endif
4107  INLINE l_imatrix operator |(const imatrix &m,const l_imatrix_slice &ms)
4109 #if(CXSC_INDEX_CHECK)
4110  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4111 #else
4112  throw();
4113 #endif
4114  INLINE l_imatrix operator |(const l_imatrix &m,const imatrix_slice &ms)
4116 #if(CXSC_INDEX_CHECK)
4117  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4118 #else
4119  throw();
4120 #endif
4121  INLINE l_imatrix operator |(const imatrix_slice &ms,const l_imatrix &m)
4123 #if(CXSC_INDEX_CHECK)
4124  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4125 #else
4126  throw();
4127 #endif
4128  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const imatrix &m)
4130 #if(CXSC_INDEX_CHECK)
4131  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4132 #else
4133  throw();
4134 #endif
4135  INLINE l_imatrix operator |(const imatrix_slice &m1,const l_imatrix_slice &m2)
4137 #if(CXSC_INDEX_CHECK)
4138  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4139 #else
4140  throw();
4141 #endif
4142  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const imatrix_slice &m2)
4144 #if(CXSC_INDEX_CHECK)
4145  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4146 #else
4147  throw();
4148 #endif
4149  INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix &m2)
4151 #if(CXSC_INDEX_CHECK)
4152  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4153 #else
4154  throw();
4155 #endif
4156  INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix_slice &ms)
4158 #if(CXSC_INDEX_CHECK)
4159  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4160 #else
4161  throw();
4162 #endif
4163 
4165  INLINE l_imatrix operator &(const imatrix &m1,const l_imatrix &m2)
4166 #if(CXSC_INDEX_CHECK)
4167  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4168 #else
4169  throw();
4170 #endif
4171  INLINE l_imatrix operator &(const l_imatrix &m1,const imatrix &m2)
4173 #if(CXSC_INDEX_CHECK)
4174  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4175 #else
4176  throw();
4177 #endif
4178  INLINE l_imatrix operator &(const imatrix &m,const l_imatrix_slice &ms)
4180 #if(CXSC_INDEX_CHECK)
4181  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4182 #else
4183  throw();
4184 #endif
4185  INLINE l_imatrix operator &(const l_imatrix &m,const imatrix_slice &ms)
4187 #if(CXSC_INDEX_CHECK)
4188  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4189 #else
4190  throw();
4191 #endif
4192  INLINE l_imatrix operator &(const imatrix_slice &ms,const l_imatrix &m)
4194 #if(CXSC_INDEX_CHECK)
4195  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4196 #else
4197  throw();
4198 #endif
4199  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const imatrix &m)
4201 #if(CXSC_INDEX_CHECK)
4202  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4203 #else
4204  throw();
4205 #endif
4206  INLINE l_imatrix operator &(const imatrix_slice &m1,const l_imatrix_slice &m2)
4208 #if(CXSC_INDEX_CHECK)
4209  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4210 #else
4211  throw();
4212 #endif
4213  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const imatrix_slice &m2)
4215 #if(CXSC_INDEX_CHECK)
4216  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4217 #else
4218  throw();
4219 #endif
4220  INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix &m2)
4222 #if(CXSC_INDEX_CHECK)
4223  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4224 #else
4225  throw();
4226 #endif
4227  INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix_slice &ms)
4229 #if(CXSC_INDEX_CHECK)
4230  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4231 #else
4232  throw();
4233 #endif
4234 
4235  //---------- l_rmatrix-imatrix ------------------
4237  INLINE l_imatrix operator +(const l_rmatrix &m1,const imatrix &m2)
4238 #if(CXSC_INDEX_CHECK)
4239  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4240 #else
4241  throw();
4242 #endif
4243  INLINE l_imatrix operator +(const imatrix &m1,const l_rmatrix &m2)
4245 #if(CXSC_INDEX_CHECK)
4246  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4247 #else
4248  throw();
4249 #endif
4250  INLINE l_imatrix operator +(const l_rmatrix &m,const imatrix_slice &ms)
4252 #if(CXSC_INDEX_CHECK)
4253  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4254 #else
4255  throw();
4256 #endif
4257  INLINE l_imatrix operator +(const imatrix &m,const l_rmatrix_slice &ms)
4259 #if(CXSC_INDEX_CHECK)
4260  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4261 #else
4262  throw();
4263 #endif
4264  INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const imatrix &m)
4266 #if(CXSC_INDEX_CHECK)
4267  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4268 #else
4269  throw();
4270 #endif
4271  INLINE l_imatrix operator +(const imatrix_slice &ms,const l_rmatrix &m)
4273 #if(CXSC_INDEX_CHECK)
4274  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4275 #else
4276  throw();
4277 #endif
4278  INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const imatrix_slice &m2)
4280 #if(CXSC_INDEX_CHECK)
4281  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4282 #else
4283  throw();
4284 #endif
4285  INLINE l_imatrix operator +(const imatrix_slice &m1,const l_rmatrix_slice &m2)
4287 #if(CXSC_INDEX_CHECK)
4288  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4289 #else
4290  throw();
4291 #endif
4292 
4294  INLINE l_imatrix operator -(const l_rmatrix &m1,const imatrix &m2)
4295 #if(CXSC_INDEX_CHECK)
4296  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4297 #else
4298  throw();
4299 #endif
4300  INLINE l_imatrix operator -(const imatrix &m1,const l_rmatrix &m2)
4302 #if(CXSC_INDEX_CHECK)
4303  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4304 #else
4305  throw();
4306 #endif
4307  INLINE l_imatrix operator -(const l_rmatrix &m,const imatrix_slice &ms)
4309 #if(CXSC_INDEX_CHECK)
4310  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4311 #else
4312  throw();
4313 #endif
4314  INLINE l_imatrix operator -(const imatrix &m,const l_rmatrix_slice &ms)
4316 #if(CXSC_INDEX_CHECK)
4317  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4318 #else
4319  throw();
4320 #endif
4321  INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const imatrix &m)
4323 #if(CXSC_INDEX_CHECK)
4324  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4325 #else
4326  throw();
4327 #endif
4328  INLINE l_imatrix operator -(const imatrix_slice &ms,const l_rmatrix &m)
4330 #if(CXSC_INDEX_CHECK)
4331  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4332 #else
4333  throw();
4334 #endif
4335  INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const imatrix_slice &ms2)
4337 #if(CXSC_INDEX_CHECK)
4338  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4339 #else
4340  throw();
4341 #endif
4342  INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_rmatrix_slice &ms2)
4344 #if(CXSC_INDEX_CHECK)
4345  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4346 #else
4347  throw();
4348 #endif
4349 
4351  INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix &m2)
4352 #if(CXSC_INDEX_CHECK)
4353  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4354 #else
4355  throw();
4356 #endif
4357  INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix &m2)
4359 #if(CXSC_INDEX_CHECK)
4360  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4361 #else
4362  throw();
4363 #endif
4364  INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix_slice &ms)
4366 #if(CXSC_INDEX_CHECK)
4367  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4368 #else
4369  throw();
4370 #endif
4371  INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix_slice &ms)
4373 #if(CXSC_INDEX_CHECK)
4374  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4375 #else
4376  throw();
4377 #endif
4378  INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const imatrix &m1)
4380 #if(CXSC_INDEX_CHECK)
4381  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4382 #else
4383  throw();
4384 #endif
4385  INLINE l_imatrix operator *(const imatrix_slice &ms, const l_rmatrix &m1)
4387 #if(CXSC_INDEX_CHECK)
4388  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4389 #else
4390  throw();
4391 #endif
4392  INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const imatrix_slice &ms2)
4394 #if(CXSC_INDEX_CHECK)
4395  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4396 #else
4397  throw();
4398 #endif
4399  INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_rmatrix_slice &ms2)
4401 #if(CXSC_INDEX_CHECK)
4402  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4403 #else
4404  throw();
4405 #endif
4406 
4408  INLINE l_imatrix operator |(const l_rmatrix &m1,const imatrix &m2)
4409 #if(CXSC_INDEX_CHECK)
4410  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4411 #else
4412  throw();
4413 #endif
4414  INLINE l_imatrix operator |(const imatrix &m1,const l_rmatrix &m2)
4416 #if(CXSC_INDEX_CHECK)
4417  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4418 #else
4419  throw();
4420 #endif
4421  INLINE l_imatrix operator |(const l_rmatrix &m,const imatrix_slice &ms)
4423 #if(CXSC_INDEX_CHECK)
4424  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4425 #else
4426  throw();
4427 #endif
4428  INLINE l_imatrix operator |(const imatrix &m,const l_rmatrix_slice &ms)
4430 #if(CXSC_INDEX_CHECK)
4431  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4432 #else
4433  throw();
4434 #endif
4435  INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const imatrix &m)
4437 #if(CXSC_INDEX_CHECK)
4438  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4439 #else
4440  throw();
4441 #endif
4442  INLINE l_imatrix operator |(const imatrix_slice &ms,const l_rmatrix &m)
4444 #if(CXSC_INDEX_CHECK)
4445  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4446 #else
4447  throw();
4448 #endif
4449  INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const imatrix_slice &m2)
4451 #if(CXSC_INDEX_CHECK)
4452  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4453 #else
4454  throw();
4455 #endif
4456  INLINE l_imatrix operator |(const imatrix_slice &m1,const l_rmatrix_slice &m2)
4458 #if(CXSC_INDEX_CHECK)
4459  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4460 #else
4461  throw();
4462 #endif
4463 
4465  INLINE l_imatrix operator &(const l_rmatrix &m1,const imatrix &m2)
4466 #if(CXSC_INDEX_CHECK)
4467  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4468 #else
4469  throw();
4470 #endif
4471  INLINE l_imatrix operator &(const imatrix &m1,const l_rmatrix &m2)
4473 #if(CXSC_INDEX_CHECK)
4474  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4475 #else
4476  throw();
4477 #endif
4478  INLINE l_imatrix operator &(const l_rmatrix &m,const imatrix_slice &ms)
4480 #if(CXSC_INDEX_CHECK)
4481  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4482 #else
4483  throw();
4484 #endif
4485  INLINE l_imatrix operator &(const imatrix &m,const l_rmatrix_slice &ms)
4487 #if(CXSC_INDEX_CHECK)
4488  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4489 #else
4490  throw();
4491 #endif
4492  INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const imatrix &m)
4494 #if(CXSC_INDEX_CHECK)
4495  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4496 #else
4497  throw();
4498 #endif
4499  INLINE l_imatrix operator &(const imatrix_slice &ms,const l_rmatrix &m)
4501 #if(CXSC_INDEX_CHECK)
4502  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4503 #else
4504  throw();
4505 #endif
4506  INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const imatrix_slice &m2)
4508 #if(CXSC_INDEX_CHECK)
4509  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4510 #else
4511  throw();
4512 #endif
4513  INLINE l_imatrix operator &(const imatrix_slice &m1,const l_rmatrix_slice &m2)
4515 #if(CXSC_INDEX_CHECK)
4516  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
4517 #else
4518  throw();
4519 #endif
4520 
4521 //------------- real x l_real ------------------------
4523  INLINE l_imatrix operator |(const rmatrix &rv1, const l_rmatrix &rv2)
4524 #if(CXSC_INDEX_CHECK)
4525  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4526 #else
4527  throw();
4528 #endif
4529  INLINE l_imatrix operator |(const l_rmatrix &rv1, const rmatrix &rv2)
4531 #if(CXSC_INDEX_CHECK)
4532  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4533 #else
4534  throw();
4535 #endif
4536  INLINE l_imatrix operator |(const l_rmatrix &rv, const rmatrix_slice &sl)
4538 #if(CXSC_INDEX_CHECK)
4539  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4540 #else
4541  throw();
4542 #endif
4543  INLINE l_imatrix operator |(const rmatrix_slice &sl,const l_rmatrix &rv)
4545 #if(CXSC_INDEX_CHECK)
4546  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4547 #else
4548  throw();
4549 #endif
4550  INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const rmatrix &rv)
4552 #if(CXSC_INDEX_CHECK)
4553  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4554 #else
4555  throw();
4556 #endif
4557  INLINE l_imatrix operator |(const rmatrix &rv,const l_rmatrix_slice &sl)
4559 #if(CXSC_INDEX_CHECK)
4560  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4561 #else
4562  throw();
4563 #endif
4564  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const rmatrix_slice &sl2)
4566 #if(CXSC_INDEX_CHECK)
4567  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4568 #else
4569  throw();
4570 #endif
4571  INLINE l_imatrix operator |(const rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
4573 #if(CXSC_INDEX_CHECK)
4574  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4575 #else
4576  throw();
4577 #endif
4578 
4579 
4580 //------------- l_real x l_real ------------------------
4582  INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
4583 #if(CXSC_INDEX_CHECK)
4584  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4585 #else
4586  throw();
4587 #endif
4588  INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
4590 #if(CXSC_INDEX_CHECK)
4591  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4592 #else
4593  throw();
4594 #endif
4595  INLINE l_imatrix operator |(const l_rmatrix &rv, const l_rmatrix_slice &sl)
4597 #if(CXSC_INDEX_CHECK)
4598  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4599 #else
4600  throw();
4601 #endif
4602  INLINE l_imatrix operator |(const l_rmatrix_slice &sl,const l_rmatrix &rv)
4604 #if(CXSC_INDEX_CHECK)
4605  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4606 #else
4607  throw();
4608 #endif
4609  INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const l_rmatrix &rv)
4611 #if(CXSC_INDEX_CHECK)
4612  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4613 #else
4614  throw();
4615 #endif
4616  INLINE l_imatrix operator |(const l_rmatrix &rv,const l_rmatrix_slice &sl)
4618 #if(CXSC_INDEX_CHECK)
4619  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4620 #else
4621  throw();
4622 #endif
4623  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
4625 #if(CXSC_INDEX_CHECK)
4626  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4627 #else
4628  throw();
4629 #endif
4630  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
4632 #if(CXSC_INDEX_CHECK)
4633  throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
4634 #else
4635  throw();
4636 #endif
4637 
4638 
4639 //============== Compare Operator ==========================
4640 
4641 //-------------- Matrix - Matrix -------------------------
4642 
4644  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix &m2) throw();
4646  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) throw();
4648  INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) throw();
4650  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) throw();
4652  INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) throw();
4654  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) throw();
4656  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
4658  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
4660  INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
4662  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
4664  INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
4666  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
4667 
4668 //---------------- Matrix - Matrix_slice ----------------------
4669 
4671  INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
4673  INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
4675  INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
4677  INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
4679  INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
4681  INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
4682 
4683 //=================== Not Operator =============================
4684 
4686  INLINE bool operator !(const l_imatrix &ms) throw();
4688  INLINE bool operator !(const l_imatrix_slice &ms) throw();
4689 
4690 //======================== Input / Output ========================
4691 
4693  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) throw();
4695  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) throw();
4697  INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) throw();
4699  INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) throw();
4700 
4702  l_imatrix Id ( const l_imatrix& );
4704  l_imatrix transp ( const l_imatrix& );
4706  l_real MaxRelDiam ( const l_imatrix_subv& );
4708  INLINE int RowLen ( const l_imatrix& );
4710  INLINE int ColLen ( const l_imatrix& );
4712  INLINE int RowLen ( const l_imatrix_slice& );
4714  INLINE int ColLen ( const l_imatrix_slice& );
4716  void DoubleSize ( l_imatrix& );
4717 
4718 } // namespace cxsc
4719 
4720 #ifdef _CXSC_INCL_INL
4721 #include "matrix.inl"
4722 #include "l_imatrix.inl"
4723 #endif
4724 
4725 
4726 #endif
4727 
cxsc::l_imatrix_subv::Col
friend l_imatrix_subv Col(l_imatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: l_imatrix.inl:263
cxsc::l_imatrix_slice::operator=
l_imatrix_slice & operator=(const l_imatrix &m)
Implementation of standard assigning operator.
Definition: l_imatrix.inl:522
cxsc::l_imatrix_subv::l_imatrix_subv
l_imatrix_subv(const l_imatrix_subv &v)
Constructor of class l_imatrix_subv.
Definition: l_imatrix.hpp:285
cxsc::l_rmatrix_slice
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
cxsc::l_imatrix_subv::operator[]
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_imatrix.inl:185
cxsc::l_imatrix_subv::operator&=
l_imatrix_subv & operator&=(const l_ivector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:972
cxsc::imatrix_slice
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
cxsc::l_imatrix_subv::l_imatrix_subv
l_imatrix_subv(l_interval *d, const int &l, const int &u, const int &s, const int &st, const int &o)
Constructor of class l_imatrix_subv.
Definition: l_imatrix.hpp:282
cxsc::mid
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::l_imatrix_subv::operator|=
l_imatrix_subv & operator|=(const l_ivector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:923
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::RowLen
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cxsc::l_rmatrix_subv
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:47
cxsc::l_imatrix_slice::operator*=
l_imatrix_slice & operator*=(const l_interval &c)
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:1549
cxsc::imatrix_subv
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::l_imatrix_subv::operator+=
l_imatrix_subv & operator+=(const l_interval &c)
Implementation of addition and allocation operation.
Definition: l_imatrix.inl:675
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::l_imatrix_subv::Row
friend l_imatrix_subv Row(l_imatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: l_imatrix.inl:252
cxsc::diam
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::l_imatrix_slice::l_imatrix_slice
l_imatrix_slice(const l_imatrix_slice &ms)
Constructor of class l_imatrix_slice.
Definition: l_imatrix.hpp:1579
cxsc::ColLen
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
cxsc::l_imatrix_slice::l_imatrix_slice
l_imatrix_slice(l_imatrix &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class l_imatrix_slice.
Definition: l_imatrix.hpp:1574
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::_imatrix
cimatrix _imatrix(const cimatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: cimatrix.inl:1137
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:963
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::l_imatrix_subv::operator-=
l_imatrix_subv & operator-=(const l_interval &c)
Implementation of subtraction and allocation operation.
Definition: l_imatrix.inl:676
cxsc::l_imatrix_subv::operator()
l_imatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: l_imatrix.hpp:436
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:660
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::l_imatrix_slice
The Multiple-Precision Data Type l_imatrix_slice.
Definition: l_imatrix.hpp:1280
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::l_interval
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:72
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::l_imatrix_subv::operator=
l_imatrix_subv & operator=(const l_imatrix_subv &rv)
Implementation of standard assigning operator.
Definition: l_imatrix.inl:428
cxsc::l_imatrix_slice::l_imatrix_slice
l_imatrix_slice(l_imatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class l_imatrix_slice.
Definition: l_imatrix.hpp:1576
cxsc::l_imatrix::operator()
l_imatrix & operator()()
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1252
cxsc::l_imatrix::operator=
l_imatrix & operator=(const l_interval &r)
Implementation of standard assigning operator.
Definition: l_imatrix.inl:496
cxsc::l_rvector_slice
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
cxsc::l_ivector::l_ivector
l_ivector()
Constructor of class l_ivector.
Definition: l_ivector.inl:31
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::l_imatrix::l_imatrix
l_imatrix()
Constructor of class l_imatrix.
Definition: l_imatrix.inl:31
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::Lb
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::l_real
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
cxsc::l_imatrix_slice::operator()
l_imatrix_slice & operator()()
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1760
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::l_imatrix_subv::Ub
friend int Ub(const l_imatrix_subv &rv)
Returns the upper bound of the vector.
Definition: l_imatrix.hpp:427
cxsc::DoubleSize
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
cxsc::l_imatrix_subv::Lb
friend int Lb(const l_imatrix_subv &rv)
Returns the lower bound of the vector.
Definition: l_imatrix.hpp:425
cxsc::transp
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition: cimatrix.cpp:74
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::l_imatrix_slice::operator&=
l_imatrix_slice & operator&=(const l_imatrix &m1)
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:2173
cxsc::Ub
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::l_imatrix_subv::operator*=
l_imatrix_subv & operator*=(const l_interval &c)
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:674
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
cxsc::l_imatrix_slice::operator|=
l_imatrix_slice & operator|=(const l_imatrix &m1)
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:2117
cxsc::l_imatrix_slice::operator-=
l_imatrix_slice & operator-=(const l_interval &c)
Implementation of subtraction and allocation operation.
cxsc::l_ivector_slice
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:871
cxsc::l_imatrix_slice::operator/=
l_imatrix_slice & operator/=(const l_interval &c)
Implementation of division and allocation operation.
Definition: l_imatrix.inl:1553
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
cxsc::Id
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
cxsc::l_imatrix_slice::operator[]
l_imatrix_subv operator[](const int &i)
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:348
cxsc::l_imatrix_subv
The Multiple-Precision Data Type l_imatrix_subv.
Definition: l_imatrix.hpp:47
cxsc::l_imatrix::operator[]
l_imatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:296
cxsc::l_imatrix_subv::operator/=
l_imatrix_subv & operator/=(const l_interval &c)
Implementation of division and allocation operation.
Definition: l_imatrix.inl:677
cxsc::l_imatrix_slice::operator+=
l_imatrix_slice & operator+=(const l_interval &c)
Implementation of addition and allocation operation.
cxsc::MaxRelDiam
real MaxRelDiam(const imatrix_subv &v)
Computes the relative diameter .
Definition: imatrix.cpp:76
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:114