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