C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
cimatrix.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: cimatrix.hpp,v 1.41 2014/01/30 17:23:43 cxsc Exp $ */
25 
26 #ifndef _CXSC_CIMATRIX_HPP_INCLUDED
27 #define _CXSC_CIMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "cidot.hpp"
31 #include "civector.hpp"
32 #include "except.hpp"
33 #include "matrix.hpp"
34 #include "imatrix.hpp"
35 #include "cmatrix.hpp"
36 
37 
38 namespace cxsc {
39 
40 class cimatrix; // forward declaration
41 class cimatrix_slice; // forward declaration
42 class srmatrix;
43 class srmatrix_slice;
44 class srmatrix_subv;
45 class simatrix;
46 class simatrix_slice;
47 class simatrix_subv;
48 class scmatrix;
49 class scmatrix_slice;
50 class scmatrix_subv;
51 class scimatrix;
52 class scimatrix_slice;
53 class scimatrix_subv;
54 
55 
56 
57 // ---------------------------------------------------------------------------
58 // ---- ----
59 // ---- class cimatrix_subv (declaration) ----
60 // ---- ----
61 // ---------------------------------------------------------------------------
62 
64 
68 {
69  friend class civector;
70  friend class cimatrix;
71  friend class cimatrix_slice;
72 
73  private:
74  cinterval *dat;
75  int lb,ub;
76  int size,start,offset; // start=first element index 0..n-1
77 
78  public:
80  friend INLINE cimatrix_subv Row(cimatrix &m,const int &i)
81 #if(CXSC_INDEX_CHECK)
82  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
83 #else
84  throw();
85 #endif
86 
88  friend INLINE cimatrix_subv Col(cimatrix &m,const int &i)
89 #if(CXSC_INDEX_CHECK)
90  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
91 #else
92  throw();
93 #endif
94  friend INLINE cimatrix_subv Row(const cimatrix &m,const int &i)
96 #if(CXSC_INDEX_CHECK)
97  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
98 #else
99  throw();
100 #endif
101 
103  friend INLINE cimatrix_subv Col(const cimatrix &m,const int &i)
104 #if(CXSC_INDEX_CHECK)
105  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
106 #else
107  throw();
108 #endif
109 
110 
111 #ifdef _CXSC_FRIEND_TPL
112  //----------------- Templates ---------------------------------------
113 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
114 #if(CXSC_INDEX_CHECK)
115  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
116 #else
117  throw();
118 #endif
119 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
120 template <class MV,class V> friend MV &_mvvassign(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 V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
127 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
128 #if(CXSC_INDEX_CHECK)
129  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
130 #else
131  throw();
132 #endif
133 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
134 #if(CXSC_INDEX_CHECK)
135  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
136 #else
137  throw();
138 #endif
139 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
140 #if(CXSC_INDEX_CHECK)
141  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
142 #else
143  throw();
144 #endif
145 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
146 #if(CXSC_INDEX_CHECK)
147  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
148 #else
149  throw();
150 #endif
151 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
152 #if(CXSC_INDEX_CHECK)
153  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
154 #else
155  throw();
156 #endif
157 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
158 #if(CXSC_INDEX_CHECK)
159  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
160 #else
161  throw();
162 #endif
163 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
164 template <class MV,class V> friend V _mvim(const MV &mv) throw();
165 template <class MV,class V> friend V _mvre(const MV &mv) throw();
166 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
167 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
168 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
169 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
170 
171  template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) throw();
172  template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) throw();
173  template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) throw();
174  template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) throw();
175  template <class MV,class S> friend MV &_mvssetim(MV &mv, const S &s) throw();
176  template <class MV,class S> friend MV &_mvssetre(MV &mv, const S &s) throw();
177 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
178 #if(CXSC_INDEX_CHECK)
179  throw(OP_WITH_WRONG_DIM);
180 #else
181  throw();
182 #endif
183 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
184 #if(CXSC_INDEX_CHECK)
185  throw(OP_WITH_WRONG_DIM);
186 #else
187  throw();
188 #endif
189  template <class MV1,class MV2,class S> friend S _mvmvcimult(const MV1 & rv1, const MV2 &rv2)
190 #if(CXSC_INDEX_CHECK)
191  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
192 #else
193  throw();
194 #endif
195  template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
196 #if(CXSC_INDEX_CHECK)
197  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
198 #else
199  throw();
200 #endif
201  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
202  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
203 #if(CXSC_INDEX_CHECK)
204  throw(ERROR__OP_WITH_WRONG_DIM<E>);
205 #else
206  throw();
207 #endif
208  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
209 #if(CXSC_INDEX_CHECK)
210  throw(ERROR__OP_WITH_WRONG_DIM<E>);
211 #else
212  throw();
213 #endif
214  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
215 #if(CXSC_INDEX_CHECK)
216  throw(ERROR__OP_WITH_WRONG_DIM<E>);
217 #else
218  throw();
219 #endif
220  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
221 #if(CXSC_INDEX_CHECK)
222  throw(ERROR__OP_WITH_WRONG_DIM<E>);
223 #else
224  throw();
225 #endif
226  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
227 #if(CXSC_INDEX_CHECK)
228  throw(ERROR__OP_WITH_WRONG_DIM<E>);
229 #else
230  throw();
231 #endif
232  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
233 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
234 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
235 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
236 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
237 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
238 #if(CXSC_INDEX_CHECK)
239  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
240 #else
241  throw();
242 #endif
243 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
244 #if(CXSC_INDEX_CHECK)
245  throw(ERROR__OP_WITH_WRONG_DIM<V>);
246 #else
247  throw();
248 #endif
249 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
250 #if(CXSC_INDEX_CHECK)
251  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
252 #else
253  throw();
254 #endif
255 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
256 #if(CXSC_INDEX_CHECK)
257  throw(ERROR__OP_WITH_WRONG_DIM<V>);
258 #else
259  throw();
260 #endif
261  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
262 #if(CXSC_INDEX_CHECK)
263  throw(ERROR__OP_WITH_WRONG_DIM<E>);
264 #else
265  throw();
266 #endif
267  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
268 #if(CXSC_INDEX_CHECK)
269  throw(ERROR__OP_WITH_WRONG_DIM<E>);
270 #else
271  throw();
272 #endif
273 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
274 #if(CXSC_INDEX_CHECK)
275  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
276 #else
277  throw();
278 #endif
279  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
280 #if(CXSC_INDEX_CHECK)
281  throw(ERROR__OP_WITH_WRONG_DIM<E>);
282 #else
283  throw();
284 #endif
285  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
286 #if(CXSC_INDEX_CHECK)
287  throw(ERROR__OP_WITH_WRONG_DIM<E>);
288 #else
289  throw();
290 #endif
291 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
292 #if(CXSC_INDEX_CHECK)
293  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
294 #else
295  throw();
296 #endif
297 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
298 #if(CXSC_INDEX_CHECK)
299  throw(ERROR__OP_WITH_WRONG_DIM<V>);
300 #else
301  throw();
302 #endif
303 
304  // Real
305 
306  // complex
307 
308  // interval
309 
310 #endif
311 
312  //----------------- Konstruktoren ----------------------------------
313 
315  explicit INLINE cimatrix_subv (cinterval *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) { }
316  public:
318  INLINE cimatrix_subv(const cimatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
319  public:
320 
321  //---------------------- Standardfunktionen ------------------------
322 
331 
333  cimatrix_subv &operator =(const scivector &rv);
335  cimatrix_subv &operator =(const srvector &rv);
337  cimatrix_subv &operator =(const scvector &rv);
339  cimatrix_subv &operator =(const sivector &rv);
340 
349 
351  cimatrix_subv &operator =(const cimatrix_subv &rv) throw();
353  cimatrix_subv &operator =(const cinterval &r) throw();
356 #if(CXSC_INDEX_CHECK)
357  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
358 #else
359  throw();
360 #endif
363 #if(CXSC_INDEX_CHECK)
364  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
365 #else
366  throw();
367 #endif
368  INLINE cimatrix_subv &operator =(const civector &v)
370 #if(CXSC_INDEX_CHECK)
371  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
372 #else
373  throw();
374 #endif
375  INLINE cimatrix_subv &operator =(const civector_slice &v)
377 #if(CXSC_INDEX_CHECK)
378  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
379 #else
380  throw();
381 #endif
382  // Real
384  INLINE cimatrix_subv &operator =(const real &r) throw();
386  INLINE cimatrix_subv &operator =(const rmatrix &m)
387 #if(CXSC_INDEX_CHECK)
388  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
389 #else
390  throw();
391 #endif
392  INLINE cimatrix_subv &operator =(const rmatrix_slice &m)
394 #if(CXSC_INDEX_CHECK)
395  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
396 #else
397  throw();
398 #endif
399  INLINE cimatrix_subv &operator =(const rvector &v)
401 #if(CXSC_INDEX_CHECK)
402  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
403 #else
404  throw();
405 #endif
406  INLINE cimatrix_subv &operator =(const rvector_slice &v)
408 #if(CXSC_INDEX_CHECK)
409  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
410 #else
411  throw();
412 #endif
413  INLINE cimatrix_subv &operator =(const rmatrix_subv &rv) throw();
415 
416  // complex
418  INLINE cimatrix_subv &operator =(const complex &r) throw();
420  INLINE cimatrix_subv &operator =(const cmatrix &m)
421 #if(CXSC_INDEX_CHECK)
422  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
423 #else
424  throw();
425 #endif
426  INLINE cimatrix_subv &operator =(const cmatrix_slice &m)
428 #if(CXSC_INDEX_CHECK)
429  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
430 #else
431  throw();
432 #endif
433  INLINE cimatrix_subv &operator =(const cvector &v)
435 #if(CXSC_INDEX_CHECK)
436  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
437 #else
438  throw();
439 #endif
440  INLINE cimatrix_subv &operator =(const cvector_slice &v)
442 #if(CXSC_INDEX_CHECK)
443  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
444 #else
445  throw();
446 #endif
447  INLINE cimatrix_subv &operator =(const cmatrix_subv &rv) throw();
449 
450  // interval
452  INLINE cimatrix_subv &operator =(const interval &r) throw();
454  INLINE cimatrix_subv &operator =(const imatrix &m)
455 #if(CXSC_INDEX_CHECK)
456  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
457 #else
458  throw();
459 #endif
460  INLINE cimatrix_subv &operator =(const imatrix_slice &m)
462 #if(CXSC_INDEX_CHECK)
463  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
464 #else
465  throw();
466 #endif
467  INLINE cimatrix_subv &operator =(const ivector &v)
469 #if(CXSC_INDEX_CHECK)
470  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
471 #else
472  throw();
473 #endif
474  INLINE cimatrix_subv &operator =(const ivector_slice &v)
476 #if(CXSC_INDEX_CHECK)
477  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
478 #else
479  throw();
480 #endif
481  INLINE cimatrix_subv &operator =(const imatrix_subv &rv) throw();
483 
485  friend INLINE int Lb(const cimatrix_subv &rv) throw() { return rv.lb; }
487  friend INLINE int Ub(const cimatrix_subv &rv) throw() { return rv.ub; }
489  friend INLINE int VecLen(const cimatrix_subv &rv) throw() { return rv.size; }
490 
492  INLINE cinterval &operator [](const int &i) const
493 #if(CXSC_INDEX_CHECK)
494  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
495 #else
496  throw();
497 #endif
498 
500  INLINE cinterval &operator [](const int &i)
501 #if(CXSC_INDEX_CHECK)
502  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
503 #else
504  throw();
505 #endif
506 
508  INLINE cimatrix_subv &operator ()() throw() { return *this; }
510  INLINE cimatrix_subv operator ()(const int &i)
511 #if(CXSC_INDEX_CHECK)
512  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
513 #else
514  throw();
515 #endif
516  INLINE cimatrix_subv operator ()(const int &i1,const int &i2)
518 #if(CXSC_INDEX_CHECK)
519  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
520 #else
521  throw();
522 #endif
523 
525  INLINE cimatrix_subv &operator *=(const cinterval &c) throw();
527  INLINE cimatrix_subv &operator +=(const cinterval &c) throw();
529  INLINE cimatrix_subv &operator -=(const cinterval &c) throw();
531  INLINE cimatrix_subv &operator /=(const cinterval &c) throw();
533  INLINE cimatrix_subv &operator -=(const scivector &rv);
535  INLINE cimatrix_subv &operator +=(const scivector &rv);
537  INLINE cimatrix_subv &operator &=(const scivector &rv);
539  INLINE cimatrix_subv &operator |=(const scivector &rv);
541  INLINE cimatrix_subv &operator -=(const scivector_slice &rv);
543  INLINE cimatrix_subv &operator +=(const scivector_slice &rv);
545  INLINE cimatrix_subv &operator &=(const scivector_slice &rv);
547  INLINE cimatrix_subv &operator |=(const scivector_slice &rv);
549  INLINE cimatrix_subv &operator -=(const scimatrix_subv &rv);
551  INLINE cimatrix_subv &operator +=(const scimatrix_subv &rv);
553  INLINE cimatrix_subv &operator &=(const scimatrix_subv &rv);
555  INLINE cimatrix_subv &operator |=(const scimatrix_subv &rv);
556 
558  INLINE cimatrix_subv &operator -=(const civector &rv)
559 #if(CXSC_INDEX_CHECK)
560  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
561 #else
562  throw();
563 #endif
564  INLINE cimatrix_subv &operator +=(const civector &rv)
566 #if(CXSC_INDEX_CHECK)
567  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
568 #else
569  throw();
570 #endif
571  INLINE cimatrix_subv &operator -=(const civector_slice &rv)
573 #if(CXSC_INDEX_CHECK)
574  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
575 #else
576  throw();
577 #endif
578  INLINE cimatrix_subv &operator +=(const civector_slice &rv)
580 #if(CXSC_INDEX_CHECK)
581  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
582 #else
583  throw();
584 #endif
585  INLINE cimatrix_subv &operator |=(const civector &rv)
587 #if(CXSC_INDEX_CHECK)
588  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
589 #else
590  throw();
591 #endif
592  INLINE cimatrix_subv &operator |=(const civector_slice &rv)
594 #if(CXSC_INDEX_CHECK)
595  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
596 #else
597  throw();
598 #endif
599  INLINE cimatrix_subv &operator &=(const civector &rv)
601 #if(CXSC_INDEX_CHECK)
602  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
603 #else
604  throw();
605 #endif
606  INLINE cimatrix_subv &operator &=(const civector_slice &rv)
608 #if(CXSC_INDEX_CHECK)
609  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
610 #else
611  throw();
612 #endif
613  // real
615  INLINE cimatrix_subv &operator *=(const real &c) throw();
617  INLINE cimatrix_subv &operator +=(const real &c) throw();
619  INLINE cimatrix_subv &operator -=(const real &c) throw();
621  INLINE cimatrix_subv &operator /=(const real &c) throw();
623  INLINE cimatrix_subv &operator -=(const srvector &rv);
625  INLINE cimatrix_subv &operator +=(const srvector &rv);
627  INLINE cimatrix_subv &operator |=(const srvector &rv);
629  INLINE cimatrix_subv &operator -=(const srvector_slice &rv);
631  INLINE cimatrix_subv &operator +=(const srvector_slice &rv);
633  INLINE cimatrix_subv &operator |=(const srvector_slice &rv);
635  INLINE cimatrix_subv &operator -=(const srmatrix_subv &rv);
637  INLINE cimatrix_subv &operator +=(const srmatrix_subv &rv);
639  INLINE cimatrix_subv &operator |=(const srmatrix_subv &rv);
641  INLINE cimatrix_subv &operator -=(const rvector &rv)
642 #if(CXSC_INDEX_CHECK)
643  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
644 #else
645  throw();
646 #endif
647  INLINE cimatrix_subv &operator +=(const rvector &rv)
649 #if(CXSC_INDEX_CHECK)
650  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
651 #else
652  throw();
653 #endif
654  INLINE cimatrix_subv &operator -=(const rvector_slice &rv)
656 #if(CXSC_INDEX_CHECK)
657  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
658 #else
659  throw();
660 #endif
661  INLINE cimatrix_subv &operator +=(const rvector_slice &rv)
663 #if(CXSC_INDEX_CHECK)
664  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
665 #else
666  throw();
667 #endif
668  INLINE cimatrix_subv &operator |=(const rvector &rv)
670 #if(CXSC_INDEX_CHECK)
671  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
672 #else
673  throw();
674 #endif
675  INLINE cimatrix_subv &operator |=(const rvector_slice &rv)
677 #if(CXSC_INDEX_CHECK)
678  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
679 #else
680  throw();
681 #endif
682  INLINE cimatrix_subv &operator &=(const rvector &rv)
684 #if(CXSC_INDEX_CHECK)
685  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
686 #else
687  throw();
688 #endif
689  INLINE cimatrix_subv &operator &=(const rvector_slice &rv)
691 #if(CXSC_INDEX_CHECK)
692  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
693 #else
694  throw();
695 #endif
696  // complex
698  INLINE cimatrix_subv &operator *=(const complex &c) throw();
700  INLINE cimatrix_subv &operator +=(const complex &c) throw();
702  INLINE cimatrix_subv &operator -=(const complex &c) throw();
704  INLINE cimatrix_subv &operator /=(const complex &c) throw();
706  INLINE cimatrix_subv &operator -=(const scvector &rv);
708  INLINE cimatrix_subv &operator +=(const scvector &rv);
710  INLINE cimatrix_subv &operator |=(const scvector &rv);
712  INLINE cimatrix_subv &operator -=(const scvector_slice &rv);
714  INLINE cimatrix_subv &operator +=(const scvector_slice &rv);
716  INLINE cimatrix_subv &operator |=(const scvector_slice &rv);
718  INLINE cimatrix_subv &operator -=(const scmatrix_subv &rv);
720  INLINE cimatrix_subv &operator +=(const scmatrix_subv &rv);
722  INLINE cimatrix_subv &operator &=(const scmatrix_subv &rv);
724  INLINE cimatrix_subv &operator |=(const scmatrix_subv &rv);
726  INLINE cimatrix_subv &operator -=(const cvector &rv)
727 #if(CXSC_INDEX_CHECK)
728  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
729 #else
730  throw();
731 #endif
732  INLINE cimatrix_subv &operator +=(const cvector &rv)
734 #if(CXSC_INDEX_CHECK)
735  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
736 #else
737  throw();
738 #endif
739  INLINE cimatrix_subv &operator -=(const cvector_slice &rv)
741 #if(CXSC_INDEX_CHECK)
742  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
743 #else
744  throw();
745 #endif
746  INLINE cimatrix_subv &operator +=(const cvector_slice &rv)
748 #if(CXSC_INDEX_CHECK)
749  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
750 #else
751  throw();
752 #endif
753  INLINE cimatrix_subv &operator |=(const cvector &rv)
755 #if(CXSC_INDEX_CHECK)
756  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
757 #else
758  throw();
759 #endif
760  INLINE cimatrix_subv &operator |=(const cvector_slice &rv)
762 #if(CXSC_INDEX_CHECK)
763  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
764 #else
765  throw();
766 #endif
767  INLINE cimatrix_subv &operator &=(const cvector &rv)
769 #if(CXSC_INDEX_CHECK)
770  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
771 #else
772  throw();
773 #endif
774  INLINE cimatrix_subv &operator &=(const cvector_slice &rv)
776 #if(CXSC_INDEX_CHECK)
777  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
778 #else
779  throw();
780 #endif
781  // interval
783  INLINE cimatrix_subv &operator *=(const interval &c) throw();
785  INLINE cimatrix_subv &operator +=(const interval &c) throw();
787  INLINE cimatrix_subv &operator -=(const interval &c) throw();
789  INLINE cimatrix_subv &operator /=(const interval &c) throw();
791  INLINE cimatrix_subv &operator -=(const sivector &rv);
793  INLINE cimatrix_subv &operator +=(const sivector &rv);
795  INLINE cimatrix_subv &operator &=(const sivector &rv);
797  INLINE cimatrix_subv &operator |=(const sivector &rv);
799  INLINE cimatrix_subv &operator -=(const sivector_slice &rv);
801  INLINE cimatrix_subv &operator +=(const sivector_slice &rv);
803  INLINE cimatrix_subv &operator &=(const sivector_slice &rv);
805  INLINE cimatrix_subv &operator |=(const sivector_slice &rv);
807  INLINE cimatrix_subv &operator -=(const simatrix_subv &rv);
809  INLINE cimatrix_subv &operator +=(const simatrix_subv &rv);
811  INLINE cimatrix_subv &operator &=(const simatrix_subv &rv);
813  INLINE cimatrix_subv &operator |=(const simatrix_subv &rv);
815  INLINE cimatrix_subv &operator -=(const ivector &rv)
816 #if(CXSC_INDEX_CHECK)
817  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
818 #else
819  throw();
820 #endif
821  INLINE cimatrix_subv &operator +=(const ivector &rv)
823 #if(CXSC_INDEX_CHECK)
824  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
825 #else
826  throw();
827 #endif
828  INLINE cimatrix_subv &operator -=(const ivector_slice &rv)
830 #if(CXSC_INDEX_CHECK)
831  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
832 #else
833  throw();
834 #endif
835  INLINE cimatrix_subv &operator +=(const ivector_slice &rv)
837 #if(CXSC_INDEX_CHECK)
838  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
839 #else
840  throw();
841 #endif
842  INLINE cimatrix_subv &operator |=(const ivector &rv)
844 #if(CXSC_INDEX_CHECK)
845  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
846 #else
847  throw();
848 #endif
849  INLINE cimatrix_subv &operator |=(const ivector_slice &rv)
851 #if(CXSC_INDEX_CHECK)
852  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
853 #else
854  throw();
855 #endif
856  INLINE cimatrix_subv &operator &=(const ivector &rv)
858 #if(CXSC_INDEX_CHECK)
859  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
860 #else
861  throw();
862 #endif
863  INLINE cimatrix_subv &operator &=(const ivector_slice &rv)
865 #if(CXSC_INDEX_CHECK)
866  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
867 #else
868  throw();
869 #endif
870 //#else
871 //#endif
872 
873 };
874 
875 
877 INLINE cimatrix_subv Row(cimatrix &m,const int &i)
878 #if(CXSC_INDEX_CHECK)
879  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
880 #else
881  throw();
882 #endif
883 INLINE cimatrix_subv Col(cimatrix &m,const int &i)
885 #if(CXSC_INDEX_CHECK)
886  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
887 #else
888  throw();
889 #endif
890 
891 
892 
893 
894 class cimatrix_slice;
895 
896 // ---------------------------------------------------------------------------
897 // ---- ----
898 // ---- class cimatrix (declaration) ----
899 // ---- ----
900 // ---------------------------------------------------------------------------
901 
902 
904 
907 class cimatrix
908 {
909  friend class cimatrix_slice;
910  friend class cimatrix_subv;
911  private:
912  cinterval *dat;
913  int lb1,ub1,lb2,ub2,xsize,ysize;
914 
915  public:
916 //#if(CXSC_INDEX_CHECK)
917 #ifdef _CXSC_FRIEND_TPL
918  //----------------- Templates ---------------------------------------
919 template <class S,class M> friend void _smconstr(S &s,const M &m)
920 #if(CXSC_INDEX_CHECK)
921  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
922 #else
923  throw();
924 #endif
925 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
926 #if(CXSC_INDEX_CHECK)
927  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
928 #else
929  throw();
930 #endif
931  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
932  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
933  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
934 #if(CXSC_INDEX_CHECK)
935  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
936 #else
937  throw();
938 #endif
939  template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
940 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
941 #if(CXSC_INDEX_CHECK)
942  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
943 #else
944  throw();
945 #endif
946 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
947  template <class M> friend int _mlb(const M &m, const int &i)
948 #if(CXSC_INDEX_CHECK)
949  throw(ERROR__WRONG_ROW_OR_COL<M>);
950 #else
951  throw();
952 #endif
953  template <class M> friend int _mub(const M &m, const int &i)
954 #if(CXSC_INDEX_CHECK)
955  throw(ERROR__WRONG_ROW_OR_COL<M>);
956 #else
957  throw();
958 #endif
959  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
960 #if(CXSC_INDEX_CHECK)
961  throw(ERROR__WRONG_ROW_OR_COL<M>);
962 #else
963  throw();
964 #endif
965  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
966 #if(CXSC_INDEX_CHECK)
967  throw(ERROR__WRONG_ROW_OR_COL<M>);
968 #else
969  throw();
970 #endif
971  template <class M> friend void _mresize(M &A) throw();
972  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
973 #if(CXSC_INDEX_CHECK)
974  throw(ERROR__WRONG_BOUNDARIES<M>);
975 #else
976  throw();
977 #endif
978  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
979 #if(CXSC_INDEX_CHECK)
980  throw(ERROR__WRONG_BOUNDARIES<M>);
981 #else
982  throw();
983 #endif
984  template <class M,class E> friend E _mabs(const M &m) throw();
985  template <class M,class E> friend E _mdiam(const M &m) throw();
986  template <class M,class E> friend E _mmid(const M &m) throw();
987  template <class M,class E> friend E _mre(const M &m) throw();
988  template <class M,class E> friend E _mim(const M &m) throw();
989  friend INLINE rmatrix SupRe(const cimatrix &v) throw();
990  friend INLINE rmatrix SupIm(const cimatrix &v) throw();
991  friend INLINE rmatrix InfRe(const cimatrix &v) throw();
992  friend INLINE rmatrix InfIm(const cimatrix &v) throw();
993  template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
994 #if(CXSC_INDEX_CHECK)
995  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
996 #else
997  throw();
998 #endif
999  template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
1000 #if(CXSC_INDEX_CHECK)
1001  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1002 #else
1003  throw();
1004 #endif
1005  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1006 #if(CXSC_INDEX_CHECK)
1007  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1008 #else
1009  throw();
1010 #endif
1011  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1012 #if(CXSC_INDEX_CHECK)
1013  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1014 #else
1015  throw();
1016 #endif
1017  template <class M,class E> friend E _minf(const M &m) throw();
1018  template <class M,class E> friend E _msup(const M &m) throw();
1019  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
1020 #if(CXSC_INDEX_CHECK)
1021  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1022 #else
1023  throw();
1024 #endif
1025  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
1026 #if(CXSC_INDEX_CHECK)
1027  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1028 #else
1029  throw();
1030 #endif
1031  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1032 #if(CXSC_INDEX_CHECK)
1033  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1034 #else
1035  throw();
1036 #endif
1037  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1038 #if(CXSC_INDEX_CHECK)
1039  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1040 #else
1041  throw();
1042 #endif
1043  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
1044 #if(CXSC_INDEX_CHECK)
1045  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1046 #else
1047  throw();
1048 #endif
1049  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
1050 #if(CXSC_INDEX_CHECK)
1051  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1052 #else
1053  throw();
1054 #endif
1055  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1056 #if(CXSC_INDEX_CHECK)
1057  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1058 #else
1059  throw();
1060 #endif
1061  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1062 #if(CXSC_INDEX_CHECK)
1063  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1064 #else
1065  throw();
1066 #endif
1067  //-------------- matrix-matrix -------------
1068  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
1069 #if(CXSC_INDEX_CHECK)
1070  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1071 #else
1072  throw();
1073 #endif
1074  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1075 #if(CXSC_INDEX_CHECK)
1076  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1077 #else
1078  throw();
1079 #endif
1080  template <class M> friend M _mminus(const M &m) throw();
1081  template <class MS,class E> friend E _msminus(const MS &ms) throw();
1082  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
1083 #if(CXSC_INDEX_CHECK)
1084  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1085 #else
1086  throw();
1087 #endif
1088  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
1089 #if(CXSC_INDEX_CHECK)
1090  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1091 #else
1092  throw();
1093 #endif
1094  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1095 #if(CXSC_INDEX_CHECK)
1096  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1097 #else
1098  throw();
1099 #endif
1100  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1101 #if(CXSC_INDEX_CHECK)
1102  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1103 #else
1104  throw();
1105 #endif
1106  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1107 #if(CXSC_INDEX_CHECK)
1108  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1109 #else
1110  throw();
1111 #endif
1112  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1113 #if(CXSC_INDEX_CHECK)
1114  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1115 #else
1116  throw();
1117 #endif
1118  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1119 #if(CXSC_INDEX_CHECK)
1120  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1121 #else
1122  throw();
1123 #endif
1124  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1125 #if(CXSC_INDEX_CHECK)
1126  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1127 #else
1128  throw();
1129 #endif
1130  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
1131 #if(CXSC_INDEX_CHECK)
1132  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1133 #else
1134  throw();
1135 #endif
1136  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1137 #if(CXSC_INDEX_CHECK)
1138  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1139 #else
1140  throw();
1141 #endif
1142  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1143 #if(CXSC_INDEX_CHECK)
1144  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1145 #else
1146  throw();
1147 #endif
1148  template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
1149 #if(CXSC_INDEX_CHECK)
1150  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1151 #else
1152  throw();
1153 #endif
1154  template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
1155 #if(CXSC_INDEX_CHECK)
1156  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1157 #else
1158  throw();
1159 #endif
1160  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1161 #if(CXSC_INDEX_CHECK)
1162  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1163 #else
1164  throw();
1165 #endif
1166  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1167 #if(CXSC_INDEX_CHECK)
1168  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1169 #else
1170  throw();
1171 #endif
1172  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1173 #if(CXSC_INDEX_CHECK)
1174  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1175 #else
1176  throw();
1177 #endif
1178  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1179 #if(CXSC_INDEX_CHECK)
1180  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1181 #else
1182  throw();
1183 #endif
1184  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
1185 #if(CXSC_INDEX_CHECK)
1186  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1187 #else
1188  throw();
1189 #endif
1190  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1191 #if(CXSC_INDEX_CHECK)
1192  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1193 #else
1194  throw();
1195 #endif
1196  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
1197 #if(CXSC_INDEX_CHECK)
1198  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1199 #else
1200  throw();
1201 #endif
1202  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1203 #if(CXSC_INDEX_CHECK)
1204  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1205 #else
1206  throw();
1207 #endif
1208  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1209 #if(CXSC_INDEX_CHECK)
1210  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1211 #else
1212  throw();
1213 #endif
1214  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1215 #if(CXSC_INDEX_CHECK)
1216  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1217 #else
1218  throw();
1219 #endif
1220  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
1221 #if(CXSC_INDEX_CHECK)
1222  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1223 #else
1224  throw();
1225 #endif
1226  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1227 #if(CXSC_INDEX_CHECK)
1228  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1229 #else
1230  throw();
1231 #endif
1232  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
1233 #if(CXSC_INDEX_CHECK)
1234  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1235 #else
1236  throw();
1237 #endif
1238  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1239 #if(CXSC_INDEX_CHECK)
1240  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1241 #else
1242  throw();
1243 #endif
1244  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1245 #if(CXSC_INDEX_CHECK)
1246  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1247 #else
1248  throw();
1249 #endif
1250  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1251 #if(CXSC_INDEX_CHECK)
1252  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1253 #else
1254  throw();
1255 #endif
1256  //-------- matrix-scalar -----------------
1257  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
1258  template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
1259  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1260  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
1261  template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
1262  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1263  //-------- matrix-vector ---------------------
1264  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1265 #if(CXSC_INDEX_CHECK)
1266  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1267 #else
1268  throw();
1269 #endif
1270  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1271 #if(CXSC_INDEX_CHECK)
1272  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1273 #else
1274  throw();
1275 #endif
1276  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1277 #if(CXSC_INDEX_CHECK)
1278  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1279 #else
1280  throw();
1281 #endif
1282  template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1283 #if(CXSC_INDEX_CHECK)
1284  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1285 #else
1286  throw();
1287 #endif
1288 
1289  template <class M> friend void *_mvoid(const M &m) throw();
1290  template <class M> friend bool _mnot(const M &m) throw();
1291  template <class MS> friend void *_msvoid(const MS &ms) throw();
1292  template <class MS> friend bool _msnot(const MS &ms) throw();
1293  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
1294  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
1295  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
1296  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
1297  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1298  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1299  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1300  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1301  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1302  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1303  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
1304  template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
1305 
1306  // Real
1307 
1308  //--- Real --------- matrix-matrix ----------------------
1309 
1310  //--- Real --------- matrix-scalar ----------------------
1311 
1312  //--- Real --------- matrix-vector ----------------------
1313  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1314 #if(CXSC_INDEX_CHECK)
1315  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1316 #else
1317  throw();
1318 #endif
1319  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1320 #if(CXSC_INDEX_CHECK)
1321  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1322 #else
1323  throw();
1324 #endif
1325 
1326  // interval
1327 
1328  //--- interval --------- matrix-matrix ----------------------
1329 
1330  //--- interval --------- matrix-scalar ----------------------
1331 
1332 
1333  //--- interval --------- matrix-vector ----------------------
1334 
1335  // complex
1336 
1337  //--- complex --------- matrix-matrix ----------------------
1338 
1339  //--- complex --------- matrix-scalar ----------------------
1340 
1341  //--- complex --------- matrix-vector ----------------------
1342 
1343  // --- complex x real ----------------
1344  // -- complex x interval ----------------------
1345  // ---- complex x interval --- scalar--------
1346 
1347 
1348  // ---- complex x interval --- vector --------
1349  // ---- complex x interval --- matrix ------------
1350 
1351  // complex x complex --------------------
1352 
1353 
1354 #endif
1355 
1356  //-------------------------- Konstruktoren ----------------------------
1357 
1358 // cinterval
1360  INLINE cimatrix(const cimatrix &rm) throw();
1362  INLINE cimatrix(const cimatrix_slice &rm) throw();
1364  INLINE cimatrix(const scimatrix &rm);
1366  INLINE cimatrix(const scimatrix_slice &rm);
1368  INLINE cimatrix() throw();
1370  explicit INLINE cimatrix(const int &m, const int &n)
1371 #if(CXSC_INDEX_CHECK)
1372  throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
1373 #else
1374  throw();
1375 #endif
1376  explicit INLINE cimatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1378 #if(CXSC_INDEX_CHECK)
1379  throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
1380 #else
1381  throw();
1382 #endif
1383  explicit INLINE cimatrix(const civector &v) throw();
1386  explicit INLINE cimatrix(const civector_slice &v) throw();
1388  explicit INLINE cimatrix(const cinterval &r) throw();
1390  INLINE cimatrix &operator =(const cinterval &r) throw();
1392  INLINE cimatrix &operator =(const cimatrix &m) throw();
1394  INLINE cimatrix &operator =(const cimatrix_slice &ms) throw();
1396  INLINE cimatrix &operator =(const scimatrix &m);
1398  INLINE cimatrix &operator =(const scimatrix_slice &ms);
1400  INLINE cimatrix &operator =(const civector &v) throw();
1402  INLINE cimatrix &operator =(const civector_slice &v) throw();
1403 // real
1405  explicit INLINE cimatrix(const real &r) throw();
1407  explicit INLINE cimatrix(const rmatrix &rm) throw();
1409  explicit INLINE cimatrix(const rmatrix_slice &rm) throw();
1411  explicit INLINE cimatrix(const srmatrix &rm);
1413  explicit INLINE cimatrix(const srmatrix_slice &rm);
1415  explicit INLINE cimatrix(const rvector &v) throw();
1417  explicit INLINE cimatrix(const rvector_slice &v) throw();
1419  INLINE cimatrix &operator =(const real &r) throw();
1421  INLINE cimatrix &operator =(const rmatrix &m) throw();
1423  INLINE cimatrix &operator =(const rmatrix_slice &ms) throw();
1425  INLINE cimatrix &operator =(const srmatrix &m);
1427  INLINE cimatrix &operator =(const srmatrix_slice &ms);
1429  INLINE cimatrix &operator =(const rvector &v) throw();
1431  INLINE cimatrix &operator =(const rvector_slice &v) throw();
1432 
1433 // complex
1435  explicit INLINE cimatrix(const complex &r) throw();
1437  explicit INLINE cimatrix(const cmatrix &rm) throw();
1439  explicit INLINE cimatrix(const cmatrix_slice &rm) throw();
1441  explicit INLINE cimatrix(const scmatrix &rm);
1443  explicit INLINE cimatrix(const scmatrix_slice &rm);
1445  explicit INLINE cimatrix(const cvector &v) throw();
1447  explicit INLINE cimatrix(const cvector_slice &v) throw();
1449  INLINE cimatrix &operator =(const complex &r) throw();
1451  INLINE cimatrix &operator =(const cmatrix &m) throw();
1453  INLINE cimatrix &operator =(const cmatrix_slice &ms) throw();
1455  INLINE cimatrix &operator =(const scmatrix &m);
1457  INLINE cimatrix &operator =(const scmatrix_slice &ms);
1459  INLINE cimatrix &operator =(const cvector &v) throw();
1461  INLINE cimatrix &operator =(const cvector_slice &v) throw();
1462 
1463 // interval
1465  explicit INLINE cimatrix(const interval &r) throw();
1467  explicit INLINE cimatrix(const imatrix &rm) throw();
1469  explicit INLINE cimatrix(const imatrix_slice &rm) throw();
1471  explicit INLINE cimatrix(const simatrix &rm);
1473  explicit INLINE cimatrix(const simatrix_slice &rm);
1475  explicit INLINE cimatrix(const ivector &v) throw();
1477  explicit INLINE cimatrix(const ivector_slice &v) throw();
1479  INLINE cimatrix &operator =(const interval &r) throw();
1481  INLINE cimatrix &operator =(const imatrix &m) throw();
1483  INLINE cimatrix &operator =(const imatrix_slice &ms) throw();
1485  INLINE cimatrix &operator =(const simatrix &m);
1487  INLINE cimatrix &operator =(const simatrix_slice &ms);
1489  INLINE cimatrix &operator =(const ivector &v) throw();
1491  INLINE cimatrix &operator =(const ivector_slice &v) throw();
1492 
1493  //--------------------------- Destruktoren -----------------------------
1494 
1495  INLINE ~cimatrix() throw() { delete [] dat; }
1496 
1497  //--------------------------- Operatoren -----------------------------
1499  INLINE cimatrix &operator +=(const scimatrix &m1);
1501  INLINE cimatrix &operator +=(const scimatrix_slice &m1);
1503  INLINE cimatrix &operator -=(const scimatrix &m1);
1505  INLINE cimatrix &operator -=(const scimatrix_slice &m1);
1507  INLINE cimatrix &operator |=(const scimatrix &m1);
1509  INLINE cimatrix &operator |=(const scimatrix_slice &m1);
1511  INLINE cimatrix &operator &=(const scimatrix &m1);
1513  INLINE cimatrix &operator &=(const scimatrix_slice &m1);
1515  INLINE cimatrix &operator *=(const scimatrix &m1);
1517  INLINE cimatrix &operator *=(const scimatrix_slice &m1);
1518 
1520  INLINE cimatrix &operator +=(const srmatrix &m1);
1522  INLINE cimatrix &operator +=(const srmatrix_slice &m1);
1524  INLINE cimatrix &operator -=(const srmatrix &m1);
1526  INLINE cimatrix &operator -=(const srmatrix_slice &m1);
1528  INLINE cimatrix &operator |=(const srmatrix &m1);
1530  INLINE cimatrix &operator |=(const srmatrix_slice &m1);
1532  INLINE cimatrix &operator &=(const srmatrix &m1);
1534  INLINE cimatrix &operator &=(const srmatrix_slice &m1);
1536  INLINE cimatrix &operator *=(const srmatrix &m1);
1538  INLINE cimatrix &operator *=(const srmatrix_slice &m1);
1539 
1541  INLINE cimatrix &operator +=(const scmatrix &m1);
1543  INLINE cimatrix &operator +=(const scmatrix_slice &m1);
1545  INLINE cimatrix &operator -=(const scmatrix &m1);
1547  INLINE cimatrix &operator -=(const scmatrix_slice &m1);
1549  INLINE cimatrix &operator |=(const scmatrix &m1);
1551  INLINE cimatrix &operator |=(const scmatrix_slice &m1);
1553  INLINE cimatrix &operator &=(const scmatrix &m1);
1555  INLINE cimatrix &operator &=(const scmatrix_slice &m1);
1557  INLINE cimatrix &operator *=(const scmatrix &m1);
1559  INLINE cimatrix &operator *=(const scmatrix_slice &m1);
1560 
1562  INLINE cimatrix &operator +=(const simatrix &m1);
1564  INLINE cimatrix &operator +=(const simatrix_slice &m1);
1566  INLINE cimatrix &operator -=(const simatrix &m1);
1568  INLINE cimatrix &operator -=(const simatrix_slice &m1);
1570  INLINE cimatrix &operator |=(const simatrix &m1);
1572  INLINE cimatrix &operator |=(const simatrix_slice &m1);
1574  INLINE cimatrix &operator &=(const simatrix &m1);
1576  INLINE cimatrix &operator &=(const simatrix_slice &m1);
1578  INLINE cimatrix &operator *=(const simatrix &m1);
1580  INLINE cimatrix &operator *=(const simatrix_slice &m1);
1581 
1583  INLINE cimatrix operator()(const intvector& p, const intvector& q);
1585  INLINE cimatrix operator()(const intmatrix& P, const intmatrix& Q);
1587  INLINE cimatrix operator()(const intvector& p);
1589  INLINE cimatrix operator()(const intmatrix& P);
1590 
1591  //------------------------- Standardfunktionen -------------------------
1592 
1594  INLINE cimatrix_subv operator [](const int &i) const
1595 #if(CXSC_INDEX_CHECK)
1596  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1597 #else
1598  throw();
1599 #endif
1600  INLINE cimatrix_subv operator [](const cxscmatrix_column &i) const
1602 #if(CXSC_INDEX_CHECK)
1603  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1604 #else
1605  throw();
1606 #endif
1607  INLINE cimatrix_subv operator [](const int &i)
1609 #if(CXSC_INDEX_CHECK)
1610  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1611 #else
1612  throw();
1613 #endif
1614  INLINE cimatrix_subv operator [](const cxscmatrix_column &i)
1616 #if(CXSC_INDEX_CHECK)
1617  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1618 #else
1619  throw();
1620 #endif
1621 
1623  INLINE cimatrix &operator ()() throw() { return *this; }
1625  INLINE cimatrix_slice operator ()(const int &m, const int &n)
1626 #if(CXSC_INDEX_CHECK)
1627  throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
1628 #else
1629  throw();
1630 #endif
1631  INLINE cimatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1633 #if(CXSC_INDEX_CHECK)
1634  throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
1635 #else
1636  throw();
1637 #endif
1638  INLINE operator void*() throw();
1639 //#else
1640 //#endif
1641 };
1642 
1643 
1645 
1651 {
1652  friend class cimatrix;
1653  private:
1654  cinterval *dat;
1655  int offset1,offset2,mxsize,mysize;
1656  int start1,end1,start2,end2,sxsize,sysize; // slice size
1657 
1658  public:
1659 //#if(CXSC_INDEX_CHECK)
1660 #ifdef _CXSC_FRIEND_TPL
1661  //----------------- Templates ---------------------------------------
1662 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1663 #if(CXSC_INDEX_CHECK)
1664  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1665 #else
1666  throw();
1667 #endif
1668  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1669 #if(CXSC_INDEX_CHECK)
1670  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1671 #else
1672  throw();
1673 #endif
1674  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1675 #if(CXSC_INDEX_CHECK)
1676  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1677 #else
1678  throw();
1679 #endif
1680  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
1681  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
1682  template <class MS> friend int _mslb(const MS &ms, const int &i)
1683 #if(CXSC_INDEX_CHECK)
1684  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1685 #else
1686  throw();
1687 #endif
1688  template <class MS> friend int _msub(const MS &ms, const int &i)
1689 #if(CXSC_INDEX_CHECK)
1690  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1691 #else
1692  throw();
1693 #endif
1694  template <class MS,class E> friend E _msabs(const MS &ms) throw();
1695  template <class MS,class E> friend E _msinf(const MS &ms) throw();
1696  template <class MS,class E> friend E _mssup(const MS &ms) throw();
1697  template <class MS,class E> friend E _msdiam(const MS &ms) throw();
1698  template <class MS,class E> friend E _msmid(const MS &ms) throw();
1699  template <class MS,class E> friend E _msre(const MS &ms) throw();
1700  template <class MS,class E> friend E _msim(const MS &ms) throw();
1701  friend INLINE rmatrix SupRe(const cimatrix_slice &v) throw();
1702  friend INLINE rmatrix SupIm(const cimatrix_slice &v) throw();
1703  friend INLINE rmatrix InfRe(const cimatrix_slice &v) throw();
1704  friend INLINE rmatrix InfIm(const cimatrix_slice &v) throw();
1705  template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
1706 #if(CXSC_INDEX_CHECK)
1707  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1708 #else
1709  throw();
1710 #endif
1711  template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
1712 #if(CXSC_INDEX_CHECK)
1713  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1714 #else
1715  throw();
1716 #endif
1717  template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1718 #if(CXSC_INDEX_CHECK)
1719  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1720 #else
1721  throw();
1722 #endif
1723  template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1724 #if(CXSC_INDEX_CHECK)
1725  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1726 #else
1727  throw();
1728 #endif
1729  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
1730 #if(CXSC_INDEX_CHECK)
1731  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1732 #else
1733  throw();
1734 #endif
1735  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
1736 #if(CXSC_INDEX_CHECK)
1737  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1738 #else
1739  throw();
1740 #endif
1741  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1742 #if(CXSC_INDEX_CHECK)
1743  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1744 #else
1745  throw();
1746 #endif
1747  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1748 #if(CXSC_INDEX_CHECK)
1749  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1750 #else
1751  throw();
1752 #endif
1753  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
1754 #if(CXSC_INDEX_CHECK)
1755  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1756 #else
1757  throw();
1758 #endif
1759  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
1760 #if(CXSC_INDEX_CHECK)
1761  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1762 #else
1763  throw();
1764 #endif
1765  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1766 #if(CXSC_INDEX_CHECK)
1767  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1768 #else
1769  throw();
1770 #endif
1771  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1772 #if(CXSC_INDEX_CHECK)
1773  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1774 #else
1775  throw();
1776 #endif
1777  //-------- matrix-matrix --------------
1778  template <class MS,class E> friend E _msminus(const MS &ms) throw();
1779  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1780 #if(CXSC_INDEX_CHECK)
1781  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1782 #else
1783  throw();
1784 #endif
1785  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1786 #if(CXSC_INDEX_CHECK)
1787  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1788 #else
1789  throw();
1790 #endif
1791  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1792 #if(CXSC_INDEX_CHECK)
1793  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1794 #else
1795  throw();
1796 #endif
1797  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1798 #if(CXSC_INDEX_CHECK)
1799  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1800 #else
1801  throw();
1802 #endif
1803  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1804 #if(CXSC_INDEX_CHECK)
1805  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1806 #else
1807  throw();
1808 #endif
1809  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1810 #if(CXSC_INDEX_CHECK)
1811  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1812 #else
1813  throw();
1814 #endif
1815  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1816 #if(CXSC_INDEX_CHECK)
1817  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1818 #else
1819  throw();
1820 #endif
1821  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1822 #if(CXSC_INDEX_CHECK)
1823  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1824 #else
1825  throw();
1826 #endif
1827  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1828 #if(CXSC_INDEX_CHECK)
1829  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1830 #else
1831  throw();
1832 #endif
1833  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1834 #if(CXSC_INDEX_CHECK)
1835  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1836 #else
1837  throw();
1838 #endif
1839  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1840 #if(CXSC_INDEX_CHECK)
1841  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1842 #else
1843  throw();
1844 #endif
1845  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1846 #if(CXSC_INDEX_CHECK)
1847  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1848 #else
1849  throw();
1850 #endif
1851  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1852 #if(CXSC_INDEX_CHECK)
1853  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1854 #else
1855  throw();
1856 #endif
1857  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1858 #if(CXSC_INDEX_CHECK)
1859  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1860 #else
1861  throw();
1862 #endif
1863  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1864 #if(CXSC_INDEX_CHECK)
1865  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1866 #else
1867  throw();
1868 #endif
1869  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1870 #if(CXSC_INDEX_CHECK)
1871  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1872 #else
1873  throw();
1874 #endif
1875  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1876 #if(CXSC_INDEX_CHECK)
1877  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1878 #else
1879  throw();
1880 #endif
1881  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1882 #if(CXSC_INDEX_CHECK)
1883  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1884 #else
1885  throw();
1886 #endif
1887  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1888 #if(CXSC_INDEX_CHECK)
1889  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1890 #else
1891  throw();
1892 #endif
1893  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1894 #if(CXSC_INDEX_CHECK)
1895  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1896 #else
1897  throw();
1898 #endif
1899  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1900 #if(CXSC_INDEX_CHECK)
1901  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1902 #else
1903  throw();
1904 #endif
1905  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1906 #if(CXSC_INDEX_CHECK)
1907  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1908 #else
1909  throw();
1910 #endif
1911  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1912 #if(CXSC_INDEX_CHECK)
1913  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1914 #else
1915  throw();
1916 #endif
1917  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1918 #if(CXSC_INDEX_CHECK)
1919  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1920 #else
1921  throw();
1922 #endif
1923  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1924 #if(CXSC_INDEX_CHECK)
1925  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1926 #else
1927  throw();
1928 #endif
1929  //--------- matrix-vector --------------
1930  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1931 #if(CXSC_INDEX_CHECK)
1932  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1933 #else
1934  throw();
1935 #endif
1936  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1937 #if(CXSC_INDEX_CHECK)
1938  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1939 #else
1940  throw();
1941 #endif
1942  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1943 #if(CXSC_INDEX_CHECK)
1944  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1945 #else
1946  throw();
1947 #endif
1948  //--------- matrix-scalar --------------
1949  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1950  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
1951  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1952  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
1953 
1954  template <class MS> friend void *_msvoid(const MS &ms) throw();
1955  template <class MS> friend bool _msnot(const MS &ms) throw();
1956  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1957  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1958  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1959  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1960  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1961  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1962  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
1963  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
1964  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
1965  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
1966  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
1967  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
1968 
1969  // Real
1970 
1971  //--- Real ------------ matrix-scalar -----------
1972 
1973 
1974  //--- Real ------------ matrix-vector -----------
1975 
1976  //--- Real ------------ matrix-matrix -----------
1977 
1978  // interval
1979 
1980  //--- interval ------------ matrix-scalar -----------
1981 
1982 
1983  //--- interval ------------ matrix-vector -----------
1984 
1985  //--- interval ------------ matrix-matrix -----------
1986 
1987  // complex
1988 
1989  //--- complex ------------ matrix-scalar -----------
1990 
1991 
1992  //--- complex ------------ matrix-vector -----------
1993 
1994 
1995  //--- complex ------------ matrix-matrix -----------
1996 
1997 
1998 #endif
1999 
2000  //--------------- Konstruktoren ----------------------------------------
2001 
2003  explicit INLINE cimatrix_slice(cimatrix &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) { }
2005  explicit INLINE cimatrix_slice(cimatrix_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) { }
2006  public:
2008  INLINE cimatrix_slice(const cimatrix_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) { }
2009  public:
2010 
2011  //---------------- Standardfunktionen -----------------------------------
2012 
2013  friend INLINE civector::civector(const cimatrix_slice &sl)
2014 #if(CXSC_INDEX_CHECK)
2015  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
2016 #else
2017  throw();
2018 #endif
2019  friend INLINE cimatrix::cimatrix(const cimatrix_slice &) throw();
2021  INLINE cimatrix_slice &operator =(const cimatrix &m)
2022 #if(CXSC_INDEX_CHECK)
2023  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2024 #else
2025  throw();
2026 #endif
2027  INLINE cimatrix_slice &operator =(const cimatrix_slice &ms)
2029 #if(CXSC_INDEX_CHECK)
2030  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2031 #else
2032  throw();
2033 #endif
2034  INLINE cimatrix_slice &operator =(const cinterval &r) throw();
2037  INLINE cimatrix_slice &operator =(const scimatrix &v);
2039  INLINE cimatrix_slice &operator =(const scimatrix_subv &v);
2041  INLINE cimatrix_slice &operator =(const scimatrix_slice &v);
2043  INLINE cimatrix_slice &operator =(const civector &v)
2044 #if(CXSC_INDEX_CHECK)
2045  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2046 #else
2047  throw();
2048 #endif
2049  INLINE cimatrix_slice &operator =(const civector_slice &v)
2051 #if(CXSC_INDEX_CHECK)
2052  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2053 #else
2054  throw();
2055 #endif
2056  INLINE cimatrix_slice &operator =(const cimatrix_subv &v)
2058 #if(CXSC_INDEX_CHECK)
2059  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2060 #else
2061  throw();
2062 #endif
2063  // real
2065  INLINE cimatrix_slice &operator =(const srmatrix &v);
2067  INLINE cimatrix_slice &operator =(const srmatrix_subv &v);
2069  INLINE cimatrix_slice &operator =(const srmatrix_slice &v);
2071  INLINE cimatrix_slice &operator =(const rmatrix &m)
2072 #if(CXSC_INDEX_CHECK)
2073  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2074 #else
2075  throw();
2076 #endif
2077  INLINE cimatrix_slice &operator =(const rmatrix_slice &ms)
2079 #if(CXSC_INDEX_CHECK)
2080  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2081 #else
2082  throw();
2083 #endif
2084  INLINE cimatrix_slice &operator =(const real &r) throw();
2087  INLINE cimatrix_slice &operator =(const rvector &v)
2088 #if(CXSC_INDEX_CHECK)
2089  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2090 #else
2091  throw();
2092 #endif
2093  INLINE cimatrix_slice &operator =(const rvector_slice &v)
2095 #if(CXSC_INDEX_CHECK)
2096  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2097 #else
2098  throw();
2099 #endif
2100  INLINE cimatrix_slice &operator =(const rmatrix_subv &v)
2102 #if(CXSC_INDEX_CHECK)
2103  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2104 #else
2105  throw();
2106 #endif
2107 
2108  // interval
2110  INLINE cimatrix_slice &operator =(const simatrix_subv &v);
2112  INLINE cimatrix_slice &operator =(const simatrix &v);
2114  INLINE cimatrix_slice &operator =(const simatrix_slice &v);
2116  INLINE cimatrix_slice &operator =(const imatrix &m)
2117 #if(CXSC_INDEX_CHECK)
2118  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2119 #else
2120  throw();
2121 #endif
2122  INLINE cimatrix_slice &operator =(const imatrix_slice &ms)
2124 #if(CXSC_INDEX_CHECK)
2125  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2126 #else
2127  throw();
2128 #endif
2129  INLINE cimatrix_slice &operator =(const interval &r) throw();
2132  INLINE cimatrix_slice &operator =(const ivector &v)
2133 #if(CXSC_INDEX_CHECK)
2134  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2135 #else
2136  throw();
2137 #endif
2138  INLINE cimatrix_slice &operator =(const ivector_slice &v)
2140 #if(CXSC_INDEX_CHECK)
2141  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2142 #else
2143  throw();
2144 #endif
2145  INLINE cimatrix_slice &operator =(const imatrix_subv &v)
2147 #if(CXSC_INDEX_CHECK)
2148  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2149 #else
2150  throw();
2151 #endif
2152 
2153  // complex
2155  INLINE cimatrix_slice &operator =(const scmatrix &v);
2157  INLINE cimatrix_slice &operator =(const scmatrix_subv &v);
2159  INLINE cimatrix_slice &operator =(const scmatrix_slice &v);
2161  INLINE cimatrix_slice &operator =(const cmatrix &m)
2162 #if(CXSC_INDEX_CHECK)
2163  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2164 #else
2165  throw();
2166 #endif
2167  INLINE cimatrix_slice &operator =(const cmatrix_slice &ms)
2169 #if(CXSC_INDEX_CHECK)
2170  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2171 #else
2172  throw();
2173 #endif
2174  INLINE cimatrix_slice &operator =(const complex &r) throw();
2177  INLINE cimatrix_slice &operator =(const cvector &v)
2178 #if(CXSC_INDEX_CHECK)
2179  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2180 #else
2181  throw();
2182 #endif
2183  INLINE cimatrix_slice &operator =(const cvector_slice &v)
2185 #if(CXSC_INDEX_CHECK)
2186  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2187 #else
2188  throw();
2189 #endif
2190  INLINE cimatrix_slice &operator =(const cmatrix_subv &v)
2192 #if(CXSC_INDEX_CHECK)
2193  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2194 #else
2195  throw();
2196 #endif
2197 
2199  INLINE cimatrix_subv operator [](const int &i)
2200 #if(CXSC_INDEX_CHECK)
2201  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2202 #else
2203  throw();
2204 #endif
2205  INLINE cimatrix_subv operator [](const cxscmatrix_column &i)
2207 #if(CXSC_INDEX_CHECK)
2208  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2209 #else
2210  throw();
2211 #endif
2212 
2214  INLINE cimatrix_subv operator [](const int &i) const
2215 #if(CXSC_INDEX_CHECK)
2216  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2217 #else
2218  throw();
2219 #endif
2220  INLINE cimatrix_subv operator [](const cxscmatrix_column &i) const
2222 #if(CXSC_INDEX_CHECK)
2223  throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2224 #else
2225  throw();
2226 #endif
2227 
2229  INLINE cimatrix_slice &operator ()() throw() { return *this; }
2231  INLINE cimatrix_slice operator ()(const int &m, const int &n)
2232 #if(CXSC_INDEX_CHECK)
2233  throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
2234 #else
2235  throw();
2236 #endif
2237  INLINE cimatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
2239 #if(CXSC_INDEX_CHECK)
2240  throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
2241 #else
2242  throw();
2243 #endif
2244  INLINE operator void*() throw();
2245 
2247  INLINE cimatrix_slice &operator +=(const cinterval &c) throw();
2249  INLINE cimatrix_slice &operator -=(const cinterval &c) throw();
2251  INLINE cimatrix_slice &operator *=(const cinterval &c) throw();
2253  INLINE cimatrix_slice &operator /=(const cinterval &c) throw();
2255  INLINE cimatrix_slice &operator +=(const scimatrix &m1);
2257  INLINE cimatrix_slice &operator +=(const scimatrix_slice &m1);
2259  INLINE cimatrix_slice &operator -=(const scimatrix &m1);
2261  INLINE cimatrix_slice &operator -=(const scimatrix_slice &m1);
2263  INLINE cimatrix_slice &operator |=(const scimatrix &m1);
2265  INLINE cimatrix_slice &operator |=(const scimatrix_slice &m1);
2267  INLINE cimatrix_slice &operator &=(const scimatrix &m1);
2269  INLINE cimatrix_slice &operator &=(const scimatrix_slice &m1);
2271  INLINE cimatrix_slice &operator *=(const scimatrix &m1);
2273  INLINE cimatrix_slice &operator *=(const scimatrix_slice &m1);
2274 
2276  INLINE cimatrix_slice &operator +=(const cimatrix &m1)
2277 #if(CXSC_INDEX_CHECK)
2278  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2279 #else
2280  throw();
2281 #endif
2282  INLINE cimatrix_slice &operator +=(const cimatrix_slice &ms2)
2284 #if(CXSC_INDEX_CHECK)
2285  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2286 #else
2287  throw();
2288 #endif
2289  INLINE cimatrix_slice &operator -=(const cimatrix &m1)
2291 #if(CXSC_INDEX_CHECK)
2292  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2293 #else
2294  throw();
2295 #endif
2296  INLINE cimatrix_slice &operator -=(const cimatrix_slice &ms2)
2298 #if(CXSC_INDEX_CHECK)
2299  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2300 #else
2301  throw();
2302 #endif
2303  INLINE cimatrix_slice &operator |=(const cimatrix &m1)
2305 #if(CXSC_INDEX_CHECK)
2306  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2307 #else
2308  throw();
2309 #endif
2310  INLINE cimatrix_slice &operator |=(const cimatrix_slice &ms2)
2312 #if(CXSC_INDEX_CHECK)
2313  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2314 #else
2315  throw();
2316 #endif
2317  INLINE cimatrix_slice &operator &=(const cimatrix &m1)
2319 #if(CXSC_INDEX_CHECK)
2320  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2321 #else
2322  throw();
2323 #endif
2324  INLINE cimatrix_slice &operator &=(const cimatrix_slice &ms2)
2326 #if(CXSC_INDEX_CHECK)
2327  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2328 #else
2329  throw();
2330 #endif
2331  INLINE cimatrix_slice &operator *=(const cimatrix &m)
2333 #if(CXSC_INDEX_CHECK)
2334  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2335 #else
2336  throw();
2337 #endif
2338  INLINE cimatrix_slice &operator *=(const cimatrix_slice &ms2)
2340 #if(CXSC_INDEX_CHECK)
2341  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2342 #else
2343  throw();
2344 #endif
2345 
2347  INLINE cimatrix_slice &operator +=(const real &c) throw();
2349  INLINE cimatrix_slice &operator -=(const real &c) throw();
2351  INLINE cimatrix_slice &operator *=(const real &c) throw();
2353  INLINE cimatrix_slice &operator /=(const real &c) throw();
2355  INLINE cimatrix_slice &operator +=(const srmatrix &m1);
2357  INLINE cimatrix_slice &operator +=(const srmatrix_slice &m1);
2359  INLINE cimatrix_slice &operator -=(const srmatrix &m1);
2361  INLINE cimatrix_slice &operator -=(const srmatrix_slice &m1);
2363  INLINE cimatrix_slice &operator |=(const srmatrix &m1);
2365  INLINE cimatrix_slice &operator |=(const srmatrix_slice &m1);
2367  INLINE cimatrix_slice &operator &=(const srmatrix &m1);
2369  INLINE cimatrix_slice &operator &=(const srmatrix_slice &m1);
2371  INLINE cimatrix_slice &operator *=(const srmatrix &m1);
2373  INLINE cimatrix_slice &operator *=(const srmatrix_slice &m1);
2374 
2376  INLINE cimatrix_slice &operator +=(const rmatrix_slice &ms2)
2377 #if(CXSC_INDEX_CHECK)
2378  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2379 #else
2380  throw();
2381 #endif
2382  INLINE cimatrix_slice &operator +=(const rmatrix &m1)
2384 #if(CXSC_INDEX_CHECK)
2385  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2386 #else
2387  throw();
2388 #endif
2389  INLINE cimatrix_slice &operator -=(const rmatrix &m1)
2391 #if(CXSC_INDEX_CHECK)
2392  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2393 #else
2394  throw();
2395 #endif
2396  INLINE cimatrix_slice &operator -=(const rmatrix_slice &ms2)
2398 #if(CXSC_INDEX_CHECK)
2399  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2400 #else
2401  throw();
2402 #endif
2403  INLINE cimatrix_slice &operator |=(const rmatrix &m1)
2405 #if(CXSC_INDEX_CHECK)
2406  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2407 #else
2408  throw();
2409 #endif
2410  INLINE cimatrix_slice &operator |=(const rmatrix_slice &ms2)
2412 #if(CXSC_INDEX_CHECK)
2413  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2414 #else
2415  throw();
2416 #endif
2417  INLINE cimatrix_slice &operator &=(const rmatrix &m1)
2419 #if(CXSC_INDEX_CHECK)
2420  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2421 #else
2422  throw();
2423 #endif
2424  INLINE cimatrix_slice &operator &=(const rmatrix_slice &ms2)
2426 #if(CXSC_INDEX_CHECK)
2427  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2428 #else
2429  throw();
2430 #endif
2431  INLINE cimatrix_slice &operator *=(const rmatrix &m)
2433 #if(CXSC_INDEX_CHECK)
2434  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2435 #else
2436  throw();
2437 #endif
2438  INLINE cimatrix_slice &operator *=(const rmatrix_slice &ms2)
2440 #if(CXSC_INDEX_CHECK)
2441  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2442 #else
2443  throw();
2444 #endif
2445 
2447  INLINE cimatrix_slice &operator +=(const complex &c) throw();
2449  INLINE cimatrix_slice &operator -=(const complex &c) throw();
2451  INLINE cimatrix_slice &operator *=(const complex &c) throw();
2453  INLINE cimatrix_slice &operator /=(const complex &c) throw();
2455  INLINE cimatrix_slice &operator +=(const scmatrix &m1);
2457  INLINE cimatrix_slice &operator +=(const scmatrix_slice &m1);
2459  INLINE cimatrix_slice &operator -=(const scmatrix &m1);
2461  INLINE cimatrix_slice &operator -=(const scmatrix_slice &m1);
2463  INLINE cimatrix_slice &operator |=(const scmatrix &m1);
2465  INLINE cimatrix_slice &operator |=(const scmatrix_slice &m1);
2467  INLINE cimatrix_slice &operator &=(const scmatrix &m1);
2469  INLINE cimatrix_slice &operator &=(const scmatrix_slice &m1);
2471  INLINE cimatrix_slice &operator *=(const scmatrix &m1);
2473  INLINE cimatrix_slice &operator *=(const scmatrix_slice &m1);
2474 
2476  INLINE cimatrix_slice &operator +=(const cmatrix_slice &ms2)
2477 #if(CXSC_INDEX_CHECK)
2478  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2479 #else
2480  throw();
2481 #endif
2482  INLINE cimatrix_slice &operator +=(const cmatrix &m1)
2484 #if(CXSC_INDEX_CHECK)
2485  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2486 #else
2487  throw();
2488 #endif
2489  INLINE cimatrix_slice &operator -=(const cmatrix &m1)
2491 #if(CXSC_INDEX_CHECK)
2492  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2493 #else
2494  throw();
2495 #endif
2496  INLINE cimatrix_slice &operator -=(const cmatrix_slice &ms2)
2498 #if(CXSC_INDEX_CHECK)
2499  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2500 #else
2501  throw();
2502 #endif
2503  INLINE cimatrix_slice &operator |=(const cmatrix &m1)
2505 #if(CXSC_INDEX_CHECK)
2506  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2507 #else
2508  throw();
2509 #endif
2510  INLINE cimatrix_slice &operator |=(const cmatrix_slice &ms2)
2512 #if(CXSC_INDEX_CHECK)
2513  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2514 #else
2515  throw();
2516 #endif
2517  INLINE cimatrix_slice &operator &=(const cmatrix &m1)
2519 #if(CXSC_INDEX_CHECK)
2520  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2521 #else
2522  throw();
2523 #endif
2524  INLINE cimatrix_slice &operator &=(const cmatrix_slice &ms2)
2526 #if(CXSC_INDEX_CHECK)
2527  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2528 #else
2529  throw();
2530 #endif
2531  INLINE cimatrix_slice &operator *=(const cmatrix &m)
2533 #if(CXSC_INDEX_CHECK)
2534  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2535 #else
2536  throw();
2537 #endif
2538  INLINE cimatrix_slice &operator *=(const cmatrix_slice &ms2)
2540 #if(CXSC_INDEX_CHECK)
2541  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2542 #else
2543  throw();
2544 #endif
2545 
2547  INLINE cimatrix_slice &operator +=(const interval &c) throw();
2549  INLINE cimatrix_slice &operator -=(const interval &c) throw();
2551  INLINE cimatrix_slice &operator *=(const interval &c) throw();
2553  INLINE cimatrix_slice &operator /=(const interval &c) throw();
2555  INLINE cimatrix_slice &operator +=(const simatrix &m1);
2557  INLINE cimatrix_slice &operator +=(const simatrix_slice &m1);
2559  INLINE cimatrix_slice &operator -=(const simatrix &m1);
2561  INLINE cimatrix_slice &operator -=(const simatrix_slice &m1);
2563  INLINE cimatrix_slice &operator |=(const simatrix &m1);
2565  INLINE cimatrix_slice &operator |=(const simatrix_slice &m1);
2567  INLINE cimatrix_slice &operator &=(const simatrix &m1);
2569  INLINE cimatrix_slice &operator &=(const simatrix_slice &m1);
2571  INLINE cimatrix_slice &operator *=(const simatrix &m1);
2573  INLINE cimatrix_slice &operator *=(const simatrix_slice &m1);
2574 
2576  INLINE cimatrix_slice &operator +=(const imatrix_slice &ms2)
2577 #if(CXSC_INDEX_CHECK)
2578  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2579 #else
2580  throw();
2581 #endif
2582  INLINE cimatrix_slice &operator +=(const imatrix &m1)
2584 #if(CXSC_INDEX_CHECK)
2585  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2586 #else
2587  throw();
2588 #endif
2589  INLINE cimatrix_slice &operator -=(const imatrix &m1)
2591 #if(CXSC_INDEX_CHECK)
2592  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2593 #else
2594  throw();
2595 #endif
2596  INLINE cimatrix_slice &operator -=(const imatrix_slice &ms2)
2598 #if(CXSC_INDEX_CHECK)
2599  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2600 #else
2601  throw();
2602 #endif
2603  INLINE cimatrix_slice &operator |=(const imatrix &m1)
2605 #if(CXSC_INDEX_CHECK)
2606  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2607 #else
2608  throw();
2609 #endif
2610  INLINE cimatrix_slice &operator |=(const imatrix_slice &ms2)
2612 #if(CXSC_INDEX_CHECK)
2613  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2614 #else
2615  throw();
2616 #endif
2617  INLINE cimatrix_slice &operator &=(const imatrix &m1)
2619 #if(CXSC_INDEX_CHECK)
2620  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2621 #else
2622  throw();
2623 #endif
2624  INLINE cimatrix_slice &operator &=(const imatrix_slice &ms2)
2626 #if(CXSC_INDEX_CHECK)
2627  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2628 #else
2629  throw();
2630 #endif
2631  INLINE cimatrix_slice &operator *=(const imatrix &m)
2633 #if(CXSC_INDEX_CHECK)
2634  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2635 #else
2636  throw();
2637 #endif
2638  INLINE cimatrix_slice &operator *=(const imatrix_slice &ms2)
2640 #if(CXSC_INDEX_CHECK)
2641  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2642 #else
2643  throw();
2644 #endif
2645 
2646 //#else
2647 //#endif
2648 };
2649 
2650 //================================================================
2651 //====================== Subvector Functions =====================
2652 
2653 //=======================Vector / Scalar =========================
2654 
2656  INLINE civector operator /(const cimatrix_subv &rv, const cinterval &s) throw();
2658  INLINE civector operator *(const cimatrix_subv &rv, const cinterval &s) throw();
2660  INLINE civector operator *(const cinterval &s, const cimatrix_subv &rv) throw();
2662  INLINE ivector abs(const cimatrix_subv &mv) throw();
2664  INLINE cvector diam(const cimatrix_subv &mv) throw();
2666  INLINE cvector mid(const cimatrix_subv &mv) throw();
2668  INLINE cvector Inf(const cimatrix_subv &mv) throw();
2670  INLINE cvector Sup(const cimatrix_subv &mv) throw();
2672  INLINE ivector Im(const cimatrix_subv &mv) throw();
2674  INLINE ivector Re(const cimatrix_subv &mv) throw();
2676  INLINE rmatrix SupRe(const cimatrix &v) throw();
2678  INLINE rmatrix SupIm(const cimatrix &v) throw();
2680  INLINE rmatrix InfRe(const cimatrix &v) throw();
2682  INLINE rmatrix InfIm(const cimatrix &v) throw();
2684  INLINE rmatrix SupRe(const cimatrix_slice &v) throw();
2686  INLINE rmatrix SupIm(const cimatrix_slice &v) throw();
2688  INLINE rmatrix InfRe(const cimatrix_slice &v) throw();
2690  INLINE rmatrix InfIm(const cimatrix_slice &v) throw();
2692  INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,const cvector &rv)
2693 #if(CXSC_INDEX_CHECK)
2694  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2695 #else
2696  throw();
2697 #endif
2698  INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,const cvector &rv)
2700 #if(CXSC_INDEX_CHECK)
2701  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2702 #else
2703  throw();
2704 #endif
2705  INLINE cimatrix_subv &UncheckedSetInf(cimatrix_subv &iv,const cvector &rv)
2707 #if(CXSC_INDEX_CHECK)
2708  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2709 #else
2710  throw();
2711 #endif
2712  INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,const cvector &rv)
2714 #if(CXSC_INDEX_CHECK)
2715  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2716 #else
2717  throw();
2718 #endif
2719  INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,const ivector &rv)
2721 #if(CXSC_INDEX_CHECK)
2722  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2723 #else
2724  throw();
2725 #endif
2726  INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,const ivector &rv)
2728 #if(CXSC_INDEX_CHECK)
2729  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2730 #else
2731  throw();
2732 #endif
2733 
2735  INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,const complex &r) throw();
2737  INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,const complex &r) throw();
2739  INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,const complex &r) throw();
2741  INLINE cimatrix_subv &SetUncheckedInf(cimatrix_subv &iv,const complex &r) throw();
2743  INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,const interval &r) throw();
2745  INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,const interval &r) throw();
2746 
2747 //======================== Vector / Vector ========================
2748 
2749 
2751  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2752 #if(CXSC_INDEX_CHECK)
2753  throw(OP_WITH_WRONG_DIM);
2754 #else
2755  throw();
2756 #endif
2757  void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
2759 #if(CXSC_INDEX_CHECK)
2760  throw(OP_WITH_WRONG_DIM);
2761 #else
2762  throw();
2763 #endif
2764  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
2766 #if(CXSC_INDEX_CHECK)
2767  throw(OP_WITH_WRONG_DIM);
2768 #else
2769  throw();
2770 #endif
2771  void accumulate(cidotprecision &dp, const civector_slice & sl1, const cimatrix_subv &rv2)
2773 #if(CXSC_INDEX_CHECK)
2774  throw(OP_WITH_WRONG_DIM);
2775 #else
2776  throw();
2777 #endif
2778  void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &rv2)
2780 #if(CXSC_INDEX_CHECK)
2781  throw(OP_WITH_WRONG_DIM);
2782 #else
2783  throw();
2784 #endif
2785  void accumulate(cidotprecision &dp, const civector_slice & sl1, const cmatrix_subv &rv2)
2787 #if(CXSC_INDEX_CHECK)
2788  throw(OP_WITH_WRONG_DIM);
2789 #else
2790  throw();
2791 #endif
2792 
2794  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector_slice &sl2)
2795 #if(CXSC_INDEX_CHECK)
2796  throw(OP_WITH_WRONG_DIM);
2797 #else
2798  throw();
2799 #endif
2800 
2802  INLINE cinterval operator *(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2803 #if(CXSC_INDEX_CHECK)
2804  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2805 #else
2806  throw();
2807 #endif
2808  INLINE cinterval operator *(const civector & rv1, const cimatrix_subv &rv2)
2810 #if(CXSC_INDEX_CHECK)
2811  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2812 #else
2813  throw();
2814 #endif
2815  INLINE cinterval operator *(const cimatrix_subv &rv1,const civector &rv2)
2817 #if(CXSC_INDEX_CHECK)
2818  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2819 #else
2820  throw();
2821 #endif
2822  INLINE cinterval operator *(const civector_slice &sl,const cimatrix_subv &sv)
2824 #if(CXSC_INDEX_CHECK)
2825  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2826 #else
2827  throw();
2828 #endif
2829  INLINE cinterval operator *(const cimatrix_subv &mv,const civector_slice &vs)
2831 #if(CXSC_INDEX_CHECK)
2832  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2833 #else
2834  throw();
2835 #endif
2836 
2838  INLINE civector operator +(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2839 #if(CXSC_INDEX_CHECK)
2840  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2841 #else
2842  throw();
2843 #endif
2844  INLINE civector operator +(const cimatrix_subv &rv1,const civector &rv2)
2846 #if(CXSC_INDEX_CHECK)
2847  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2848 #else
2849  throw();
2850 #endif
2851  INLINE civector operator +(const civector & rv1, const cimatrix_subv &rv2)
2853 #if(CXSC_INDEX_CHECK)
2854  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2855 #else
2856  throw();
2857 #endif
2858  INLINE civector operator +(const civector_slice &sl,const cimatrix_subv &mv)
2860 #if(CXSC_INDEX_CHECK)
2861  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2862 #else
2863  throw();
2864 #endif
2865  INLINE civector operator +(const cimatrix_subv &mv,const civector_slice &sl)
2867 #if(CXSC_INDEX_CHECK)
2868  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2869 #else
2870  throw();
2871 #endif
2872 
2874  INLINE civector operator -(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2875 #if(CXSC_INDEX_CHECK)
2876  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2877 #else
2878  throw();
2879 #endif
2880  INLINE civector operator -(const civector & rv1, const cimatrix_subv &rv2)
2882 #if(CXSC_INDEX_CHECK)
2883  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2884 #else
2885  throw();
2886 #endif
2887  INLINE civector operator -(const cimatrix_subv &rv1,const civector &rv2)
2889 #if(CXSC_INDEX_CHECK)
2890  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2891 #else
2892  throw();
2893 #endif
2894  INLINE civector operator -(const civector_slice &sl,const cimatrix_subv &mv)
2896 #if(CXSC_INDEX_CHECK)
2897  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2898 #else
2899  throw();
2900 #endif
2901  INLINE civector operator -(const cimatrix_subv &mv,const civector_slice &sl)
2903 #if(CXSC_INDEX_CHECK)
2904  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2905 #else
2906  throw();
2907 #endif
2908 
2909 // real
2910 
2912  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rmatrix_subv &rv2)
2913 #if(CXSC_INDEX_CHECK)
2914  throw(OP_WITH_WRONG_DIM);
2915 #else
2916  throw();
2917 #endif
2918  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector_slice &sl2)
2920 #if(CXSC_INDEX_CHECK)
2921  throw(OP_WITH_WRONG_DIM);
2922 #else
2923  throw();
2924 #endif
2925  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
2927 #if(CXSC_INDEX_CHECK)
2928  throw(OP_WITH_WRONG_DIM);
2929 #else
2930  throw();
2931 #endif
2932  void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
2934 #if(CXSC_INDEX_CHECK)
2935  throw(OP_WITH_WRONG_DIM);
2936 #else
2937  throw();
2938 #endif
2939  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cimatrix_subv &rv2)
2941 #if(CXSC_INDEX_CHECK)
2942  throw(OP_WITH_WRONG_DIM);
2943 #else
2944  throw();
2945 #endif
2946  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const cimatrix_subv &rv2)
2948 #if(CXSC_INDEX_CHECK)
2949  throw(OP_WITH_WRONG_DIM);
2950 #else
2951  throw();
2952 #endif
2953 
2954 // complex
2955 
2957  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cmatrix_subv &rv2)
2958 #if(CXSC_INDEX_CHECK)
2959  throw(OP_WITH_WRONG_DIM);
2960 #else
2961  throw();
2962 #endif
2963  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector_slice &sl2)
2965 #if(CXSC_INDEX_CHECK)
2966  throw(OP_WITH_WRONG_DIM);
2967 #else
2968  throw();
2969 #endif
2970  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
2972 #if(CXSC_INDEX_CHECK)
2973  throw(OP_WITH_WRONG_DIM);
2974 #else
2975  throw();
2976 #endif
2977  void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
2979 #if(CXSC_INDEX_CHECK)
2980  throw(OP_WITH_WRONG_DIM);
2981 #else
2982  throw();
2983 #endif
2984  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cimatrix_subv &rv2)
2986 #if(CXSC_INDEX_CHECK)
2987  throw(OP_WITH_WRONG_DIM);
2988 #else
2989  throw();
2990 #endif
2991  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cimatrix_subv &rv2)
2993 #if(CXSC_INDEX_CHECK)
2994  throw(OP_WITH_WRONG_DIM);
2995 #else
2996  throw();
2997 #endif
2998 
2999 // interval
3000 
3002  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const imatrix_subv &rv2)
3003 #if(CXSC_INDEX_CHECK)
3004  throw(OP_WITH_WRONG_DIM);
3005 #else
3006  throw();
3007 #endif
3008  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector_slice &sl2)
3010 #if(CXSC_INDEX_CHECK)
3011  throw(OP_WITH_WRONG_DIM);
3012 #else
3013  throw();
3014 #endif
3015  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
3017 #if(CXSC_INDEX_CHECK)
3018  throw(OP_WITH_WRONG_DIM);
3019 #else
3020  throw();
3021 #endif
3022  void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
3024 #if(CXSC_INDEX_CHECK)
3025  throw(OP_WITH_WRONG_DIM);
3026 #else
3027  throw();
3028 #endif
3029  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cimatrix_subv &rv2)
3031 #if(CXSC_INDEX_CHECK)
3032  throw(OP_WITH_WRONG_DIM);
3033 #else
3034  throw();
3035 #endif
3036  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const cimatrix_subv &rv2)
3038 #if(CXSC_INDEX_CHECK)
3039  throw(OP_WITH_WRONG_DIM);
3040 #else
3041  throw();
3042 #endif
3043  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const imatrix_subv &rv2)
3045 #if(CXSC_INDEX_CHECK)
3046  throw(OP_WITH_WRONG_DIM);
3047 #else
3048  throw();
3049 #endif
3050  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cmatrix_subv &rv2)
3052 #if(CXSC_INDEX_CHECK)
3053  throw(OP_WITH_WRONG_DIM);
3054 #else
3055  throw();
3056 #endif
3057 
3058 
3059 //====================================================================
3060 //===================== Matrix Functions =============================
3061 
3063  INLINE cimatrix _imatrix(const cimatrix &rm) throw();
3065  INLINE cimatrix _imatrix(const civector &v) throw();
3067  INLINE cimatrix _imatrix(const civector_slice &v) throw();
3069  INLINE cimatrix _imatrix(const cinterval &r) throw();
3070 
3072  INLINE int Lb(const cimatrix &rm, const int &i)
3073 #if(CXSC_INDEX_CHECK)
3074  throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3075 #else
3076  throw();
3077 #endif
3078  INLINE int Ub(const cimatrix &rm, const int &i)
3080 #if(CXSC_INDEX_CHECK)
3081  throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3082 #else
3083  throw();
3084 #endif
3085  INLINE int Lb(const cimatrix_slice &rm, const int &i)
3087 #if(CXSC_INDEX_CHECK)
3088  throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3089 #else
3090  throw();
3091 #endif
3092  INLINE int Ub(const cimatrix_slice &rm, const int &i)
3094 #if(CXSC_INDEX_CHECK)
3095  throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3096 #else
3097  throw();
3098 #endif
3099  INLINE cimatrix &SetLb(cimatrix &m, const int &i,const int &j)
3101 #if(CXSC_INDEX_CHECK)
3102  throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3103 #else
3104  throw();
3105 #endif
3106  INLINE cimatrix &SetUb(cimatrix &m, const int &i,const int &j)
3108 #if(CXSC_INDEX_CHECK)
3109  throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3110 #else
3111  throw();
3112 #endif
3113  INLINE void Resize(cimatrix &A) throw();
3116  INLINE void Resize(cimatrix &A,const int &m, const int &n)
3117 #if(CXSC_INDEX_CHECK)
3118  throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
3119 #else
3120  throw();
3121 #endif
3122  INLINE void Resize(cimatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
3124 #if(CXSC_INDEX_CHECK)
3125  throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
3126 #else
3127  throw();
3128 #endif
3129 
3131  INLINE imatrix abs(const cimatrix &m) throw();
3133  INLINE imatrix abs(const cimatrix_slice &ms) throw();
3135  INLINE cmatrix diam(const cimatrix &m) throw();
3137  INLINE cmatrix diam(const cimatrix_slice &m) throw();
3139  INLINE cmatrix mid(const cimatrix &m) throw();
3141  INLINE cmatrix mid(const cimatrix_slice &m) throw();
3143  INLINE cmatrix Inf(const cimatrix &m) throw();
3145  INLINE cmatrix Sup(const cimatrix &m) throw();
3147  INLINE cmatrix Inf(const cimatrix_slice &m) throw();
3149  INLINE cmatrix Sup(const cimatrix_slice &m) throw();
3151  INLINE cimatrix &SetInf(cimatrix &cm,const cmatrix &rm)
3152 #if(CXSC_INDEX_CHECK)
3153  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3154 #else
3155  throw();
3156 #endif
3157  INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,const cmatrix &rm)
3159 #if(CXSC_INDEX_CHECK)
3160  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3161 #else
3162  throw();
3163 #endif
3164  INLINE cimatrix &SetInf(cimatrix &cm,const cmatrix_slice &rm)
3166 #if(CXSC_INDEX_CHECK)
3167  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3168 #else
3169  throw();
3170 #endif
3171  INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,const cmatrix_slice &rm)
3173 #if(CXSC_INDEX_CHECK)
3174  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3175 #else
3176  throw();
3177 #endif
3178  INLINE cimatrix &SetSup(cimatrix &cm,const cmatrix &rm)
3180 #if(CXSC_INDEX_CHECK)
3181  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3182 #else
3183  throw();
3184 #endif
3185  INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,const cmatrix &rm)
3187 #if(CXSC_INDEX_CHECK)
3188  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3189 #else
3190  throw();
3191 #endif
3192  INLINE cimatrix &SetSup(cimatrix &cm,const cmatrix_slice &rm)
3194 #if(CXSC_INDEX_CHECK)
3195  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3196 #else
3197  throw();
3198 #endif
3199  INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,const cmatrix_slice &rm)
3201 #if(CXSC_INDEX_CHECK)
3202  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3203 #else
3204  throw();
3205 #endif
3206  INLINE cimatrix &UncheckedSetInf(cimatrix &cm,const cmatrix &rm)
3208 #if(CXSC_INDEX_CHECK)
3209  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3210 #else
3211  throw();
3212 #endif
3213  INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,const cmatrix &rm)
3215 #if(CXSC_INDEX_CHECK)
3216  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3217 #else
3218  throw();
3219 #endif
3220  INLINE cimatrix &UncheckedSetInf(cimatrix &cm,const cmatrix_slice &rm)
3222 #if(CXSC_INDEX_CHECK)
3223  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3224 #else
3225  throw();
3226 #endif
3227  INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,const cmatrix_slice &rm)
3229 #if(CXSC_INDEX_CHECK)
3230  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3231 #else
3232  throw();
3233 #endif
3234  INLINE cimatrix &UncheckedSetSup(cimatrix &cm,const cmatrix &rm)
3236 #if(CXSC_INDEX_CHECK)
3237  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3238 #else
3239  throw();
3240 #endif
3241  INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,const cmatrix &rm)
3243 #if(CXSC_INDEX_CHECK)
3244  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3245 #else
3246  throw();
3247 #endif
3248  INLINE cimatrix &UncheckedSetSup(cimatrix &cm,const cmatrix_slice &rm)
3250 #if(CXSC_INDEX_CHECK)
3251  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3252 #else
3253  throw();
3254 #endif
3255  INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,const cmatrix_slice &rm)
3257 #if(CXSC_INDEX_CHECK)
3258  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3259 #else
3260  throw();
3261 #endif
3262 
3264  INLINE imatrix Im(const cimatrix &m) throw();
3266  INLINE imatrix Re(const cimatrix &m) throw();
3268  INLINE imatrix Im(const cimatrix_slice &m) throw();
3270  INLINE imatrix Re(const cimatrix_slice &m) throw();
3272  INLINE cimatrix &SetIm(cimatrix &cm,const imatrix &rm)
3273 #if(CXSC_INDEX_CHECK)
3274  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3275 #else
3276  throw();
3277 #endif
3278  INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,const imatrix &rm)
3280 #if(CXSC_INDEX_CHECK)
3281  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3282 #else
3283  throw();
3284 #endif
3285  INLINE cimatrix &SetIm(cimatrix &cm,const imatrix_slice &rm)
3287 #if(CXSC_INDEX_CHECK)
3288  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3289 #else
3290  throw();
3291 #endif
3292  INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,const imatrix_slice &rm)
3294 #if(CXSC_INDEX_CHECK)
3295  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3296 #else
3297  throw();
3298 #endif
3299  INLINE cimatrix &SetRe(cimatrix &cm,const imatrix &rm)
3301 #if(CXSC_INDEX_CHECK)
3302  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3303 #else
3304  throw();
3305 #endif
3306  INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,const imatrix &rm)
3308 #if(CXSC_INDEX_CHECK)
3309  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3310 #else
3311  throw();
3312 #endif
3313  INLINE cimatrix &SetRe(cimatrix &cm,const imatrix_slice &rm)
3315 #if(CXSC_INDEX_CHECK)
3316  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3317 #else
3318  throw();
3319 #endif
3320  INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,const imatrix_slice &rm)
3322 #if(CXSC_INDEX_CHECK)
3323  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3324 #else
3325  throw();
3326 #endif
3327 
3328 //===================== Matrix / Scalar ===============================
3329 
3331  INLINE cimatrix operator *(const cinterval &c, const cimatrix &m) throw();
3333  INLINE cimatrix operator *(const cinterval &c, const cimatrix_slice &ms) throw();
3335  INLINE cimatrix operator *(const cimatrix &m,const cinterval &c) throw();
3337  INLINE cimatrix operator *(const cimatrix_slice &ms,const cinterval &c) throw();
3339  INLINE cimatrix &operator *=(cimatrix &m,const cinterval &c) throw();
3341  INLINE cimatrix operator /(const cimatrix &m,const cinterval &c) throw();
3343  INLINE cimatrix operator /(const cimatrix_slice &ms, const cinterval &c) throw();
3345  INLINE cimatrix &operator /=(cimatrix &m,const cinterval &c) throw();
3346 
3347 //------------ real - cimatrix -----------------------------------------------
3348 
3350  INLINE cimatrix operator *(const real &c, const cimatrix &m) throw();
3352  INLINE cimatrix operator *(const real &c, const cimatrix_slice &ms) throw();
3354  INLINE cimatrix operator *(const cimatrix &m,const real &c) throw();
3356  INLINE cimatrix operator *(const cimatrix_slice &ms,const real &c) throw();
3358  INLINE cimatrix &operator *=(cimatrix &m,const real &c) throw();
3360  INLINE cimatrix operator /(const cimatrix &m,const real &c) throw();
3362  INLINE cimatrix operator /(const cimatrix_slice &ms, const real &c) throw();
3364  INLINE cimatrix &operator /=(cimatrix &m,const real &c) throw();
3365 //----------------- rmatrix - cinterval ----------------
3366 
3368  INLINE cimatrix operator *(const cinterval &c, const rmatrix &m) throw();
3370  INLINE cimatrix operator *(const cinterval &c, const rmatrix_slice &ms) throw();
3372  INLINE cimatrix operator *(const rmatrix &m,const cinterval &c) throw();
3374  INLINE cimatrix operator *(const rmatrix_slice &ms,const cinterval &c) throw();
3376  INLINE cimatrix operator /(const rmatrix &m,const cinterval &c) throw();
3378  INLINE cimatrix operator /(const rmatrix_slice &ms, const cinterval &c) throw();
3379 
3380 //------------ complex - cimatrix -----------------------------------------------
3381 
3383  INLINE cimatrix operator *(const complex &c, const cimatrix &m) throw();
3385  INLINE cimatrix operator *(const complex &c, const cimatrix_slice &ms) throw();
3387  INLINE cimatrix operator *(const cimatrix &m,const complex &c) throw();
3389  INLINE cimatrix operator *(const cimatrix_slice &ms,const complex &c) throw();
3391  INLINE cimatrix &operator *=(cimatrix &m,const complex &c) throw();
3393  INLINE cimatrix operator /(const cimatrix &m,const complex &c) throw();
3395  INLINE cimatrix operator /(const cimatrix_slice &ms, const complex &c) throw();
3397  INLINE cimatrix &operator /=(cimatrix &m,const complex &c) throw();
3398 //----------------- cmatrix - cinterval ----------------
3399 
3401  INLINE cimatrix operator *(const cinterval &c, const cmatrix &m) throw();
3403  INLINE cimatrix operator *(const cinterval &c, const cmatrix_slice &ms) throw();
3405  INLINE cimatrix operator *(const cmatrix &m,const cinterval &c) throw();
3407  INLINE cimatrix operator *(const cmatrix_slice &ms,const cinterval &c) throw();
3409  INLINE cimatrix operator /(const cmatrix &m,const cinterval &c) throw();
3411  INLINE cimatrix operator /(const cmatrix_slice &ms, const cinterval &c) throw();
3412 
3413 //------------ interval - cimatrix -----------------------------------------------
3414 
3416  INLINE cimatrix operator *(const interval &c, const cimatrix &m) throw();
3418  INLINE cimatrix operator *(const interval &c, const cimatrix_slice &ms) throw();
3420  INLINE cimatrix operator *(const cimatrix &m,const interval &c) throw();
3422  INLINE cimatrix operator *(const cimatrix_slice &ms,const interval &c) throw();
3424  INLINE cimatrix &operator *=(cimatrix &m,const interval &c) throw();
3426  INLINE cimatrix operator /(const cimatrix &m,const interval &c) throw();
3428  INLINE cimatrix operator /(const cimatrix_slice &ms, const interval &c) throw();
3430  INLINE cimatrix &operator /=(cimatrix &m,const interval &c) throw();
3431 //----------------- imatrix - cinterval ----------------
3432 
3434  INLINE cimatrix operator *(const cinterval &c, const imatrix &m) throw();
3436  INLINE cimatrix operator *(const cinterval &c, const imatrix_slice &ms) throw();
3438  INLINE cimatrix operator *(const imatrix &m,const cinterval &c) throw();
3440  INLINE cimatrix operator *(const imatrix_slice &ms,const cinterval &c) throw();
3442  INLINE cimatrix operator /(const imatrix &m,const cinterval &c) throw();
3444  INLINE cimatrix operator /(const imatrix_slice &ms, const cinterval &c) throw();
3445 
3446 
3447 //============================ Matrix / Vector ===================================
3448 
3449 
3451  INLINE civector operator *(const cimatrix &m,const civector &v)
3452 #if(CXSC_INDEX_CHECK)
3453  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3454 #else
3455  throw();
3456 #endif
3457  INLINE civector operator *(const cimatrix_slice &ms,const civector &v)
3459 #if(CXSC_INDEX_CHECK)
3460  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3461 #else
3462  throw();
3463 #endif
3464  INLINE civector operator *(const civector &v,const cimatrix &m)
3466 #if(CXSC_INDEX_CHECK)
3467  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3468 #else
3469  throw();
3470 #endif
3471  INLINE civector operator *(const civector &v,const cimatrix_slice &ms)
3473 #if(CXSC_INDEX_CHECK)
3474  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3475 #else
3476  throw();
3477 #endif
3478  INLINE civector &operator *=(civector &v,const cimatrix &m)
3480 #if(CXSC_INDEX_CHECK)
3481  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3482 #else
3483  throw();
3484 #endif
3485  INLINE civector &operator *=(civector &v,const cimatrix_slice &ms)
3487 #if(CXSC_INDEX_CHECK)
3488  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3489 #else
3490  throw();
3491 #endif
3492 
3494  INLINE civector operator *(const civector_slice &v,const cimatrix &m)
3495 #if(CXSC_INDEX_CHECK)
3496  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3497 #else
3498  throw();
3499 #endif
3500  INLINE civector operator *(const civector_slice &v,const cimatrix_slice &m)
3502 #if(CXSC_INDEX_CHECK)
3503  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3504 #else
3505  throw();
3506 #endif
3507 
3508 //----------------- real -------------------------------------
3509 
3511  INLINE civector operator *(const rvector &v,const cimatrix &m)
3512 #if(CXSC_INDEX_CHECK)
3513  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3514 #else
3515  throw();
3516 #endif
3517  INLINE civector operator *(const rvector &v,const cimatrix_slice &ms)
3519 #if(CXSC_INDEX_CHECK)
3520  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3521 #else
3522  throw();
3523 #endif
3524  INLINE civector operator *(const rvector_slice &v,const cimatrix &m)
3526 #if(CXSC_INDEX_CHECK)
3527  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3528 #else
3529  throw();
3530 #endif
3531 
3533  INLINE civector operator *(const cimatrix &m,const rvector &v)
3534 #if(CXSC_INDEX_CHECK)
3535  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3536 #else
3537  throw();
3538 #endif
3539  INLINE civector operator *(const cimatrix_slice &ms,const rvector &v)
3541 #if(CXSC_INDEX_CHECK)
3542  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3543 #else
3544  throw();
3545 #endif
3546 
3547 //----------------- complex -------------------------------------
3548 
3550  INLINE civector operator *(const cvector &v,const cimatrix &m)
3551 #if(CXSC_INDEX_CHECK)
3552  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3553 #else
3554  throw();
3555 #endif
3556  INLINE civector operator *(const cvector &v,const cimatrix_slice &ms)
3558 #if(CXSC_INDEX_CHECK)
3559  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3560 #else
3561  throw();
3562 #endif
3563  INLINE civector operator *(const cvector_slice &v,const cimatrix &m)
3565 #if(CXSC_INDEX_CHECK)
3566  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3567 #else
3568  throw();
3569 #endif
3570 
3572  INLINE civector operator *(const cimatrix &m,const cvector &v)
3573 #if(CXSC_INDEX_CHECK)
3574  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3575 #else
3576  throw();
3577 #endif
3578  INLINE civector operator *(const cimatrix_slice &ms,const cvector &v)
3580 #if(CXSC_INDEX_CHECK)
3581  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3582 #else
3583  throw();
3584 #endif
3585 
3586 //----------------- interval -------------------------------------
3587 
3589  INLINE civector operator *(const ivector &v,const cimatrix &m)
3590 #if(CXSC_INDEX_CHECK)
3591  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3592 #else
3593  throw();
3594 #endif
3595  INLINE civector operator *(const ivector &v,const cimatrix_slice &ms)
3597 #if(CXSC_INDEX_CHECK)
3598  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3599 #else
3600  throw();
3601 #endif
3602  INLINE civector operator *(const ivector_slice &v,const cimatrix &m)
3604 #if(CXSC_INDEX_CHECK)
3605  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3606 #else
3607  throw();
3608 #endif
3609 
3611  INLINE civector operator *(const cimatrix &m,const ivector &v)
3612 #if(CXSC_INDEX_CHECK)
3613  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3614 #else
3615  throw();
3616 #endif
3617  INLINE civector operator *(const cimatrix_slice &ms,const ivector &v)
3619 #if(CXSC_INDEX_CHECK)
3620  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3621 #else
3622  throw();
3623 #endif
3624 
3625 
3626 //================ Matrix / Matrix ============================
3627 
3629  INLINE const cimatrix &operator +(const cimatrix &m1) throw();
3631  INLINE cimatrix operator +(const cimatrix_slice &ms) throw();
3633  INLINE cimatrix operator +(const cimatrix &m1,const cimatrix &m2)
3634 #if(CXSC_INDEX_CHECK)
3635  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3636 #else
3637  throw();
3638 #endif
3639  INLINE cimatrix operator +(const cimatrix &m,const cimatrix_slice &ms)
3641 #if(CXSC_INDEX_CHECK)
3642  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3643 #else
3644  throw();
3645 #endif
3646  INLINE cimatrix operator +(const cimatrix_slice &ms,const cimatrix &m)
3648 #if(CXSC_INDEX_CHECK)
3649  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3650 #else
3651  throw();
3652 #endif
3653  INLINE cimatrix operator +(const cimatrix_slice &m1,const cimatrix_slice &m2)
3655 #if(CXSC_INDEX_CHECK)
3656  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3657 #else
3658  throw();
3659 #endif
3660  INLINE cimatrix &operator +=(cimatrix &m1,const cimatrix &m2)
3662 #if(CXSC_INDEX_CHECK)
3663  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3664 #else
3665  throw();
3666 #endif
3667  INLINE cimatrix &operator +=(cimatrix &m1,const cimatrix_slice &ms)
3669 #if(CXSC_INDEX_CHECK)
3670  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3671 #else
3672  throw();
3673 #endif
3674 
3676  INLINE cimatrix operator -(const cimatrix &m) throw();
3678  INLINE cimatrix operator -(const cimatrix_slice &ms) throw();
3680  INLINE cimatrix operator -(const cimatrix &m1,const cimatrix &m2)
3681 #if(CXSC_INDEX_CHECK)
3682  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3683 #else
3684  throw();
3685 #endif
3686  INLINE cimatrix operator -(const cimatrix &m,const cimatrix_slice &ms)
3688 #if(CXSC_INDEX_CHECK)
3689  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3690 #else
3691  throw();
3692 #endif
3693  INLINE cimatrix operator -(const cimatrix_slice &ms,const cimatrix &m)
3695 #if(CXSC_INDEX_CHECK)
3696  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3697 #else
3698  throw();
3699 #endif
3700  INLINE cimatrix operator -(const cimatrix_slice &ms1,const cimatrix_slice &ms2)
3702 #if(CXSC_INDEX_CHECK)
3703  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3704 #else
3705  throw();
3706 #endif
3707  INLINE cimatrix &operator -=(cimatrix &m1,const cimatrix &m2)
3709 #if(CXSC_INDEX_CHECK)
3710  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3711 #else
3712  throw();
3713 #endif
3714  INLINE cimatrix &operator -=(cimatrix &m1,const cimatrix_slice &ms)
3716 #if(CXSC_INDEX_CHECK)
3717  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3718 #else
3719  throw();
3720 #endif
3721 
3723  INLINE cimatrix operator *(const cimatrix &m1, const cimatrix &m2)
3724 #if(CXSC_INDEX_CHECK)
3725  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3726 #else
3727  throw();
3728 #endif
3729  INLINE cimatrix operator *(const cimatrix &m1, const cimatrix_slice &ms)
3731 #if(CXSC_INDEX_CHECK)
3732  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3733 #else
3734  throw();
3735 #endif
3736  INLINE cimatrix operator *(const cimatrix_slice &ms, const cimatrix &m1)
3738 #if(CXSC_INDEX_CHECK)
3739  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3740 #else
3741  throw();
3742 #endif
3743  INLINE cimatrix operator *(const cimatrix_slice &ms1, const cimatrix_slice &ms2)
3745 #if(CXSC_INDEX_CHECK)
3746  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3747 #else
3748  throw();
3749 #endif
3750  INLINE cimatrix &operator *=(cimatrix &m1,const cimatrix &m2)
3752 #if(CXSC_INDEX_CHECK)
3753  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3754 #else
3755  throw();
3756 #endif
3757  INLINE cimatrix &operator *=(cimatrix &m1,const cimatrix_slice &ms)
3759 #if(CXSC_INDEX_CHECK)
3760  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3761 #else
3762  throw();
3763 #endif
3764 
3765 
3767  INLINE cimatrix operator |(const cimatrix &m1,const cimatrix &m2)
3768 #if(CXSC_INDEX_CHECK)
3769  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3770 #else
3771  throw();
3772 #endif
3773  INLINE cimatrix operator |(const cimatrix &m,const cimatrix_slice &ms)
3775 #if(CXSC_INDEX_CHECK)
3776  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3777 #else
3778  throw();
3779 #endif
3780  INLINE cimatrix operator |(const cimatrix_slice &ms,const cimatrix &m)
3782 #if(CXSC_INDEX_CHECK)
3783  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3784 #else
3785  throw();
3786 #endif
3787  INLINE cimatrix operator |(const cimatrix_slice &m1,const cimatrix_slice &m2)
3789 #if(CXSC_INDEX_CHECK)
3790  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3791 #else
3792  throw();
3793 #endif
3794  INLINE cimatrix &operator |=(cimatrix &m1,const cimatrix &m2)
3796 #if(CXSC_INDEX_CHECK)
3797  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3798 #else
3799  throw();
3800 #endif
3801  INLINE cimatrix &operator |=(cimatrix &m1,const cimatrix_slice &ms)
3803 #if(CXSC_INDEX_CHECK)
3804  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3805 #else
3806  throw();
3807 #endif
3808 
3810  INLINE cimatrix operator &(const cimatrix &m1,const cimatrix &m2)
3811 #if(CXSC_INDEX_CHECK)
3812  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3813 #else
3814  throw();
3815 #endif
3816  INLINE cimatrix operator &(const cimatrix &m,const cimatrix_slice &ms)
3818 #if(CXSC_INDEX_CHECK)
3819  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3820 #else
3821  throw();
3822 #endif
3823  INLINE cimatrix operator &(const cimatrix_slice &ms,const cimatrix &m)
3825 #if(CXSC_INDEX_CHECK)
3826  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3827 #else
3828  throw();
3829 #endif
3830  INLINE cimatrix operator &(const cimatrix_slice &m1,const cimatrix_slice &m2)
3832 #if(CXSC_INDEX_CHECK)
3833  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3834 #else
3835  throw();
3836 #endif
3837  INLINE cimatrix &operator &=(cimatrix &m1,const cimatrix &m2)
3839 #if(CXSC_INDEX_CHECK)
3840  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3841 #else
3842  throw();
3843 #endif
3844  INLINE cimatrix &operator &=(cimatrix &m1,const cimatrix_slice &ms)
3846 #if(CXSC_INDEX_CHECK)
3847  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3848 #else
3849  throw();
3850 #endif
3851 
3852  //---------- rmatrix-cimatrix ------------------
3854  INLINE cimatrix operator +(const rmatrix &m1,const cimatrix &m2)
3855 #if(CXSC_INDEX_CHECK)
3856  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3857 #else
3858  throw();
3859 #endif
3860  INLINE cimatrix operator +(const cimatrix &m1,const rmatrix &m2)
3862 #if(CXSC_INDEX_CHECK)
3863  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3864 #else
3865  throw();
3866 #endif
3867  INLINE cimatrix operator +(const rmatrix &m,const cimatrix_slice &ms)
3869 #if(CXSC_INDEX_CHECK)
3870  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3871 #else
3872  throw();
3873 #endif
3874  INLINE cimatrix operator +(const cimatrix &m,const rmatrix_slice &ms)
3876 #if(CXSC_INDEX_CHECK)
3877  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3878 #else
3879  throw();
3880 #endif
3881  INLINE cimatrix operator +(const rmatrix_slice &ms,const cimatrix &m)
3883 #if(CXSC_INDEX_CHECK)
3884  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3885 #else
3886  throw();
3887 #endif
3888  INLINE cimatrix operator +(const cimatrix_slice &ms,const rmatrix &m)
3890 #if(CXSC_INDEX_CHECK)
3891  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3892 #else
3893  throw();
3894 #endif
3895  INLINE cimatrix operator +(const rmatrix_slice &m1,const cimatrix_slice &m2)
3897 #if(CXSC_INDEX_CHECK)
3898  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3899 #else
3900  throw();
3901 #endif
3902  INLINE cimatrix operator +(const cimatrix_slice &m1,const rmatrix_slice &m2)
3904 #if(CXSC_INDEX_CHECK)
3905  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3906 #else
3907  throw();
3908 #endif
3909  INLINE cimatrix &operator +=(cimatrix &m1,const rmatrix &m2)
3911 #if(CXSC_INDEX_CHECK)
3912  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3913 #else
3914  throw();
3915 #endif
3916  INLINE cimatrix &operator +=(cimatrix &m1,const rmatrix_slice &ms)
3918 #if(CXSC_INDEX_CHECK)
3919  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3920 #else
3921  throw();
3922 #endif
3923 
3925  INLINE cimatrix operator -(const rmatrix &m1,const cimatrix &m2)
3926 #if(CXSC_INDEX_CHECK)
3927  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3928 #else
3929  throw();
3930 #endif
3931  INLINE cimatrix operator -(const cimatrix &m1,const rmatrix &m2)
3933 #if(CXSC_INDEX_CHECK)
3934  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3935 #else
3936  throw();
3937 #endif
3938  INLINE cimatrix operator -(const rmatrix &m,const cimatrix_slice &ms)
3940 #if(CXSC_INDEX_CHECK)
3941  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3942 #else
3943  throw();
3944 #endif
3945  INLINE cimatrix operator -(const cimatrix &m,const rmatrix_slice &ms)
3947 #if(CXSC_INDEX_CHECK)
3948  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3949 #else
3950  throw();
3951 #endif
3952  INLINE cimatrix operator -(const rmatrix_slice &ms,const cimatrix &m)
3954 #if(CXSC_INDEX_CHECK)
3955  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3956 #else
3957  throw();
3958 #endif
3959  INLINE cimatrix operator -(const cimatrix_slice &ms,const rmatrix &m)
3961 #if(CXSC_INDEX_CHECK)
3962  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3963 #else
3964  throw();
3965 #endif
3966  INLINE cimatrix operator -(const rmatrix_slice &ms1,const cimatrix_slice &ms2)
3968 #if(CXSC_INDEX_CHECK)
3969  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3970 #else
3971  throw();
3972 #endif
3973  INLINE cimatrix operator -(const cimatrix_slice &ms1,const rmatrix_slice &ms2)
3975 #if(CXSC_INDEX_CHECK)
3976  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3977 #else
3978  throw();
3979 #endif
3980  INLINE cimatrix &operator -=(cimatrix &m1,const rmatrix &m2)
3982 #if(CXSC_INDEX_CHECK)
3983  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3984 #else
3985  throw();
3986 #endif
3987  INLINE cimatrix &operator -=(cimatrix &m1,const rmatrix_slice &ms)
3989 #if(CXSC_INDEX_CHECK)
3990  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3991 #else
3992  throw();
3993 #endif
3994 
3996  INLINE cimatrix operator *(const rmatrix &m1, const cimatrix &m2)
3997 #if(CXSC_INDEX_CHECK)
3998  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3999 #else
4000  throw();
4001 #endif
4002  INLINE cimatrix operator *(const cimatrix &m1, const rmatrix &m2)
4004 #if(CXSC_INDEX_CHECK)
4005  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4006 #else
4007  throw();
4008 #endif
4009  INLINE cimatrix operator *(const rmatrix &m1, const cimatrix_slice &ms)
4011 #if(CXSC_INDEX_CHECK)
4012  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4013 #else
4014  throw();
4015 #endif
4016  INLINE cimatrix operator *(const cimatrix &m1, const rmatrix_slice &ms)
4018 #if(CXSC_INDEX_CHECK)
4019  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4020 #else
4021  throw();
4022 #endif
4023  INLINE cimatrix operator *(const rmatrix_slice &ms, const cimatrix &m1)
4025 #if(CXSC_INDEX_CHECK)
4026  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4027 #else
4028  throw();
4029 #endif
4030  INLINE cimatrix operator *(const cimatrix_slice &ms, const rmatrix &m1)
4032 #if(CXSC_INDEX_CHECK)
4033  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4034 #else
4035  throw();
4036 #endif
4037  INLINE cimatrix operator *(const rmatrix_slice &ms1, const cimatrix_slice &ms2)
4039 #if(CXSC_INDEX_CHECK)
4040  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4041 #else
4042  throw();
4043 #endif
4044  INLINE cimatrix operator *(const cimatrix_slice &ms1, const rmatrix_slice &ms2)
4046 #if(CXSC_INDEX_CHECK)
4047  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4048 #else
4049  throw();
4050 #endif
4051  INLINE cimatrix &operator *=(cimatrix &m1,const rmatrix &m2)
4053 #if(CXSC_INDEX_CHECK)
4054  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4055 #else
4056  throw();
4057 #endif
4058  INLINE cimatrix &operator *=(cimatrix &m1,const rmatrix_slice &ms)
4060 #if(CXSC_INDEX_CHECK)
4061  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4062 #else
4063  throw();
4064 #endif
4065 
4067  INLINE cimatrix operator |(const rmatrix &m1,const cimatrix &m2)
4068 #if(CXSC_INDEX_CHECK)
4069  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4070 #else
4071  throw();
4072 #endif
4073  INLINE cimatrix operator |(const cimatrix &m1,const rmatrix &m2)
4075 #if(CXSC_INDEX_CHECK)
4076  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4077 #else
4078  throw();
4079 #endif
4080  INLINE cimatrix operator |(const rmatrix &m,const cimatrix_slice &ms)
4082 #if(CXSC_INDEX_CHECK)
4083  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4084 #else
4085  throw();
4086 #endif
4087  INLINE cimatrix operator |(const cimatrix &m,const rmatrix_slice &ms)
4089 #if(CXSC_INDEX_CHECK)
4090  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4091 #else
4092  throw();
4093 #endif
4094  INLINE cimatrix operator |(const rmatrix_slice &ms,const cimatrix &m)
4096 #if(CXSC_INDEX_CHECK)
4097  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4098 #else
4099  throw();
4100 #endif
4101  INLINE cimatrix operator |(const cimatrix_slice &ms,const rmatrix &m)
4103 #if(CXSC_INDEX_CHECK)
4104  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4105 #else
4106  throw();
4107 #endif
4108  INLINE cimatrix operator |(const rmatrix_slice &m1,const cimatrix_slice &m2)
4110 #if(CXSC_INDEX_CHECK)
4111  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4112 #else
4113  throw();
4114 #endif
4115  INLINE cimatrix operator |(const cimatrix_slice &m1,const rmatrix_slice &m2)
4117 #if(CXSC_INDEX_CHECK)
4118  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4119 #else
4120  throw();
4121 #endif
4122  INLINE cimatrix &operator |=(cimatrix &m1,const rmatrix &m2)
4124 #if(CXSC_INDEX_CHECK)
4125  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4126 #else
4127  throw();
4128 #endif
4129  INLINE cimatrix &operator |=(cimatrix &m1,const rmatrix_slice &ms)
4131 #if(CXSC_INDEX_CHECK)
4132  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4133 #else
4134  throw();
4135 #endif
4136 
4138  INLINE cimatrix operator &(const rmatrix &m1,const cimatrix &m2)
4139 #if(CXSC_INDEX_CHECK)
4140  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4141 #else
4142  throw();
4143 #endif
4144  INLINE cimatrix operator &(const cimatrix &m1,const rmatrix &m2)
4146 #if(CXSC_INDEX_CHECK)
4147  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4148 #else
4149  throw();
4150 #endif
4151  INLINE cimatrix operator &(const rmatrix &m,const cimatrix_slice &ms)
4153 #if(CXSC_INDEX_CHECK)
4154  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4155 #else
4156  throw();
4157 #endif
4158  INLINE cimatrix operator &(const cimatrix &m,const rmatrix_slice &ms)
4160 #if(CXSC_INDEX_CHECK)
4161  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4162 #else
4163  throw();
4164 #endif
4165  INLINE cimatrix operator &(const rmatrix_slice &ms,const cimatrix &m)
4167 #if(CXSC_INDEX_CHECK)
4168  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4169 #else
4170  throw();
4171 #endif
4172  INLINE cimatrix operator &(const cimatrix_slice &ms,const rmatrix &m)
4174 #if(CXSC_INDEX_CHECK)
4175  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4176 #else
4177  throw();
4178 #endif
4179  INLINE cimatrix operator &(const rmatrix_slice &m1,const cimatrix_slice &m2)
4181 #if(CXSC_INDEX_CHECK)
4182  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4183 #else
4184  throw();
4185 #endif
4186  INLINE cimatrix operator &(const cimatrix_slice &m1,const rmatrix_slice &m2)
4188 #if(CXSC_INDEX_CHECK)
4189  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4190 #else
4191  throw();
4192 #endif
4193  INLINE cimatrix &operator &=(cimatrix &m1,const rmatrix &m2)
4195 #if(CXSC_INDEX_CHECK)
4196  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4197 #else
4198  throw();
4199 #endif
4200  INLINE cimatrix &operator &=(cimatrix &m1,const rmatrix_slice &ms)
4202 #if(CXSC_INDEX_CHECK)
4203  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4204 #else
4205  throw();
4206 #endif
4207 
4208  //---------- cmatrix-cimatrix ------------------
4210  INLINE cimatrix operator +(const cmatrix &m1,const cimatrix &m2)
4211 #if(CXSC_INDEX_CHECK)
4212  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4213 #else
4214  throw();
4215 #endif
4216  INLINE cimatrix operator +(const cimatrix &m1,const cmatrix &m2)
4218 #if(CXSC_INDEX_CHECK)
4219  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4220 #else
4221  throw();
4222 #endif
4223  INLINE cimatrix operator +(const cmatrix &m,const cimatrix_slice &ms)
4225 #if(CXSC_INDEX_CHECK)
4226  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4227 #else
4228  throw();
4229 #endif
4230  INLINE cimatrix operator +(const cimatrix &m,const cmatrix_slice &ms)
4232 #if(CXSC_INDEX_CHECK)
4233  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4234 #else
4235  throw();
4236 #endif
4237  INLINE cimatrix operator +(const cmatrix_slice &ms,const cimatrix &m)
4239 #if(CXSC_INDEX_CHECK)
4240  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4241 #else
4242  throw();
4243 #endif
4244  INLINE cimatrix operator +(const cimatrix_slice &ms,const cmatrix &m)
4246 #if(CXSC_INDEX_CHECK)
4247  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4248 #else
4249  throw();
4250 #endif
4251  INLINE cimatrix operator +(const cmatrix_slice &m1,const cimatrix_slice &m2)
4253 #if(CXSC_INDEX_CHECK)
4254  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4255 #else
4256  throw();
4257 #endif
4258  INLINE cimatrix operator +(const cimatrix_slice &m1,const cmatrix_slice &m2)
4260 #if(CXSC_INDEX_CHECK)
4261  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4262 #else
4263  throw();
4264 #endif
4265  INLINE cimatrix &operator +=(cimatrix &m1,const cmatrix &m2)
4267 #if(CXSC_INDEX_CHECK)
4268  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4269 #else
4270  throw();
4271 #endif
4272  INLINE cimatrix &operator +=(cimatrix &m1,const cmatrix_slice &ms)
4274 #if(CXSC_INDEX_CHECK)
4275  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4276 #else
4277  throw();
4278 #endif
4279 
4281  INLINE cimatrix operator -(const cmatrix &m1,const cimatrix &m2)
4282 #if(CXSC_INDEX_CHECK)
4283  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4284 #else
4285  throw();
4286 #endif
4287  INLINE cimatrix operator -(const cimatrix &m1,const cmatrix &m2)
4289 #if(CXSC_INDEX_CHECK)
4290  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4291 #else
4292  throw();
4293 #endif
4294  INLINE cimatrix operator -(const cmatrix &m,const cimatrix_slice &ms)
4296 #if(CXSC_INDEX_CHECK)
4297  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4298 #else
4299  throw();
4300 #endif
4301  INLINE cimatrix operator -(const cimatrix &m,const cmatrix_slice &ms)
4303 #if(CXSC_INDEX_CHECK)
4304  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4305 #else
4306  throw();
4307 #endif
4308  INLINE cimatrix operator -(const cmatrix_slice &ms,const cimatrix &m)
4310 #if(CXSC_INDEX_CHECK)
4311  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4312 #else
4313  throw();
4314 #endif
4315  INLINE cimatrix operator -(const cimatrix_slice &ms,const cmatrix &m)
4317 #if(CXSC_INDEX_CHECK)
4318  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4319 #else
4320  throw();
4321 #endif
4322  INLINE cimatrix operator -(const cmatrix_slice &ms1,const cimatrix_slice &ms2)
4324 #if(CXSC_INDEX_CHECK)
4325  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4326 #else
4327  throw();
4328 #endif
4329  INLINE cimatrix operator -(const cimatrix_slice &ms1,const cmatrix_slice &ms2)
4331 #if(CXSC_INDEX_CHECK)
4332  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4333 #else
4334  throw();
4335 #endif
4336  INLINE cimatrix &operator -=(cimatrix &m1,const cmatrix &m2)
4338 #if(CXSC_INDEX_CHECK)
4339  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4340 #else
4341  throw();
4342 #endif
4343  INLINE cimatrix &operator -=(cimatrix &m1,const cmatrix_slice &ms)
4345 #if(CXSC_INDEX_CHECK)
4346  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4347 #else
4348  throw();
4349 #endif
4350 
4352  INLINE cimatrix operator *(const cmatrix &m1, const cimatrix &m2)
4353 #if(CXSC_INDEX_CHECK)
4354  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4355 #else
4356  throw();
4357 #endif
4358  INLINE cimatrix operator *(const cimatrix &m1, const cmatrix &m2)
4360 #if(CXSC_INDEX_CHECK)
4361  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4362 #else
4363  throw();
4364 #endif
4365  INLINE cimatrix operator *(const cmatrix &m1, const cimatrix_slice &ms)
4367 #if(CXSC_INDEX_CHECK)
4368  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4369 #else
4370  throw();
4371 #endif
4372  INLINE cimatrix operator *(const cimatrix &m1, const cmatrix_slice &ms)
4374 #if(CXSC_INDEX_CHECK)
4375  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4376 #else
4377  throw();
4378 #endif
4379  INLINE cimatrix operator *(const cmatrix_slice &ms, const cimatrix &m1)
4381 #if(CXSC_INDEX_CHECK)
4382  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4383 #else
4384  throw();
4385 #endif
4386  INLINE cimatrix operator *(const cimatrix_slice &ms, const cmatrix &m1)
4388 #if(CXSC_INDEX_CHECK)
4389  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4390 #else
4391  throw();
4392 #endif
4393  INLINE cimatrix operator *(const cmatrix_slice &ms1, const cimatrix_slice &ms2)
4395 #if(CXSC_INDEX_CHECK)
4396  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4397 #else
4398  throw();
4399 #endif
4400  INLINE cimatrix operator *(const cimatrix_slice &ms1, const cmatrix_slice &ms2)
4402 #if(CXSC_INDEX_CHECK)
4403  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4404 #else
4405  throw();
4406 #endif
4407  INLINE cimatrix &operator *=(cimatrix &m1,const cmatrix &m2)
4409 #if(CXSC_INDEX_CHECK)
4410  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4411 #else
4412  throw();
4413 #endif
4414  INLINE cimatrix &operator *=(cimatrix &m1,const cmatrix_slice &ms)
4416 #if(CXSC_INDEX_CHECK)
4417  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4418 #else
4419  throw();
4420 #endif
4421 
4423  INLINE cimatrix operator |(const cmatrix &m1,const cimatrix &m2)
4424 #if(CXSC_INDEX_CHECK)
4425  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4426 #else
4427  throw();
4428 #endif
4429  INLINE cimatrix operator |(const cimatrix &m1,const cmatrix &m2)
4431 #if(CXSC_INDEX_CHECK)
4432  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4433 #else
4434  throw();
4435 #endif
4436  INLINE cimatrix operator |(const cmatrix &m,const cimatrix_slice &ms)
4438 #if(CXSC_INDEX_CHECK)
4439  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4440 #else
4441  throw();
4442 #endif
4443  INLINE cimatrix operator |(const cimatrix &m,const cmatrix_slice &ms)
4445 #if(CXSC_INDEX_CHECK)
4446  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4447 #else
4448  throw();
4449 #endif
4450  INLINE cimatrix operator |(const cmatrix_slice &ms,const cimatrix &m)
4452 #if(CXSC_INDEX_CHECK)
4453  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4454 #else
4455  throw();
4456 #endif
4457  INLINE cimatrix operator |(const cimatrix_slice &ms,const cmatrix &m)
4459 #if(CXSC_INDEX_CHECK)
4460  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4461 #else
4462  throw();
4463 #endif
4464  INLINE cimatrix operator |(const cmatrix_slice &m1,const cimatrix_slice &m2)
4466 #if(CXSC_INDEX_CHECK)
4467  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4468 #else
4469  throw();
4470 #endif
4471  INLINE cimatrix operator |(const cimatrix_slice &m1,const cmatrix_slice &m2)
4473 #if(CXSC_INDEX_CHECK)
4474  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4475 #else
4476  throw();
4477 #endif
4478  INLINE cimatrix &operator |=(cimatrix &m1,const cmatrix &m2)
4480 #if(CXSC_INDEX_CHECK)
4481  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4482 #else
4483  throw();
4484 #endif
4485  INLINE cimatrix &operator |=(cimatrix &m1,const cmatrix_slice &ms)
4487 #if(CXSC_INDEX_CHECK)
4488  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4489 #else
4490  throw();
4491 #endif
4492 
4494  INLINE cimatrix operator &(const cmatrix &m1,const cimatrix &m2)
4495 #if(CXSC_INDEX_CHECK)
4496  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4497 #else
4498  throw();
4499 #endif
4500  INLINE cimatrix operator &(const cimatrix &m1,const cmatrix &m2)
4502 #if(CXSC_INDEX_CHECK)
4503  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4504 #else
4505  throw();
4506 #endif
4507  INLINE cimatrix operator &(const cmatrix &m,const cimatrix_slice &ms)
4509 #if(CXSC_INDEX_CHECK)
4510  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4511 #else
4512  throw();
4513 #endif
4514  INLINE cimatrix operator &(const cimatrix &m,const cmatrix_slice &ms)
4516 #if(CXSC_INDEX_CHECK)
4517  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4518 #else
4519  throw();
4520 #endif
4521  INLINE cimatrix operator &(const cmatrix_slice &ms,const cimatrix &m)
4523 #if(CXSC_INDEX_CHECK)
4524  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4525 #else
4526  throw();
4527 #endif
4528  INLINE cimatrix operator &(const cimatrix_slice &ms,const cmatrix &m)
4530 #if(CXSC_INDEX_CHECK)
4531  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4532 #else
4533  throw();
4534 #endif
4535  INLINE cimatrix operator &(const cmatrix_slice &m1,const cimatrix_slice &m2)
4537 #if(CXSC_INDEX_CHECK)
4538  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4539 #else
4540  throw();
4541 #endif
4542  INLINE cimatrix operator &(const cimatrix_slice &m1,const cmatrix_slice &m2)
4544 #if(CXSC_INDEX_CHECK)
4545  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4546 #else
4547  throw();
4548 #endif
4549  INLINE cimatrix &operator &=(cimatrix &m1,const cmatrix &m2)
4551 #if(CXSC_INDEX_CHECK)
4552  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4553 #else
4554  throw();
4555 #endif
4556  INLINE cimatrix &operator &=(cimatrix &m1,const cmatrix_slice &ms)
4558 #if(CXSC_INDEX_CHECK)
4559  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4560 #else
4561  throw();
4562 #endif
4563 
4564  //---------- imatrix-cimatrix ------------------
4566  INLINE cimatrix operator +(const imatrix &m1,const cimatrix &m2)
4567 #if(CXSC_INDEX_CHECK)
4568  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4569 #else
4570  throw();
4571 #endif
4572  INLINE cimatrix operator +(const cimatrix &m1,const imatrix &m2)
4574 #if(CXSC_INDEX_CHECK)
4575  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4576 #else
4577  throw();
4578 #endif
4579  INLINE cimatrix operator +(const imatrix &m,const cimatrix_slice &ms)
4581 #if(CXSC_INDEX_CHECK)
4582  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4583 #else
4584  throw();
4585 #endif
4586  INLINE cimatrix operator +(const cimatrix &m,const imatrix_slice &ms)
4588 #if(CXSC_INDEX_CHECK)
4589  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4590 #else
4591  throw();
4592 #endif
4593  INLINE cimatrix operator +(const imatrix_slice &ms,const cimatrix &m)
4595 #if(CXSC_INDEX_CHECK)
4596  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4597 #else
4598  throw();
4599 #endif
4600  INLINE cimatrix operator +(const cimatrix_slice &ms,const imatrix &m)
4602 #if(CXSC_INDEX_CHECK)
4603  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4604 #else
4605  throw();
4606 #endif
4607  INLINE cimatrix operator +(const imatrix_slice &m1,const cimatrix_slice &m2)
4609 #if(CXSC_INDEX_CHECK)
4610  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4611 #else
4612  throw();
4613 #endif
4614  INLINE cimatrix operator +(const cimatrix_slice &m1,const imatrix_slice &m2)
4616 #if(CXSC_INDEX_CHECK)
4617  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4618 #else
4619  throw();
4620 #endif
4621  INLINE cimatrix &operator +=(cimatrix &m1,const imatrix &m2)
4623 #if(CXSC_INDEX_CHECK)
4624  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4625 #else
4626  throw();
4627 #endif
4628  INLINE cimatrix &operator +=(cimatrix &m1,const imatrix_slice &ms)
4630 #if(CXSC_INDEX_CHECK)
4631  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4632 #else
4633  throw();
4634 #endif
4635 
4637  INLINE cimatrix operator -(const imatrix &m1,const cimatrix &m2)
4638 #if(CXSC_INDEX_CHECK)
4639  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4640 #else
4641  throw();
4642 #endif
4643  INLINE cimatrix operator -(const cimatrix &m1,const imatrix &m2)
4645 #if(CXSC_INDEX_CHECK)
4646  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4647 #else
4648  throw();
4649 #endif
4650  INLINE cimatrix operator -(const imatrix &m,const cimatrix_slice &ms)
4652 #if(CXSC_INDEX_CHECK)
4653  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4654 #else
4655  throw();
4656 #endif
4657  INLINE cimatrix operator -(const cimatrix &m,const imatrix_slice &ms)
4659 #if(CXSC_INDEX_CHECK)
4660  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4661 #else
4662  throw();
4663 #endif
4664  INLINE cimatrix operator -(const imatrix_slice &ms,const cimatrix &m)
4666 #if(CXSC_INDEX_CHECK)
4667  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4668 #else
4669  throw();
4670 #endif
4671  INLINE cimatrix operator -(const cimatrix_slice &ms,const imatrix &m)
4673 #if(CXSC_INDEX_CHECK)
4674  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4675 #else
4676  throw();
4677 #endif
4678  INLINE cimatrix operator -(const imatrix_slice &ms1,const cimatrix_slice &ms2)
4680 #if(CXSC_INDEX_CHECK)
4681  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4682 #else
4683  throw();
4684 #endif
4685  INLINE cimatrix operator -(const cimatrix_slice &ms1,const imatrix_slice &ms2)
4687 #if(CXSC_INDEX_CHECK)
4688  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4689 #else
4690  throw();
4691 #endif
4692  INLINE cimatrix &operator -=(cimatrix &m1,const imatrix &m2)
4694 #if(CXSC_INDEX_CHECK)
4695  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4696 #else
4697  throw();
4698 #endif
4699  INLINE cimatrix &operator -=(cimatrix &m1,const imatrix_slice &ms)
4701 #if(CXSC_INDEX_CHECK)
4702  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4703 #else
4704  throw();
4705 #endif
4706 
4708  INLINE cimatrix operator *(const imatrix &m1, const cimatrix &m2)
4709 #if(CXSC_INDEX_CHECK)
4710  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4711 #else
4712  throw();
4713 #endif
4714  INLINE cimatrix operator *(const cimatrix &m1, const imatrix &m2)
4716 #if(CXSC_INDEX_CHECK)
4717  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4718 #else
4719  throw();
4720 #endif
4721  INLINE cimatrix operator *(const imatrix &m1, const cimatrix_slice &ms)
4723 #if(CXSC_INDEX_CHECK)
4724  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4725 #else
4726  throw();
4727 #endif
4728  INLINE cimatrix operator *(const cimatrix &m1, const imatrix_slice &ms)
4730 #if(CXSC_INDEX_CHECK)
4731  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4732 #else
4733  throw();
4734 #endif
4735  INLINE cimatrix operator *(const imatrix_slice &ms, const cimatrix &m1)
4737 #if(CXSC_INDEX_CHECK)
4738  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4739 #else
4740  throw();
4741 #endif
4742  INLINE cimatrix operator *(const cimatrix_slice &ms, const imatrix &m1)
4744 #if(CXSC_INDEX_CHECK)
4745  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4746 #else
4747  throw();
4748 #endif
4749  INLINE cimatrix operator *(const imatrix_slice &ms1, const cimatrix_slice &ms2)
4751 #if(CXSC_INDEX_CHECK)
4752  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4753 #else
4754  throw();
4755 #endif
4756  INLINE cimatrix operator *(const cimatrix_slice &ms1, const imatrix_slice &ms2)
4758 #if(CXSC_INDEX_CHECK)
4759  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4760 #else
4761  throw();
4762 #endif
4763  INLINE cimatrix &operator *=(cimatrix &m1,const imatrix &m2)
4765 #if(CXSC_INDEX_CHECK)
4766  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4767 #else
4768  throw();
4769 #endif
4770  INLINE cimatrix &operator *=(cimatrix &m1,const imatrix_slice &ms)
4772 #if(CXSC_INDEX_CHECK)
4773  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4774 #else
4775  throw();
4776 #endif
4777 
4779  INLINE cimatrix operator |(const imatrix &m1,const cimatrix &m2)
4780 #if(CXSC_INDEX_CHECK)
4781  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4782 #else
4783  throw();
4784 #endif
4785  INLINE cimatrix operator |(const cimatrix &m1,const imatrix &m2)
4787 #if(CXSC_INDEX_CHECK)
4788  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4789 #else
4790  throw();
4791 #endif
4792  INLINE cimatrix operator |(const imatrix &m,const cimatrix_slice &ms)
4794 #if(CXSC_INDEX_CHECK)
4795  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4796 #else
4797  throw();
4798 #endif
4799  INLINE cimatrix operator |(const cimatrix &m,const imatrix_slice &ms)
4801 #if(CXSC_INDEX_CHECK)
4802  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4803 #else
4804  throw();
4805 #endif
4806  INLINE cimatrix operator |(const imatrix_slice &ms,const cimatrix &m)
4808 #if(CXSC_INDEX_CHECK)
4809  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4810 #else
4811  throw();
4812 #endif
4813  INLINE cimatrix operator |(const cimatrix_slice &ms,const imatrix &m)
4815 #if(CXSC_INDEX_CHECK)
4816  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4817 #else
4818  throw();
4819 #endif
4820  INLINE cimatrix operator |(const imatrix_slice &m1,const cimatrix_slice &m2)
4822 #if(CXSC_INDEX_CHECK)
4823  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4824 #else
4825  throw();
4826 #endif
4827  INLINE cimatrix operator |(const cimatrix_slice &m1,const imatrix_slice &m2)
4829 #if(CXSC_INDEX_CHECK)
4830  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4831 #else
4832  throw();
4833 #endif
4834  INLINE cimatrix &operator |=(cimatrix &m1,const imatrix &m2)
4836 #if(CXSC_INDEX_CHECK)
4837  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4838 #else
4839  throw();
4840 #endif
4841  INLINE cimatrix &operator |=(cimatrix &m1,const imatrix_slice &ms)
4843 #if(CXSC_INDEX_CHECK)
4844  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4845 #else
4846  throw();
4847 #endif
4848 
4850  INLINE cimatrix operator &(const imatrix &m1,const cimatrix &m2)
4851 #if(CXSC_INDEX_CHECK)
4852  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4853 #else
4854  throw();
4855 #endif
4856  INLINE cimatrix operator &(const cimatrix &m1,const imatrix &m2)
4858 #if(CXSC_INDEX_CHECK)
4859  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4860 #else
4861  throw();
4862 #endif
4863  INLINE cimatrix operator &(const imatrix &m,const cimatrix_slice &ms)
4865 #if(CXSC_INDEX_CHECK)
4866  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4867 #else
4868  throw();
4869 #endif
4870  INLINE cimatrix operator &(const cimatrix &m,const imatrix_slice &ms)
4872 #if(CXSC_INDEX_CHECK)
4873  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4874 #else
4875  throw();
4876 #endif
4877  INLINE cimatrix operator &(const imatrix_slice &ms,const cimatrix &m)
4879 #if(CXSC_INDEX_CHECK)
4880  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4881 #else
4882  throw();
4883 #endif
4884  INLINE cimatrix operator &(const cimatrix_slice &ms,const imatrix &m)
4886 #if(CXSC_INDEX_CHECK)
4887  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4888 #else
4889  throw();
4890 #endif
4891  INLINE cimatrix operator &(const imatrix_slice &m1,const cimatrix_slice &m2)
4893 #if(CXSC_INDEX_CHECK)
4894  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4895 #else
4896  throw();
4897 #endif
4898  INLINE cimatrix operator &(const cimatrix_slice &m1,const imatrix_slice &m2)
4900 #if(CXSC_INDEX_CHECK)
4901  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4902 #else
4903  throw();
4904 #endif
4905  INLINE cimatrix &operator &=(cimatrix &m1,const imatrix &m2)
4907 #if(CXSC_INDEX_CHECK)
4908  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4909 #else
4910  throw();
4911 #endif
4912  INLINE cimatrix &operator &=(cimatrix &m1,const imatrix_slice &ms)
4914 #if(CXSC_INDEX_CHECK)
4915  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4916 #else
4917  throw();
4918 #endif
4919 
4920  //---------- cmatrix-imatrix ------------------
4922  INLINE cimatrix operator +(const cmatrix &m1,const imatrix &m2)
4923 #if(CXSC_INDEX_CHECK)
4924  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4925 #else
4926  throw();
4927 #endif
4928  INLINE cimatrix operator +(const imatrix &m1,const cmatrix &m2)
4930 #if(CXSC_INDEX_CHECK)
4931  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4932 #else
4933  throw();
4934 #endif
4935  INLINE cimatrix operator +(const cmatrix &m,const imatrix_slice &ms)
4937 #if(CXSC_INDEX_CHECK)
4938  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4939 #else
4940  throw();
4941 #endif
4942  INLINE cimatrix operator +(const imatrix &m,const cmatrix_slice &ms)
4944 #if(CXSC_INDEX_CHECK)
4945  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4946 #else
4947  throw();
4948 #endif
4949  INLINE cimatrix operator +(const cmatrix_slice &ms,const imatrix &m)
4951 #if(CXSC_INDEX_CHECK)
4952  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4953 #else
4954  throw();
4955 #endif
4956  INLINE cimatrix operator +(const imatrix_slice &ms,const cmatrix &m)
4958 #if(CXSC_INDEX_CHECK)
4959  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4960 #else
4961  throw();
4962 #endif
4963  INLINE cimatrix operator +(const cmatrix_slice &m1,const imatrix_slice &m2)
4965 #if(CXSC_INDEX_CHECK)
4966  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4967 #else
4968  throw();
4969 #endif
4970  INLINE cimatrix operator +(const imatrix_slice &m1,const cmatrix_slice &m2)
4972 #if(CXSC_INDEX_CHECK)
4973  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4974 #else
4975  throw();
4976 #endif
4977 
4979  INLINE cimatrix operator -(const cmatrix &m1,const imatrix &m2)
4980 #if(CXSC_INDEX_CHECK)
4981  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4982 #else
4983  throw();
4984 #endif
4985  INLINE cimatrix operator -(const imatrix &m1,const cmatrix &m2)
4987 #if(CXSC_INDEX_CHECK)
4988  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4989 #else
4990  throw();
4991 #endif
4992  INLINE cimatrix operator -(const cmatrix &m,const imatrix_slice &ms)
4994 #if(CXSC_INDEX_CHECK)
4995  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4996 #else
4997  throw();
4998 #endif
4999  INLINE cimatrix operator -(const imatrix &m,const cmatrix_slice &ms)
5001 #if(CXSC_INDEX_CHECK)
5002  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5003 #else
5004  throw();
5005 #endif
5006  INLINE cimatrix operator -(const cmatrix_slice &ms,const imatrix &m)
5008 #if(CXSC_INDEX_CHECK)
5009  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5010 #else
5011  throw();
5012 #endif
5013  INLINE cimatrix operator -(const imatrix_slice &ms,const cmatrix &m)
5015 #if(CXSC_INDEX_CHECK)
5016  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5017 #else
5018  throw();
5019 #endif
5020  INLINE cimatrix operator -(const cmatrix_slice &ms1,const imatrix_slice &ms2)
5022 #if(CXSC_INDEX_CHECK)
5023  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5024 #else
5025  throw();
5026 #endif
5027  INLINE cimatrix operator -(const imatrix_slice &ms1,const cmatrix_slice &ms2)
5029 #if(CXSC_INDEX_CHECK)
5030  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5031 #else
5032  throw();
5033 #endif
5034 
5036  INLINE cimatrix operator *(const cmatrix &m1, const imatrix &m2)
5037 #if(CXSC_INDEX_CHECK)
5038  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5039 #else
5040  throw();
5041 #endif
5042  INLINE cimatrix operator *(const imatrix &m1, const cmatrix &m2)
5044 #if(CXSC_INDEX_CHECK)
5045  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5046 #else
5047  throw();
5048 #endif
5049  INLINE cimatrix operator *(const cmatrix &m1, const imatrix_slice &ms)
5051 #if(CXSC_INDEX_CHECK)
5052  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5053 #else
5054  throw();
5055 #endif
5056  INLINE cimatrix operator *(const imatrix &m1, const cmatrix_slice &ms)
5058 #if(CXSC_INDEX_CHECK)
5059  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5060 #else
5061  throw();
5062 #endif
5063  INLINE cimatrix operator *(const cmatrix_slice &ms, const imatrix &m1)
5065 #if(CXSC_INDEX_CHECK)
5066  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5067 #else
5068  throw();
5069 #endif
5070  INLINE cimatrix operator *(const imatrix_slice &ms, const cmatrix &m1)
5072 #if(CXSC_INDEX_CHECK)
5073  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5074 #else
5075  throw();
5076 #endif
5077  INLINE cimatrix operator *(const cmatrix_slice &ms1, const imatrix_slice &ms2)
5079 #if(CXSC_INDEX_CHECK)
5080  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5081 #else
5082  throw();
5083 #endif
5084  INLINE cimatrix operator *(const imatrix_slice &ms1, const cmatrix_slice &ms2)
5086 #if(CXSC_INDEX_CHECK)
5087  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5088 #else
5089  throw();
5090 #endif
5091 
5093  INLINE cimatrix operator |(const cmatrix &m1,const imatrix &m2)
5094 #if(CXSC_INDEX_CHECK)
5095  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5096 #else
5097  throw();
5098 #endif
5099  INLINE cimatrix operator |(const imatrix &m1,const cmatrix &m2)
5101 #if(CXSC_INDEX_CHECK)
5102  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5103 #else
5104  throw();
5105 #endif
5106  INLINE cimatrix operator |(const cmatrix &m,const imatrix_slice &ms)
5108 #if(CXSC_INDEX_CHECK)
5109  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5110 #else
5111  throw();
5112 #endif
5113  INLINE cimatrix operator |(const imatrix &m,const cmatrix_slice &ms)
5115 #if(CXSC_INDEX_CHECK)
5116  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5117 #else
5118  throw();
5119 #endif
5120  INLINE cimatrix operator |(const cmatrix_slice &ms,const imatrix &m)
5122 #if(CXSC_INDEX_CHECK)
5123  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5124 #else
5125  throw();
5126 #endif
5127  INLINE cimatrix operator |(const imatrix_slice &ms,const cmatrix &m)
5129 #if(CXSC_INDEX_CHECK)
5130  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5131 #else
5132  throw();
5133 #endif
5134  INLINE cimatrix operator |(const cmatrix_slice &m1,const imatrix_slice &m2)
5136 #if(CXSC_INDEX_CHECK)
5137  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5138 #else
5139  throw();
5140 #endif
5141  INLINE cimatrix operator |(const imatrix_slice &m1,const cmatrix_slice &m2)
5143 #if(CXSC_INDEX_CHECK)
5144  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5145 #else
5146  throw();
5147 #endif
5148 
5150  INLINE cimatrix operator &(const cmatrix &m1,const imatrix &m2)
5151 #if(CXSC_INDEX_CHECK)
5152  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5153 #else
5154  throw();
5155 #endif
5156  INLINE cimatrix operator &(const imatrix &m1,const cmatrix &m2)
5158 #if(CXSC_INDEX_CHECK)
5159  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5160 #else
5161  throw();
5162 #endif
5163  INLINE cimatrix operator &(const cmatrix &m,const imatrix_slice &ms)
5165 #if(CXSC_INDEX_CHECK)
5166  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5167 #else
5168  throw();
5169 #endif
5170  INLINE cimatrix operator &(const imatrix &m,const cmatrix_slice &ms)
5172 #if(CXSC_INDEX_CHECK)
5173  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5174 #else
5175  throw();
5176 #endif
5177  INLINE cimatrix operator &(const cmatrix_slice &ms,const imatrix &m)
5179 #if(CXSC_INDEX_CHECK)
5180  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5181 #else
5182  throw();
5183 #endif
5184  INLINE cimatrix operator &(const imatrix_slice &ms,const cmatrix &m)
5186 #if(CXSC_INDEX_CHECK)
5187  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5188 #else
5189  throw();
5190 #endif
5191  INLINE cimatrix operator &(const cmatrix_slice &m1,const imatrix_slice &m2)
5193 #if(CXSC_INDEX_CHECK)
5194  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5195 #else
5196  throw();
5197 #endif
5198  INLINE cimatrix operator &(const imatrix_slice &m1,const cmatrix_slice &m2)
5200 #if(CXSC_INDEX_CHECK)
5201  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5202 #else
5203  throw();
5204 #endif
5205 
5206 //------------- real x complex ------------------------
5208  INLINE cimatrix operator |(const rmatrix &rv1, const cmatrix &rv2)
5209 #if(CXSC_INDEX_CHECK)
5210  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5211 #else
5212  throw();
5213 #endif
5214  INLINE cimatrix operator |(const cmatrix &rv1, const rmatrix &rv2)
5216 #if(CXSC_INDEX_CHECK)
5217  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5218 #else
5219  throw();
5220 #endif
5221  INLINE cimatrix operator |(const cmatrix &rv, const rmatrix_slice &sl)
5223 #if(CXSC_INDEX_CHECK)
5224  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5225 #else
5226  throw();
5227 #endif
5228  INLINE cimatrix operator |(const rmatrix_slice &sl,const cmatrix &rv)
5230 #if(CXSC_INDEX_CHECK)
5231  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5232 #else
5233  throw();
5234 #endif
5235  INLINE cimatrix operator |(const cmatrix_slice &sl, const rmatrix &rv)
5237 #if(CXSC_INDEX_CHECK)
5238  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5239 #else
5240  throw();
5241 #endif
5242  INLINE cimatrix operator |(const rmatrix &rv,const cmatrix_slice &sl)
5244 #if(CXSC_INDEX_CHECK)
5245  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5246 #else
5247  throw();
5248 #endif
5249  INLINE cimatrix operator |(const cmatrix_slice &sl1, const rmatrix_slice &sl2)
5251 #if(CXSC_INDEX_CHECK)
5252  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5253 #else
5254  throw();
5255 #endif
5256  INLINE cimatrix operator |(const rmatrix_slice &sl1, const cmatrix_slice &sl2)
5258 #if(CXSC_INDEX_CHECK)
5259  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5260 #else
5261  throw();
5262 #endif
5263 
5264 
5265 //------------- complex x complex ------------------------
5267  INLINE cimatrix operator |(const cmatrix &rv1, const cmatrix &rv2)
5268 #if(CXSC_INDEX_CHECK)
5269  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5270 #else
5271  throw();
5272 #endif
5273  INLINE cimatrix operator |(const cmatrix &rv1, const cmatrix &rv2)
5275 #if(CXSC_INDEX_CHECK)
5276  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5277 #else
5278  throw();
5279 #endif
5280  INLINE cimatrix operator |(const cmatrix &rv, const cmatrix_slice &sl)
5282 #if(CXSC_INDEX_CHECK)
5283  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5284 #else
5285  throw();
5286 #endif
5287  INLINE cimatrix operator |(const cmatrix_slice &sl,const cmatrix &rv)
5289 #if(CXSC_INDEX_CHECK)
5290  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5291 #else
5292  throw();
5293 #endif
5294  INLINE cimatrix operator |(const cmatrix_slice &sl, const cmatrix &rv)
5296 #if(CXSC_INDEX_CHECK)
5297  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5298 #else
5299  throw();
5300 #endif
5301  INLINE cimatrix operator |(const cmatrix &rv,const cmatrix_slice &sl)
5303 #if(CXSC_INDEX_CHECK)
5304  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5305 #else
5306  throw();
5307 #endif
5308  INLINE cimatrix operator |(const cmatrix_slice &sl1, const cmatrix_slice &sl2)
5310 #if(CXSC_INDEX_CHECK)
5311  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5312 #else
5313  throw();
5314 #endif
5315  INLINE cimatrix operator |(const cmatrix_slice &sl1, const cmatrix_slice &sl2)
5317 #if(CXSC_INDEX_CHECK)
5318  throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5319 #else
5320  throw();
5321 #endif
5322 
5323 
5324 //============== Compare Operator ==========================
5325 
5326 //-------------- Matrix - Matrix -------------------------
5327 
5329  INLINE bool operator ==(const cimatrix &m1,const cimatrix &m2) throw();
5331  INLINE bool operator !=(const cimatrix &m1,const cimatrix &m2) throw();
5333  INLINE bool operator <(const cimatrix &m1,const cimatrix &m2) throw();
5335  INLINE bool operator <=(const cimatrix &m1,const cimatrix &m2) throw();
5337  INLINE bool operator >(const cimatrix &m1,const cimatrix &m2) throw();
5339  INLINE bool operator >=(const cimatrix &m1,const cimatrix &m2) throw();
5341  INLINE bool operator ==(const cimatrix &m1,const cimatrix_slice &ms) throw();
5343  INLINE bool operator !=(const cimatrix &m1,const cimatrix_slice &ms) throw();
5345  INLINE bool operator <(const cimatrix &m1,const cimatrix_slice &ms) throw();
5347  INLINE bool operator <=(const cimatrix &m1,const cimatrix_slice &ms) throw();
5349  INLINE bool operator >(const cimatrix &m1,const cimatrix_slice &ms) throw();
5351  INLINE bool operator >=(const cimatrix &m1,const cimatrix_slice &ms) throw();
5352 
5353 //---------------- Matrix - Matrix_slice ----------------------
5354 
5356  INLINE bool operator ==(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
5358  INLINE bool operator !=(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
5360  INLINE bool operator <(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
5362  INLINE bool operator <=(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
5364  INLINE bool operator >(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
5366  INLINE bool operator >=(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
5367 
5368 //=================== Not Operator =============================
5369 
5371  INLINE bool operator !(const cimatrix &ms) throw();
5373  INLINE bool operator !(const cimatrix_slice &ms) throw();
5374 
5375 //======================== Input / Output ========================
5376 
5378  INLINE std::ostream &operator <<(std::ostream &s,const cimatrix &r) throw();
5380  INLINE std::ostream &operator <<(std::ostream &s,const cimatrix_slice &r) throw();
5382  INLINE std::istream &operator >>(std::istream &s,cimatrix &r) throw();
5384  INLINE std::istream &operator >>(std::istream &s,cimatrix_slice &r) throw();
5385 
5387  rmatrix CompMat ( const cimatrix& );
5389  cimatrix Id ( const cimatrix& );
5391  cimatrix transp ( const cimatrix& );
5393  INLINE int RowLen ( const cimatrix& );
5395  INLINE int ColLen ( const cimatrix& );
5397  INLINE int RowLen ( const cimatrix_slice& );
5399  INLINE int ColLen ( const cimatrix_slice& );
5401  void DoubleSize ( cimatrix& );
5402 
5403 } // namespace cxsc
5404 
5405 
5406 #ifdef _CXSC_INCL_INL
5407 #include "matrix.inl"
5408 #include "cimatrix.inl"
5409 #endif
5410 
5411 
5412 #ifdef CXSC_USE_BLAS
5413 #define _CXSC_BLAS_CIMATRIX
5414 #include "cxsc_blas.inl"
5415 #endif
5416 
5417 #endif
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
friend int Ub(const cimatrix_subv &rv)
Returns the upper bound of the vector.
Definition: cimatrix.hpp:487
The Data Type imatrix_subv.
Definition: imatrix.hpp:55
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
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
The Data Type cimatrix_subv.
Definition: cimatrix.hpp:67
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
The Data Type cimatrix_slice.
Definition: cimatrix.hpp:1650
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
The Scalar Type interval.
Definition: interval.hpp:54
cimatrix_subv(const cimatrix_subv &v)
Constructor of class cimatrix_subv.
Definition: cimatrix.hpp:318
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
cimatrix_slice(cimatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class cimatrix_slice.
Definition: cimatrix.hpp:2005
A sparse complex interval matrix.
Definition: scimatrix.hpp:71
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
A sparse real matrix.
Definition: srmatrix.hpp:77
cinterval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: cimatrix.inl:275
friend int VecLen(const cimatrix_subv &rv)
Returns the size of the vector.
Definition: cimatrix.hpp:489
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
A sparse complex interval vector.
Definition: scivector.hpp:62
The Data Type ivector_slice.
Definition: ivector.hpp:962
cimatrix_subv & operator+=(const cinterval &c)
Implementation of addition and allocation operation.
Definition: cimatrix.inl:734
cimatrix_subv & operator/=(const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:736
cimatrix()
Constructor of class cimatrix.
Definition: cimatrix.inl:31
The Data Type cidotprecision.
Definition: cidot.hpp:57
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
A sparse complex vector.
Definition: scvector.hpp:58
The Data Type cvector.
Definition: cvector.hpp:57
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
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
cimatrix_slice(const cimatrix_slice &ms)
Constructor of class cimatrix_slice.
Definition: cimatrix.hpp:2008
The Data Type rvector.
Definition: rvector.hpp:57
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
The Data Type cmatrix.
Definition: cmatrix.hpp:513
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360
A sparse complex matrix.
Definition: scmatrix.hpp:69
The Scalar Type cinterval.
Definition: cinterval.hpp:54
cimatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: cimatrix.hpp:508
A slice of a sparse complex matrix.
Definition: scmatrix.hpp:1956
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
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 civector_slice.
Definition: civector.hpp:1014
The Data Type rmatrix.
Definition: rmatrix.hpp:470
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cimatrix_subv & operator-=(const cinterval &c)
Implementation of subtraction and allocation operation.
Definition: cimatrix.inl:735
The Scalar Type complex.
Definition: complex.hpp:49
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:53
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
friend cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
The Data Type ivector.
Definition: ivector.hpp:54
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski&#39;s comparison matrix.
Definition: cimatrix.cpp:45
cimatrix_subv(cinterval *d, const int &l, const int &u, const int &s, const int &st, const int &o)
Constructor of class cimatrix_subv.
Definition: cimatrix.hpp:315
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1202
friend int Lb(const cimatrix_subv &rv)
Returns the lower bound of the vector.
Definition: cimatrix.hpp:485
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
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
The Data Type imatrix.
Definition: imatrix.hpp:659
civector()
Constructor of class civector.
Definition: civector.inl:31
Represents a row or column vector of a sparse matrix.
Definition: scimatrix.hpp:9628
cimatrix_slice(cimatrix &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class cimatrix_slice.
Definition: cimatrix.hpp:2003
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
cimatrix_subv & operator*=(const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:733
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
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 cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
The Data Type cvector_slice.
Definition: cvector.hpp:844
A slice of a sparse complex interval matrix.
Definition: scimatrix.hpp:4918
The Scalar Type real.
Definition: real.hpp:113
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
The Data Type intvector.
Definition: intvector.hpp:51
A sparse interval matrix.
Definition: simatrix.hpp:69
The Data Type cimatrix.
Definition: cimatrix.hpp:907
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737