C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
cmatrix.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: cmatrix.hpp,v 1.37 2014/01/30 17:23:44 cxsc Exp $ */
25 
26 #ifndef _CXSC_CMATRIX_HPP_INCLUDED
27 #define _CXSC_CMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "cdot.hpp"
31 #include "cidot.hpp"
32 #include "cvector.hpp"
33 #include "except.hpp"
34 #include "matrix.hpp"
35 #include "rmatrix.hpp"
36 
37 namespace cxsc {
38 
39 class cmatrix;
40 class cmatrix_slice;
41 class srmatrix;
42 class srmatrix_slice;
43 class srmatrix_subv;
44 class scmatrix;
45 class scmatrix_slice;
46 class scmatrix_subv;
47 
48 
50 
54 {
55  friend class cvector;
56  friend class civector;
57  friend class cmatrix;
58  friend class cmatrix_slice;
59  private:
60  complex *dat;
61  int lb,ub;
62  int size,start,offset; // start=first element index 0..n-1
63 
64  public:
66  friend INLINE cmatrix_subv Row(cmatrix &m,const int &i)
67 #if(CXSC_INDEX_CHECK)
68  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
69 #else
70  throw();
71 #endif
72  friend INLINE cmatrix_subv Col(cmatrix &m,const int &i)
74 #if(CXSC_INDEX_CHECK)
75  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
76 #else
77  throw();
78 #endif
79  friend INLINE cmatrix_subv Row(const cmatrix &m,const int &i)
80 #if(CXSC_INDEX_CHECK)
81  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
82 #else
83  throw();
84 #endif
85  friend INLINE cmatrix_subv Col(const cmatrix &m,const int &i)
87 #if(CXSC_INDEX_CHECK)
88  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
89 #else
90  throw();
91 #endif
92 //#if(CXSC_INDEX_CHECK)
93 #ifdef _CXSC_FRIEND_TPL
94  //----------------- Templates ---------------------------------------
95 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
96 #if(CXSC_INDEX_CHECK)
97  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
98 #else
99  throw();
100 #endif
101 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
102 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
105 #else
106  throw();
107 #endif
108 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
109 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
110 template <class MV,class V> friend V _mvim(const MV &mv) throw();
111 template <class MV,class V> friend V _mvre(const MV &mv) throw();
112 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
113 #if(CXSC_INDEX_CHECK)
114  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
115 #else
116  throw();
117 #endif
118 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
119 #if(CXSC_INDEX_CHECK)
120  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
121 #else
122  throw();
123 #endif
124  template <class MV,class S> friend MV &_mvssetim(MV &mv, const S &s) throw();
125  template <class MV,class S> friend MV &_mvssetre(MV &mv, const S &s) throw();
126 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
127 #if(CXSC_INDEX_CHECK)
128  throw(OP_WITH_WRONG_DIM);
129 #else
130  throw();
131 #endif
132 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
133 #if(CXSC_INDEX_CHECK)
134  throw(OP_WITH_WRONG_DIM);
135 #else
136  throw();
137 #endif
138 
139  template <class MV1,class MV2,class S> friend S _mvmvcmult(const MV1 & rv1, const MV2 &rv2)
140 #if(CXSC_INDEX_CHECK)
141  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
142 #else
143  throw();
144 #endif
145  template <class MV1,class MV2,class S> friend S _mvmvcimult(const MV1 & rv1, const MV2 &rv2)
146 #if(CXSC_INDEX_CHECK)
147  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
148 #else
149  throw();
150 #endif
151  template <class V,class MV,class S> friend S _vmvcmult(const V &rv1, const MV &rv2)
152 #if(CXSC_INDEX_CHECK)
153  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
154 #else
155  throw();
156 #endif
157  template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
158 #if(CXSC_INDEX_CHECK)
159  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
160 #else
161  throw();
162 #endif
163  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
164  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
165 #if(CXSC_INDEX_CHECK)
166  throw(ERROR__OP_WITH_WRONG_DIM<E>);
167 #else
168  throw();
169 #endif
170  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
171 #if(CXSC_INDEX_CHECK)
172  throw(ERROR__OP_WITH_WRONG_DIM<E>);
173 #else
174  throw();
175 #endif
176  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
177 #if(CXSC_INDEX_CHECK)
178  throw(ERROR__OP_WITH_WRONG_DIM<E>);
179 #else
180  throw();
181 #endif
182  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
183 #if(CXSC_INDEX_CHECK)
184  throw(ERROR__OP_WITH_WRONG_DIM<E>);
185 #else
186  throw();
187 #endif
188  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
189 #if(CXSC_INDEX_CHECK)
190  throw(ERROR__OP_WITH_WRONG_DIM<E>);
191 #else
192  throw();
193 #endif
194  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
195 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
196 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
197 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
198 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
199 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
200 #if(CXSC_INDEX_CHECK)
201  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
202 #else
203  throw();
204 #endif
205 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
206 #if(CXSC_INDEX_CHECK)
207  throw(ERROR__OP_WITH_WRONG_DIM<V>);
208 #else
209  throw();
210 #endif
211 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
212 #if(CXSC_INDEX_CHECK)
213  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
214 #else
215  throw();
216 #endif
217 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
218 #if(CXSC_INDEX_CHECK)
219  throw(ERROR__OP_WITH_WRONG_DIM<V>);
220 #else
221  throw();
222 #endif
223  // Real
224 
225 
226  // interval
227 
228 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
229 #if(CXSC_INDEX_CHECK)
230  throw(ERROR__OP_WITH_WRONG_DIM<V>);
231 #else
232  throw();
233 #endif
234 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
235 #if(CXSC_INDEX_CHECK)
236  throw(ERROR__OP_WITH_WRONG_DIM<V>);
237 #else
238  throw();
239 #endif
240 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
241 #if(CXSC_INDEX_CHECK)
242  throw(ERROR__OP_WITH_WRONG_DIM<V>);
243 #else
244  throw();
245 #endif
246 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
247 #if(CXSC_INDEX_CHECK)
248  throw(ERROR__OP_WITH_WRONG_DIM<V>);
249 #else
250  throw();
251 #endif
252 
253 #endif
254 
255  //----------------- Konstruktoren ----------------------------------
256 
258  explicit INLINE cmatrix_subv (complex *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) { }
259  public:
261  INLINE cmatrix_subv(const cmatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
262  public:
263 
264  //---------------------- Standardfunktionen ------------------------
266  friend INLINE int Lb(const cmatrix_subv &rv) throw() { return rv.lb; }
268  friend INLINE int Ub(const cmatrix_subv &rv) throw() { return rv.ub; }
270  friend INLINE int VecLen(const cmatrix_subv &rv) throw() { return rv.size; }
271 
273  INLINE complex& operator [](const int &i) const
274 #if(CXSC_INDEX_CHECK)
275  throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
276 #else
277  throw();
278 #endif
279 
281  INLINE complex& operator [](const int &i)
282 #if(CXSC_INDEX_CHECK)
283  throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
284 #else
285  throw();
286 #endif
287 
289  INLINE cmatrix_subv &operator ()() throw() { return *this; }
291  INLINE cmatrix_subv operator ()(const int &i)
292 #if(CXSC_INDEX_CHECK)
293  throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
294 #else
295  throw();
296 #endif
297  INLINE cmatrix_subv operator ()(const int &i1,const int &i2)
299 #if(CXSC_INDEX_CHECK)
300  throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
301 #else
302  throw();
303 #endif
304 
306  INLINE cmatrix_subv &operator =(const scmatrix_subv &rv);
308  INLINE cmatrix_subv &operator =(const scvector &r);
310  INLINE cmatrix_subv &operator =(const scvector_slice &r);
312  INLINE cmatrix_subv &operator =(const srmatrix_subv &rv);
314  INLINE cmatrix_subv &operator =(const srvector &r);
316  INLINE cmatrix_subv &operator =(const srvector_slice &r);
317 
319  INLINE cmatrix_subv &operator =(const cmatrix_subv &rv) throw();
321  INLINE cmatrix_subv &operator =(const complex &r) throw();
323  INLINE cmatrix_subv &operator =(const cmatrix &m)
324 #if(CXSC_INDEX_CHECK)
325  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
326 #else
327  throw();
328 #endif
329  INLINE cmatrix_subv &operator =(const cmatrix_slice &m)
331 #if(CXSC_INDEX_CHECK)
332  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
333 #else
334  throw();
335 #endif
336  INLINE cmatrix_subv &operator =(const cvector &v)
338 #if(CXSC_INDEX_CHECK)
339  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
340 #else
341  throw();
342 #endif
343  INLINE cmatrix_subv &operator =(const cvector_slice &v)
345 #if(CXSC_INDEX_CHECK)
346  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
347 #else
348  throw();
349 #endif
350 
351  //Sparse
353  INLINE cmatrix_subv &operator +=(const scmatrix_subv &rv);
355  INLINE cmatrix_subv &operator +=(const scvector &r);
357  INLINE cmatrix_subv &operator +=(const scvector_slice &r);
359  INLINE cmatrix_subv &operator +=(const srmatrix_subv &rv);
361  INLINE cmatrix_subv &operator +=(const srvector &r);
363  INLINE cmatrix_subv &operator +=(const srvector_slice &r);
365  INLINE cmatrix_subv &operator -=(const scmatrix_subv &rv);
367  INLINE cmatrix_subv &operator -=(const scvector &r);
371  INLINE cmatrix_subv &operator -=(const srmatrix_subv &rv);
373  INLINE cmatrix_subv &operator -=(const srvector &r);
376 
378  INLINE cmatrix_subv &operator *=(const complex &c) throw();
380  INLINE cmatrix_subv &operator +=(const complex &c) throw();
382  INLINE cmatrix_subv &operator -=(const complex &c) throw();
384  INLINE cmatrix_subv &operator /=(const complex &c) throw();
386  INLINE cmatrix_subv &operator -=(const cvector &rv)
387 #if(CXSC_INDEX_CHECK)
388  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
389 #else
390  throw();
391 #endif
392  INLINE cmatrix_subv &operator +=(const cvector &rv)
394 #if(CXSC_INDEX_CHECK)
395  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
396 #else
397  throw();
398 #endif
399  INLINE cmatrix_subv &operator -=(const cvector_slice &rv)
401 #if(CXSC_INDEX_CHECK)
402  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
403 #else
404  throw();
405 #endif
406  INLINE cmatrix_subv &operator +=(const cvector_slice &rv)
408 #if(CXSC_INDEX_CHECK)
409  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
410 #else
411  throw();
412 #endif
413  // Real
415  INLINE cmatrix_subv &operator =(const rmatrix_subv &rv) throw();
417  INLINE cmatrix_subv &operator =(const real &r) throw();
419  INLINE cmatrix_subv &operator =(const rmatrix &m)
420 #if(CXSC_INDEX_CHECK)
421  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
422 #else
423  throw();
424 #endif
425  INLINE cmatrix_subv &operator =(const rmatrix_slice &m)
427 #if(CXSC_INDEX_CHECK)
428  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
429 #else
430  throw();
431 #endif
432  INLINE cmatrix_subv &operator =(const rvector &v)
434 #if(CXSC_INDEX_CHECK)
435  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
436 #else
437  throw();
438 #endif
439  INLINE cmatrix_subv &operator =(const rvector_slice &v)
441 #if(CXSC_INDEX_CHECK)
442  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
443 #else
444  throw();
445 #endif
446 
448  INLINE cmatrix_subv &operator *=(const real &c) throw();
450  INLINE cmatrix_subv &operator +=(const real &c) throw();
452  INLINE cmatrix_subv &operator -=(const real &c) throw();
454  INLINE cmatrix_subv &operator /=(const real &c) throw();
456  INLINE cmatrix_subv &operator -=(const rvector &rv)
457 #if(CXSC_INDEX_CHECK)
458  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
459 #else
460  throw();
461 #endif
462  INLINE cmatrix_subv &operator +=(const rvector &rv)
464 #if(CXSC_INDEX_CHECK)
465  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
466 #else
467  throw();
468 #endif
469  INLINE cmatrix_subv &operator -=(const rvector_slice &rv)
471 #if(CXSC_INDEX_CHECK)
472  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
473 #else
474  throw();
475 #endif
476  INLINE cmatrix_subv &operator +=(const rvector_slice &rv)
478 #if(CXSC_INDEX_CHECK)
479  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
480 #else
481  throw();
482 #endif
483 //#else
484 //#endif
485 
486 };
487 
489 INLINE cmatrix_subv Row(cmatrix &m,const int &i)
490 #if(CXSC_INDEX_CHECK)
491  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
492 #else
493  throw();
494 #endif
495 INLINE cmatrix_subv Col(cmatrix &m,const int &i)
497 #if(CXSC_INDEX_CHECK)
498  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
499 #else
500  throw();
501 #endif
502 
503 
504 
505 //----------------------- Matrix -----------------------------------------------
506 
507 class cmatrix_slice;
508 
510 
513 class cmatrix
514 {
515  friend class cmatrix_slice;
516  friend class cmatrix_subv;
517  friend class cimatrix;
518  private:
519  complex *dat;
520  int lb1,ub1,lb2,ub2,xsize,ysize;
521 
522  public:
523  double* to_blas_array() const { return (double*)dat; }
524 //#if(CXSC_INDEX_CHECK)
525 #ifdef _CXSC_FRIEND_TPL
526  //----------------- Templates ---------------------------------------
527 template <class S,class M> friend void _smconstr(S &s,const M &m)
528 #if(CXSC_INDEX_CHECK)
529  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
530 #else
531  throw();
532 #endif
533 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
534 #if(CXSC_INDEX_CHECK)
535  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
536 #else
537  throw();
538 #endif
539  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
540  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
541  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
542 #if(CXSC_INDEX_CHECK)
543  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
544 #else
545  throw();
546 #endif
547  template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
548 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
549 #if(CXSC_INDEX_CHECK)
550  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
551 #else
552  throw();
553 #endif
554 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
555  template <class M> friend int _mlb(const M &m, const int &i)
556 #if(CXSC_INDEX_CHECK)
557  throw(ERROR__WRONG_ROW_OR_COL<M>);
558 #else
559  throw();
560 #endif
561  template <class M> friend int _mub(const M &m, const int &i)
562 #if(CXSC_INDEX_CHECK)
563  throw(ERROR__WRONG_ROW_OR_COL<M>);
564 #else
565  throw();
566 #endif
567  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
568 #if(CXSC_INDEX_CHECK)
569  throw(ERROR__WRONG_ROW_OR_COL<M>);
570 #else
571  throw();
572 #endif
573  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
574 #if(CXSC_INDEX_CHECK)
575  throw(ERROR__WRONG_ROW_OR_COL<M>);
576 #else
577  throw();
578 #endif
579  template <class M,class E> friend E _mre(const M &m) throw();
580  template <class M,class E> friend E _mim(const M &m) throw();
581  template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
582 #if(CXSC_INDEX_CHECK)
583  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
584 #else
585  throw();
586 #endif
587  template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
588 #if(CXSC_INDEX_CHECK)
589  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
590 #else
591  throw();
592 #endif
593  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
594 #if(CXSC_INDEX_CHECK)
595  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
596 #else
597  throw();
598 #endif
599  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
600 #if(CXSC_INDEX_CHECK)
601  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
602 #else
603  throw();
604 #endif
605  template <class M> friend void _mresize(M &A) throw();
606  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
607 #if(CXSC_INDEX_CHECK)
608  throw(ERROR__WRONG_BOUNDARIES<M>);
609 #else
610  throw();
611 #endif
612  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
613 #if(CXSC_INDEX_CHECK)
614  throw(ERROR__WRONG_BOUNDARIES<M>);
615 #else
616  throw();
617 #endif
618  template <class M,class E> friend E _mabs(const M &m) throw();
619  //-------------- matrix-matrix -------------
620  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
621 #if(CXSC_INDEX_CHECK)
622  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
623 #else
624  throw();
625 #endif
626  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
627 #if(CXSC_INDEX_CHECK)
628  throw(ERROR__OP_WITH_WRONG_DIM<M>);
629 #else
630  throw();
631 #endif
632  template <class M> friend M _mminus(const M &m) throw();
633  template <class MS,class E> friend E _msminus(const MS &ms) throw();
634  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
635 #if(CXSC_INDEX_CHECK)
636  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
637 #else
638  throw();
639 #endif
640  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
641 #if(CXSC_INDEX_CHECK)
642  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
643 #else
644  throw();
645 #endif
646  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
647 #if(CXSC_INDEX_CHECK)
648  throw(ERROR__OP_WITH_WRONG_DIM<M>);
649 #else
650  throw();
651 #endif
652  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
653 #if(CXSC_INDEX_CHECK)
654  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
655 #else
656  throw();
657 #endif
658  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
659 #if(CXSC_INDEX_CHECK)
660  throw(ERROR__OP_WITH_WRONG_DIM<E>);
661 #else
662  throw();
663 #endif
664  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
665 #if(CXSC_INDEX_CHECK)
666  throw(ERROR__OP_WITH_WRONG_DIM<E>);
667 #else
668  throw();
669 #endif
670  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
671 #if(CXSC_INDEX_CHECK)
672  throw(ERROR__OP_WITH_WRONG_DIM<E>);
673 #else
674  throw();
675 #endif
676  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
677 #if(CXSC_INDEX_CHECK)
678  throw(ERROR__OP_WITH_WRONG_DIM<E>);
679 #else
680  throw();
681 #endif
682  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
683 #if(CXSC_INDEX_CHECK)
684  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
685 #else
686  throw();
687 #endif
688  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
689 #if(CXSC_INDEX_CHECK)
690  throw(ERROR__OP_WITH_WRONG_DIM<M>);
691 #else
692  throw();
693 #endif
694  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
695 #if(CXSC_INDEX_CHECK)
696  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
697 #else
698  throw();
699 #endif
700  template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2)
701 #if(CXSC_INDEX_CHECK)
702  throw(ERROR__OP_WITH_WRONG_DIM<E>);
703 #else
704  throw();
705 #endif
706  template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
707 #if(CXSC_INDEX_CHECK)
708  throw(ERROR__OP_WITH_WRONG_DIM<E>);
709 #else
710  throw();
711 #endif
712  template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2)
713 #if(CXSC_INDEX_CHECK)
714  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
715 #else
716  throw();
717 #endif
718  template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
719 #if(CXSC_INDEX_CHECK)
720  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
721 #else
722  throw();
723 #endif
724  template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
725 #if(CXSC_INDEX_CHECK)
726  throw(ERROR__OP_WITH_WRONG_DIM<E>);
727 #else
728  throw();
729 #endif
730  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
731 #if(CXSC_INDEX_CHECK)
732  throw(ERROR__OP_WITH_WRONG_DIM<E>);
733 #else
734  throw();
735 #endif
736  template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
737 #if(CXSC_INDEX_CHECK)
738  throw(ERROR__OP_WITH_WRONG_DIM<E>);
739 #else
740  throw();
741 #endif
742  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
743 #if(CXSC_INDEX_CHECK)
744  throw(ERROR__OP_WITH_WRONG_DIM<E>);
745 #else
746  throw();
747 #endif
748  template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
749 #if(CXSC_INDEX_CHECK)
750  throw(ERROR__OP_WITH_WRONG_DIM<M>);
751 #else
752  throw();
753 #endif
754  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
755 #if(CXSC_INDEX_CHECK)
756  throw(ERROR__OP_WITH_WRONG_DIM<M>);
757 #else
758  throw();
759 #endif
760  template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
761 #if(CXSC_INDEX_CHECK)
762  throw(ERROR__OP_WITH_WRONG_DIM<E>);
763 #else
764  throw();
765 #endif
766  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
767 #if(CXSC_INDEX_CHECK)
768  throw(ERROR__OP_WITH_WRONG_DIM<E>);
769 #else
770  throw();
771 #endif
772  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
773 #if(CXSC_INDEX_CHECK)
774  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
775 #else
776  throw();
777 #endif
778  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
779 #if(CXSC_INDEX_CHECK)
780  throw(ERROR__OP_WITH_WRONG_DIM<M>);
781 #else
782  throw();
783 #endif
784  //-------- matrix-scalar -----------------
785  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
786  template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
787  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
788  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
789  template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
790  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
791  //-------- matrix-vector ---------------------
792  template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
793 #if(CXSC_INDEX_CHECK)
794  throw(ERROR__OP_WITH_WRONG_DIM<M>);
795 #else
796  throw();
797 #endif
798  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
799 #if(CXSC_INDEX_CHECK)
800  throw(ERROR__OP_WITH_WRONG_DIM<M>);
801 #else
802  throw();
803 #endif
804  template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
805 #if(CXSC_INDEX_CHECK)
806  throw(ERROR__OP_WITH_WRONG_DIM<M>);
807 #else
808  throw();
809 #endif
810  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
811 #if(CXSC_INDEX_CHECK)
812  throw(ERROR__OP_WITH_WRONG_DIM<M>);
813 #else
814  throw();
815 #endif
816  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
817 #if(CXSC_INDEX_CHECK)
818  throw(ERROR__OP_WITH_WRONG_DIM<M>);
819 #else
820  throw();
821 #endif
822  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
823 #if(CXSC_INDEX_CHECK)
824  throw(ERROR__OP_WITH_WRONG_DIM<M>);
825 #else
826  throw();
827 #endif
828  template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
829 #if(CXSC_INDEX_CHECK)
830  throw(ERROR__OP_WITH_WRONG_DIM<M>);
831 #else
832  throw();
833 #endif
834  template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
835 #if(CXSC_INDEX_CHECK)
836  throw(ERROR__OP_WITH_WRONG_DIM<M>);
837 #else
838  throw();
839 #endif
840 
841  template <class M> friend void *_mvoid(const M &m) throw();
842  template <class M> friend bool _mnot(const M &m) throw();
843  template <class MS> friend void *_msvoid(const MS &ms) throw();
844  template <class MS> friend bool _msnot(const MS &ms) throw();
845  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
846  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
847  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
848  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
849  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
850  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
851  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
852  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
853  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
854  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
855  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
856  template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
857 
858  // Real
859 
860  //--- Real --------- matrix-matrix ----------------------
861 
862  //--- Real --------- matrix-scalar ----------------------
863 
864  //--- Real --------- matrix-vector ----------------------
865  template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
866 #if(CXSC_INDEX_CHECK)
867  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
868 #else
869  throw();
870 #endif
871  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
872 #if(CXSC_INDEX_CHECK)
873  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
874 #else
875  throw();
876 #endif
877  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
878 #if(CXSC_INDEX_CHECK)
879  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
880 #else
881  throw();
882 #endif
883  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
884 #if(CXSC_INDEX_CHECK)
885  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
886 #else
887  throw();
888 #endif
889 
890  // interval --------
891  // matrix-matrix
892 
893  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
894 #if(CXSC_INDEX_CHECK)
895  throw(ERROR__OP_WITH_WRONG_DIM<E>);
896 #else
897  throw();
898 #endif
899  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
900 #if(CXSC_INDEX_CHECK)
901  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
902 #else
903  throw();
904 #endif
905  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
906 #if(CXSC_INDEX_CHECK)
907  throw(ERROR__OP_WITH_WRONG_DIM<M>);
908 #else
909  throw();
910 #endif
911 
912  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
913 #if(CXSC_INDEX_CHECK)
914  throw(ERROR__OP_WITH_WRONG_DIM<E>);
915 #else
916  throw();
917 #endif
918  // matrix-scalar
919 
920  // matrix-vector
921 
922  // cinterval ----------
923 
924  template <class M,class E> friend E _mdiam(const M &m) throw();
925  template <class M,class E> friend E _mmid(const M &m) throw();
926  template <class MS,class E> friend E _msdiam(const MS &ms) throw();
927  template <class MS,class E> friend E _msmid(const MS &ms) throw();
928  template <class M,class E> friend E _minf(const M &m) throw();
929  template <class MS,class E> friend E _msinf(const MS &ms) throw();
930  template <class M,class E> friend E _msup(const M &m) throw();
931  template <class MS,class E> friend E _mssup(const MS &ms) throw();
932  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
933 #if(CXSC_INDEX_CHECK)
934  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
935 #else
936  throw();
937 #endif
938  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
939 #if(CXSC_INDEX_CHECK)
940  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
941 #else
942  throw();
943 #endif
944  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
945 #if(CXSC_INDEX_CHECK)
946  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
947 #else
948  throw();
949 #endif
950  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
951 #if(CXSC_INDEX_CHECK)
952  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
953 #else
954  throw();
955 #endif
956  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
957 #if(CXSC_INDEX_CHECK)
958  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
959 #else
960  throw();
961 #endif
962  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
963 #if(CXSC_INDEX_CHECK)
964  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
965 #else
966  throw();
967 #endif
968  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
969 #if(CXSC_INDEX_CHECK)
970  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
971 #else
972  throw();
973 #endif
974  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
975 #if(CXSC_INDEX_CHECK)
976  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
977 #else
978  throw();
979 #endif
980 
981  // matrix-matrix
982 
983  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
984 #if(CXSC_INDEX_CHECK)
985  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
986 #else
987  throw();
988 #endif
989  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
990 #if(CXSC_INDEX_CHECK)
991  throw(ERROR__OP_WITH_WRONG_DIM<M>);
992 #else
993  throw();
994 #endif
995  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
996 #if(CXSC_INDEX_CHECK)
997  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
998 #else
999  throw();
1000 #endif
1001 
1002  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
1003 #if(CXSC_INDEX_CHECK)
1004  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1005 #else
1006  throw();
1007 #endif
1008  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1009 #if(CXSC_INDEX_CHECK)
1010  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1011 #else
1012  throw();
1013 #endif
1014  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1015 #if(CXSC_INDEX_CHECK)
1016  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1017 #else
1018  throw();
1019 #endif
1020  // matrix-scalar
1021 
1022  // matrix-vector
1023 
1024 #endif
1025 
1026  //-------------------------- Konstruktoren ----------------------------
1027 
1028 // complex
1030  INLINE cmatrix(const cmatrix &rm) throw();
1032  INLINE cmatrix(const cmatrix_slice &rm) throw();
1034  INLINE cmatrix(const scmatrix &rm);
1036  INLINE cmatrix(const scmatrix_slice &rm);
1038  INLINE cmatrix() throw();
1040  explicit INLINE cmatrix(const int &m, const int &n)
1041 #if(CXSC_INDEX_CHECK)
1042  throw(ERROR_CMATRIX_WRONG_BOUNDARIES);
1043 #else
1044  throw();
1045 #endif
1046  explicit INLINE cmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1048 #if(CXSC_INDEX_CHECK)
1049  throw(ERROR_CMATRIX_WRONG_BOUNDARIES);
1050 #else
1051  throw();
1052 #endif
1053  explicit INLINE cmatrix(const cvector &v) throw();
1056  explicit INLINE cmatrix(const cvector_slice &v) throw();
1058  explicit INLINE cmatrix(const complex &r) throw();
1060  INLINE cmatrix &operator =(const complex &r) throw();
1062  INLINE cmatrix &operator =(const cmatrix &m) throw();
1064  INLINE cmatrix &operator =(const cmatrix_slice &ms) throw();
1066  INLINE cmatrix &operator =(const scmatrix &m);
1068  INLINE cmatrix &operator =(const scmatrix_slice &ms);
1070  INLINE cmatrix &operator =(const cvector &v) throw();
1072  INLINE cmatrix &operator =(const cvector_slice &v) throw();
1073 // real
1075  explicit INLINE cmatrix(const real &) throw();
1077  explicit INLINE cmatrix(const rmatrix &rm) throw();
1079  explicit INLINE cmatrix(const rmatrix_slice &rm) throw();
1081  explicit INLINE cmatrix(const srmatrix &rm);
1083  explicit INLINE cmatrix(const srmatrix_slice &rm);
1085  explicit INLINE cmatrix(const rvector &v) throw();
1087  explicit INLINE cmatrix(const rvector_slice &v) throw();
1089  INLINE cmatrix &operator =(const real &r) throw();
1091  INLINE cmatrix &operator =(const rmatrix &m) throw();
1093  INLINE cmatrix &operator =(const rmatrix_slice &ms) throw();
1095  INLINE cmatrix &operator =(const srmatrix &m);
1097  INLINE cmatrix &operator =(const srmatrix_slice &ms);
1099  INLINE cmatrix &operator =(const rvector &v) throw();
1101  INLINE cmatrix &operator =(const rvector_slice &v) throw();
1102 
1103  //--------------------------- Destruktoren -----------------------------
1104 
1105  INLINE ~cmatrix() throw() { delete [] dat; }
1106 
1107 
1108  //--------------------------- Operatoren -----------------------------
1110  INLINE cmatrix &operator +=(const srmatrix &m);
1112  INLINE cmatrix &operator +=(const srmatrix_slice &ms);
1114  INLINE cmatrix &operator +=(const scmatrix &m);
1116  INLINE cmatrix &operator +=(const scmatrix_slice &ms);
1118  INLINE cmatrix &operator -=(const srmatrix &m);
1120  INLINE cmatrix &operator -=(const srmatrix_slice &ms);
1122  INLINE cmatrix &operator -=(const scmatrix &m);
1124  INLINE cmatrix &operator -=(const scmatrix_slice &ms);
1126  INLINE cmatrix &operator *=(const srmatrix &m);
1128  INLINE cmatrix &operator *=(const srmatrix_slice &ms);
1130  INLINE cmatrix &operator *=(const scmatrix &m);
1132  INLINE cmatrix &operator *=(const scmatrix_slice &ms);
1133 
1135  INLINE cmatrix operator()(const intvector& p, const intvector& q);
1137  INLINE cmatrix operator()(const intmatrix& P, const intmatrix& Q);
1139  INLINE cmatrix operator()(const intvector& p);
1141  INLINE cmatrix operator()(const intmatrix& P);
1142 
1143 
1144  //------------------------- Standardfunktionen -------------------------
1145 
1147  INLINE cmatrix_subv operator [](const int &i) const
1148 #if(CXSC_INDEX_CHECK)
1149  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1150 #else
1151  throw();
1152 #endif
1153  INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const
1155 #if(CXSC_INDEX_CHECK)
1156  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1157 #else
1158  throw();
1159 #endif
1160  INLINE cmatrix_subv operator [](const int &i)
1162 #if(CXSC_INDEX_CHECK)
1163  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1164 #else
1165  throw();
1166 #endif
1167  INLINE cmatrix_subv operator [](const cxscmatrix_column &i)
1169 #if(CXSC_INDEX_CHECK)
1170  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1171 #else
1172  throw();
1173 #endif
1174  INLINE cmatrix &operator ()() throw() { return *this; }
1177  INLINE cmatrix_slice operator ()(const int &m, const int &n)
1178 #if(CXSC_INDEX_CHECK)
1179  throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG);
1180 #else
1181  throw();
1182 #endif
1183  INLINE cmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1185 #if(CXSC_INDEX_CHECK)
1186  throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG);
1187 #else
1188  throw();
1189 #endif
1190  INLINE operator void*() throw();
1191 //#else
1192 //#endif
1193 };
1194 
1195 
1197 
1203 {
1204  friend class cmatrix;
1205  friend class cimatrix;
1206  private:
1207  complex *dat;
1208  int offset1,offset2,mxsize,mysize;
1209  int start1,end1,start2,end2,sxsize,sysize; // slice size
1210 
1211  public:
1212 //#if(CXSC_INDEX_CHECK)
1213 #ifdef _CXSC_FRIEND_TPL
1214  //----------------- Templates ---------------------------------------
1215 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1216 #if(CXSC_INDEX_CHECK)
1217  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1218 #else
1219  throw();
1220 #endif
1221  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1222 #if(CXSC_INDEX_CHECK)
1223  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1224 #else
1225  throw();
1226 #endif
1227  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1228 #if(CXSC_INDEX_CHECK)
1229  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1230 #else
1231  throw();
1232 #endif
1233  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
1234  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
1235 
1236  template <class MS> friend int _mslb(const MS &ms, const int &i)
1237 #if(CXSC_INDEX_CHECK)
1238  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1239 #else
1240  throw();
1241 #endif
1242  template <class MS> friend int _msub(const MS &ms, const int &i)
1243 #if(CXSC_INDEX_CHECK)
1244  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1245 #else
1246  throw();
1247 #endif
1248  template <class MS,class E> friend E _msre(const MS &ms) throw();
1249  template <class MS,class E> friend E _msim(const MS &ms) throw();
1250  template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
1251 #if(CXSC_INDEX_CHECK)
1252  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1253 #else
1254  throw();
1255 #endif
1256  template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
1257 #if(CXSC_INDEX_CHECK)
1258  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1259 #else
1260  throw();
1261 #endif
1262  template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1263 #if(CXSC_INDEX_CHECK)
1264  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1265 #else
1266  throw();
1267 #endif
1268  template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1269 #if(CXSC_INDEX_CHECK)
1270  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1271 #else
1272  throw();
1273 #endif
1274  template <class MS,class E> friend E _msabs(const MS &ms) throw();
1275  //-------- matrix-matrix --------------
1276  template <class MS,class E> friend E _msminus(const MS &ms) throw();
1277  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1278 #if(CXSC_INDEX_CHECK)
1279  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1280 #else
1281  throw();
1282 #endif
1283  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1284 #if(CXSC_INDEX_CHECK)
1285  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1286 #else
1287  throw();
1288 #endif
1289  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1290 #if(CXSC_INDEX_CHECK)
1291  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1292 #else
1293  throw();
1294 #endif
1295  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1296 #if(CXSC_INDEX_CHECK)
1297  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1298 #else
1299  throw();
1300 #endif
1301  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1302 #if(CXSC_INDEX_CHECK)
1303  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1304 #else
1305  throw();
1306 #endif
1307  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1308 #if(CXSC_INDEX_CHECK)
1309  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1310 #else
1311  throw();
1312 #endif
1313  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1314 #if(CXSC_INDEX_CHECK)
1315  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1316 #else
1317  throw();
1318 #endif
1319  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1320 #if(CXSC_INDEX_CHECK)
1321  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1322 #else
1323  throw();
1324 #endif
1325  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1326 #if(CXSC_INDEX_CHECK)
1327  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1328 #else
1329  throw();
1330 #endif
1331  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1332 #if(CXSC_INDEX_CHECK)
1333  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1334 #else
1335  throw();
1336 #endif
1337  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1338 #if(CXSC_INDEX_CHECK)
1339  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1340 #else
1341  throw();
1342 #endif
1343  template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
1344 #if(CXSC_INDEX_CHECK)
1345  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1346 #else
1347  throw();
1348 #endif
1349  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1350 #if(CXSC_INDEX_CHECK)
1351  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1352 #else
1353  throw();
1354 #endif
1355  template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
1356 #if(CXSC_INDEX_CHECK)
1357  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1358 #else
1359  throw();
1360 #endif
1361  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1362 #if(CXSC_INDEX_CHECK)
1363  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1364 #else
1365  throw();
1366 #endif
1367  template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
1368 #if(CXSC_INDEX_CHECK)
1369  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1370 #else
1371  throw();
1372 #endif
1373  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1374 #if(CXSC_INDEX_CHECK)
1375  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1376 #else
1377  throw();
1378 #endif
1379  template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
1380 #if(CXSC_INDEX_CHECK)
1381  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1382 #else
1383  throw();
1384 #endif
1385  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1386 #if(CXSC_INDEX_CHECK)
1387  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1388 #else
1389  throw();
1390 #endif
1391  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1392 #if(CXSC_INDEX_CHECK)
1393  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1394 #else
1395  throw();
1396 #endif
1397  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1398 #if(CXSC_INDEX_CHECK)
1399  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1400 #else
1401  throw();
1402 #endif
1403  //--------- matrix-vector --------------
1404  template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
1405 #if(CXSC_INDEX_CHECK)
1406  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1407 #else
1408  throw();
1409 #endif
1410  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1411 #if(CXSC_INDEX_CHECK)
1412  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1413 #else
1414  throw();
1415 #endif
1416  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1417 #if(CXSC_INDEX_CHECK)
1418  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1419 #else
1420  throw();
1421 #endif
1422  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1423 #if(CXSC_INDEX_CHECK)
1424  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1425 #else
1426  throw();
1427 #endif
1428  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
1429 #if(CXSC_INDEX_CHECK)
1430  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1431 #else
1432  throw();
1433 #endif
1434  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1435 #if(CXSC_INDEX_CHECK)
1436  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1437 #else
1438  throw();
1439 #endif
1440  //--------- matrix-scalar --------------
1441  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1442  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
1443  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1444  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
1445 
1446  template <class MS> friend void *_msvoid(const MS &ms) throw();
1447  template <class MS> friend bool _msnot(const MS &ms) throw();
1448  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1449  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1450  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1451  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1452  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1453  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1454  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
1455  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
1456  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
1457  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
1458  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
1459  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
1460 
1461  // Real
1462 
1463  //--- Real ------------ matrix-scalar -----------
1464  //--- Real ------------ matrix-vector -----------
1465  //--- Real ------------ matrix-matrix -----------
1466  // interval ----------------
1467  // matrix-matrix
1468 
1469  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1470 #if(CXSC_INDEX_CHECK)
1471  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1472 #else
1473  throw();
1474 #endif
1475  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1476 #if(CXSC_INDEX_CHECK)
1477  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1478 #else
1479  throw();
1480 #endif
1481  // matrix-scalar
1482  // matrix-vector
1483 
1484  // cinterval --------------
1485 
1486  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1487 #if(CXSC_INDEX_CHECK)
1488  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1489 #else
1490  throw();
1491 #endif
1492  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1493 #if(CXSC_INDEX_CHECK)
1494  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1495 #else
1496  throw();
1497 #endif
1498  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1499 #if(CXSC_INDEX_CHECK)
1500  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1501 #else
1502  throw();
1503 #endif
1504  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1505 #if(CXSC_INDEX_CHECK)
1506  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1507 #else
1508  throw();
1509 #endif
1510  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1511 #if(CXSC_INDEX_CHECK)
1512  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1513 #else
1514  throw();
1515 #endif
1516  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1517 #if(CXSC_INDEX_CHECK)
1518  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1519 #else
1520  throw();
1521 #endif
1522  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1523 #if(CXSC_INDEX_CHECK)
1524  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1525 #else
1526  throw();
1527 #endif
1528  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1529 #if(CXSC_INDEX_CHECK)
1530  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1531 #else
1532  throw();
1533 #endif
1534 
1535  // matrix-matrix
1536 
1537  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1538 #if(CXSC_INDEX_CHECK)
1539  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1540 #else
1541  throw();
1542 #endif
1543  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1544 #if(CXSC_INDEX_CHECK)
1545  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1546 #else
1547  throw();
1548 #endif
1549 
1550  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1551 #if(CXSC_INDEX_CHECK)
1552  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1553 #else
1554  throw();
1555 #endif
1556  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1557 #if(CXSC_INDEX_CHECK)
1558  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1559 #else
1560  throw();
1561 #endif
1562 
1563  // matrix-scalar
1564  // cinterval -- matrix-vector
1565 
1566 
1567  /* friend TINLINE civector &_vsmscimultassign<civector_slice,cmatrix_slice,cinterval>(civector_slice &v,const cmatrix_slice &ms)
1568 #if(CXSC_INDEX_CHECK)
1569  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1570 #else
1571  throw();
1572  #endif */
1573 
1574 #endif
1575 
1576  //--------------- Konstruktoren ----------------------------------------
1577 
1579  explicit INLINE cmatrix_slice(cmatrix &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) { }
1581  explicit INLINE cmatrix_slice(cmatrix_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) { }
1582  public:
1584  INLINE cmatrix_slice(const cmatrix_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) { }
1585  public:
1586 
1587  //---------------- Standardfunktionen -----------------------------------
1588 
1589  friend cvector::cvector(const cmatrix_slice &sl)
1590 #if(CXSC_INDEX_CHECK)
1591  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1592 #else
1593  throw();
1594 #endif
1595  friend INLINE cmatrix::cmatrix(const cmatrix_slice &) throw();
1597  INLINE cmatrix_slice &operator =(const cmatrix &m)
1598 #if(CXSC_INDEX_CHECK)
1599  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1600 #else
1601  throw();
1602 #endif
1603 
1604  //Sparse
1606  INLINE cmatrix_slice &operator =(const scmatrix &ms);
1610  INLINE cmatrix_slice &operator =(const srmatrix &ms);
1613 
1614 
1616  INLINE cmatrix_slice &operator =(const cmatrix_slice &ms)
1617 #if(CXSC_INDEX_CHECK)
1618  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1619 #else
1620  throw();
1621 #endif
1622  INLINE cmatrix_slice &operator =(const complex &r) throw();
1625  INLINE cmatrix_slice &operator =(const cvector &v)
1626 #if(CXSC_INDEX_CHECK)
1627  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1628 #else
1629  throw();
1630 #endif
1631  INLINE cmatrix_slice &operator =(const cvector_slice &v)
1633 #if(CXSC_INDEX_CHECK)
1634  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1635 #else
1636  throw();
1637 #endif
1638  INLINE cmatrix_slice &operator =(const rmatrix &m)
1640 #if(CXSC_INDEX_CHECK)
1641  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1642 #else
1643  throw();
1644 #endif
1645  INLINE cmatrix_slice &operator =(const rmatrix_slice &ms)
1647 #if(CXSC_INDEX_CHECK)
1648  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1649 #else
1650  throw();
1651 #endif
1652  INLINE cmatrix_slice &operator =(const real &r) throw();
1655  INLINE cmatrix_slice &operator =(const rvector &v)
1656 #if(CXSC_INDEX_CHECK)
1657  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1658 #else
1659  throw();
1660 #endif
1661  INLINE cmatrix_slice &operator =(const rvector_slice &v)
1663 #if(CXSC_INDEX_CHECK)
1664  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1665 #else
1666  throw();
1667 #endif
1668  INLINE cmatrix_subv operator [](const int &i)
1670 #if(CXSC_INDEX_CHECK)
1671  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1672 #else
1673  throw();
1674 #endif
1675  INLINE cmatrix_subv operator [](const cxscmatrix_column &i)
1677 #if(CXSC_INDEX_CHECK)
1678  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1679 #else
1680  throw();
1681 #endif
1682 
1684  INLINE cmatrix_subv operator [](const int &i) const
1685 #if(CXSC_INDEX_CHECK)
1686  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1687 #else
1688  throw();
1689 #endif
1690  INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const
1692 #if(CXSC_INDEX_CHECK)
1693  throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT);
1694 #else
1695  throw();
1696 #endif
1697  INLINE cmatrix_slice &operator ()() throw() { return *this; }
1700  INLINE cmatrix_slice operator ()(const int &m, const int &n)
1701 #if(CXSC_INDEX_CHECK)
1702  throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG);
1703 #else
1704  throw();
1705 #endif
1706  INLINE cmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1708 #if(CXSC_INDEX_CHECK)
1709  throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG);
1710 #else
1711  throw();
1712 #endif
1713 
1714  //Sparse
1716  INLINE cmatrix_slice &operator +=(const srmatrix &m);
1718  INLINE cmatrix_slice &operator +=(const srmatrix_slice &ms);
1720  INLINE cmatrix_slice &operator +=(const scmatrix &m);
1722  INLINE cmatrix_slice &operator +=(const scmatrix_slice &ms);
1724  INLINE cmatrix_slice &operator -=(const srmatrix &m);
1726  INLINE cmatrix_slice &operator -=(const srmatrix_slice &ms);
1728  INLINE cmatrix_slice &operator -=(const scmatrix &m);
1730  INLINE cmatrix_slice &operator -=(const scmatrix_slice &ms);
1732  INLINE cmatrix_slice &operator *=(const srmatrix &m);
1734  INLINE cmatrix_slice &operator *=(const srmatrix_slice &ms);
1736  INLINE cmatrix_slice &operator *=(const scmatrix &m);
1738  INLINE cmatrix_slice &operator *=(const scmatrix_slice &ms);
1739 
1741  INLINE cmatrix_slice &operator *=(const cmatrix &m)
1742 #if(CXSC_INDEX_CHECK)
1743  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1744 #else
1745  throw();
1746 #endif
1747  INLINE cmatrix_slice &operator *=(const rmatrix &m)
1749 #if(CXSC_INDEX_CHECK)
1750  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1751 #else
1752  throw();
1753 #endif
1754  INLINE cmatrix_slice &operator *=(const cmatrix_slice &ms2)
1756 #if(CXSC_INDEX_CHECK)
1757  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1758 #else
1759  throw();
1760 #endif
1761  INLINE cmatrix_slice &operator *=(const rmatrix_slice &ms2)
1763 #if(CXSC_INDEX_CHECK)
1764  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1765 #else
1766  throw();
1767 #endif
1768  INLINE cmatrix_slice &operator +=(const cmatrix &m1)
1770 #if(CXSC_INDEX_CHECK)
1771  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1772 #else
1773  throw();
1774 #endif
1775  INLINE cmatrix_slice &operator +=(const rmatrix &m1)
1777 #if(CXSC_INDEX_CHECK)
1778  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1779 #else
1780  throw();
1781 #endif
1782  INLINE cmatrix_slice &operator +=(const cmatrix_slice &ms2)
1784 #if(CXSC_INDEX_CHECK)
1785  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1786 #else
1787  throw();
1788 #endif
1789  INLINE cmatrix_slice &operator +=(const rmatrix_slice &ms2)
1791 #if(CXSC_INDEX_CHECK)
1792  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1793 #else
1794  throw();
1795 #endif
1796  INLINE cmatrix_slice &operator -=(const cmatrix &m1)
1798 #if(CXSC_INDEX_CHECK)
1799  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1800 #else
1801  throw();
1802 #endif
1803  INLINE cmatrix_slice &operator -=(const rmatrix &m1)
1805 #if(CXSC_INDEX_CHECK)
1806  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1807 #else
1808  throw();
1809 #endif
1810  INLINE cmatrix_slice &operator -=(const cmatrix_slice &ms2)
1812 #if(CXSC_INDEX_CHECK)
1813  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1814 #else
1815  throw();
1816 #endif
1817  INLINE cmatrix_slice &operator -=(const rmatrix_slice &ms2)
1819 #if(CXSC_INDEX_CHECK)
1820  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1821 #else
1822  throw();
1823 #endif
1824  INLINE cmatrix_slice &operator |=(const cmatrix &m1)
1826 #if(CXSC_INDEX_CHECK)
1827  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1828 #else
1829  throw();
1830 #endif
1831  INLINE cmatrix_slice &operator |=(const rmatrix &m1)
1833 #if(CXSC_INDEX_CHECK)
1834  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1835 #else
1836  throw();
1837 #endif
1838  INLINE cmatrix_slice &operator |=(const cmatrix_slice &ms2)
1840 #if(CXSC_INDEX_CHECK)
1841  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1842 #else
1843  throw();
1844 #endif
1845  INLINE cmatrix_slice &operator |=(const rmatrix_slice &ms2)
1847 #if(CXSC_INDEX_CHECK)
1848  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1849 #else
1850  throw();
1851 #endif
1852  INLINE cmatrix_slice &operator *=(const complex &c) throw();
1855  INLINE cmatrix_slice &operator *=(const real &c) throw();
1857  INLINE cmatrix_slice &operator /=(const complex &c) throw();
1859  INLINE cmatrix_slice &operator /=(const real &c) throw();
1860  INLINE operator void*() throw();
1861 //#else
1862 //#endif
1863 };
1864 
1865 //================================================================
1866 //====================== Subvector Functions =====================
1867 
1868 //=======================Vector / Scalar =========================
1869 
1871  INLINE cvector operator /(const cmatrix_subv &rv, const complex &s) throw();
1873  INLINE cvector operator *(const cmatrix_subv &rv, const complex &s) throw();
1875  INLINE cvector operator *(const complex &s, const cmatrix_subv &rv) throw();
1876 
1877 //======================== Vector / Vector ========================
1878 
1880  INLINE rvector abs(const cmatrix_subv &mv) throw();
1882  INLINE rvector Im(const cmatrix_subv &mv) throw();
1884  INLINE rvector Re(const cmatrix_subv &mv) throw();
1886  INLINE cmatrix_subv &SetIm(cmatrix_subv &mv,const rvector &rv)
1887 #if(CXSC_INDEX_CHECK)
1888  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1889 #else
1890  throw();
1891 #endif
1892  INLINE cmatrix_subv &SetRe(cmatrix_subv &mv,const rvector &rv)
1894 #if(CXSC_INDEX_CHECK)
1895  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1896 #else
1897  throw();
1898 #endif
1899  INLINE cmatrix_subv &SetRe(cmatrix_subv &iv,const real &r) throw();
1902  INLINE cmatrix_subv &SetIm(cmatrix_subv &iv,const real &r) throw();
1903 
1904 
1906  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1907 #if(CXSC_INDEX_CHECK)
1908  throw(OP_WITH_WRONG_DIM);
1909 #else
1910  throw();
1911 #endif
1912 
1914  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2);
1915 
1917  void accumulate(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1918 #if(CXSC_INDEX_CHECK)
1919  throw(OP_WITH_WRONG_DIM);
1920 #else
1921  throw();
1922 #endif
1923 
1925  void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2);
1926 
1928  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1929 #if(CXSC_INDEX_CHECK)
1930  throw(OP_WITH_WRONG_DIM);
1931 #else
1932  throw();
1933 #endif
1934 
1936  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2);
1937 
1939  void accumulate(cdotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2)
1940 #if(CXSC_INDEX_CHECK)
1941  throw(OP_WITH_WRONG_DIM);
1942 #else
1943  throw();
1944 #endif
1945 
1947  void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2);
1948 
1950  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2)
1951 #if(CXSC_INDEX_CHECK)
1952  throw(OP_WITH_WRONG_DIM);
1953 #else
1954  throw();
1955 #endif
1956 
1958  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2);
1959 
1960 
1962  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1963 #if(CXSC_INDEX_CHECK)
1964  throw(OP_WITH_WRONG_DIM);
1965 #else
1966  throw();
1967 #endif
1968  void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1970 #if(CXSC_INDEX_CHECK)
1971  throw(OP_WITH_WRONG_DIM);
1972 #else
1973  throw();
1974 #endif
1975  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1977 #if(CXSC_INDEX_CHECK)
1978  throw(OP_WITH_WRONG_DIM);
1979 #else
1980  throw();
1981 #endif
1982  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2)
1984 #if(CXSC_INDEX_CHECK)
1985  throw(OP_WITH_WRONG_DIM);
1986 #else
1987  throw();
1988 #endif
1989  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2)
1991 #if(CXSC_INDEX_CHECK)
1992  throw(OP_WITH_WRONG_DIM);
1993 #else
1994  throw();
1995 #endif
1996 
1998  INLINE complex operator *(const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1999 #if(CXSC_INDEX_CHECK)
2000  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2001 #else
2002  throw();
2003 #endif
2004  INLINE complex operator *(const cvector & rv1, const cmatrix_subv &rv2)
2006 #if(CXSC_INDEX_CHECK)
2007  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2008 #else
2009  throw();
2010 #endif
2011  INLINE complex operator *(const cmatrix_subv &rv1,const cvector &rv2)
2013 #if(CXSC_INDEX_CHECK)
2014  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2015 #else
2016  throw();
2017 #endif
2018  INLINE complex operator *(const cvector_slice &sl,const cmatrix_subv &sv)
2020 #if(CXSC_INDEX_CHECK)
2021  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2022 #else
2023  throw();
2024 #endif
2025  INLINE complex operator *(const cmatrix_subv &mv,const cvector_slice &vs)
2027 #if(CXSC_INDEX_CHECK)
2028  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2029 #else
2030  throw();
2031 #endif
2032 
2034  INLINE cvector operator +(const cmatrix_subv & rv1, const cmatrix_subv &rv2)
2035 #if(CXSC_INDEX_CHECK)
2036  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2037 #else
2038  throw();
2039 #endif
2040  INLINE cvector operator +(const cmatrix_subv &rv1,const cvector &rv2)
2042 #if(CXSC_INDEX_CHECK)
2043  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2044 #else
2045  throw();
2046 #endif
2047  INLINE cvector operator +(const cvector & rv1, const cmatrix_subv &rv2)
2049 #if(CXSC_INDEX_CHECK)
2050  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2051 #else
2052  throw();
2053 #endif
2054  INLINE cvector operator +(const cvector_slice &sl,const cmatrix_subv &mv)
2056 #if(CXSC_INDEX_CHECK)
2057  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2058 #else
2059  throw();
2060 #endif
2061  INLINE cvector operator +(const cmatrix_subv &mv,const cvector_slice &sl)
2063 #if(CXSC_INDEX_CHECK)
2064  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2065 #else
2066  throw();
2067 #endif
2068 
2070  INLINE cvector operator -(const cmatrix_subv & rv1, const cmatrix_subv &rv2)
2071 #if(CXSC_INDEX_CHECK)
2072  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2073 #else
2074  throw();
2075 #endif
2076  INLINE cvector operator -(const cvector & rv1, const cmatrix_subv &rv2)
2078 #if(CXSC_INDEX_CHECK)
2079  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2080 #else
2081  throw();
2082 #endif
2083  INLINE cvector operator -(const cmatrix_subv &rv1,const cvector &rv2)
2085 #if(CXSC_INDEX_CHECK)
2086  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2087 #else
2088  throw();
2089 #endif
2090  INLINE cvector operator -(const cvector_slice &sl,const cmatrix_subv &mv)
2092 #if(CXSC_INDEX_CHECK)
2093  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2094 #else
2095  throw();
2096 #endif
2097  INLINE cvector operator -(const cmatrix_subv &mv,const cvector_slice &sl)
2099 #if(CXSC_INDEX_CHECK)
2100  throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM);
2101 #else
2102  throw();
2103 #endif
2104 
2105 //====================================================================
2106 //===================== Matrix Functions =============================
2107 
2109  INLINE cmatrix _cmatrix(const cmatrix &rm) throw();
2111  INLINE cmatrix _cmatrix(const cvector &v) throw();
2113  INLINE cmatrix _cmatrix(const cvector_slice &v) throw();
2115  INLINE cmatrix _cmatrix(const complex &r) throw();
2116 
2118  INLINE int Lb(const cmatrix &rm, const int &i)
2119 #if(CXSC_INDEX_CHECK)
2120  throw(ERROR_CMATRIX_WRONG_ROW_OR_COL);
2121 #else
2122  throw();
2123 #endif
2124  INLINE int Ub(const cmatrix &rm, const int &i)
2126 #if(CXSC_INDEX_CHECK)
2127  throw(ERROR_CMATRIX_WRONG_ROW_OR_COL);
2128 #else
2129  throw();
2130 #endif
2131  INLINE int Lb(const cmatrix_slice &rm, const int &i)
2133 #if(CXSC_INDEX_CHECK)
2134  throw(ERROR_CMATRIX_WRONG_ROW_OR_COL);
2135 #else
2136  throw();
2137 #endif
2138  INLINE int Ub(const cmatrix_slice &rm, const int &i)
2140 #if(CXSC_INDEX_CHECK)
2141  throw(ERROR_CMATRIX_WRONG_ROW_OR_COL);
2142 #else
2143  throw();
2144 #endif
2145  INLINE cmatrix &SetLb(cmatrix &m, const int &i,const int &j)
2147 #if(CXSC_INDEX_CHECK)
2148  throw(ERROR_CMATRIX_WRONG_ROW_OR_COL);
2149 #else
2150  throw();
2151 #endif
2152  INLINE cmatrix &SetUb(cmatrix &m, const int &i,const int &j)
2154 #if(CXSC_INDEX_CHECK)
2155  throw(ERROR_CMATRIX_WRONG_ROW_OR_COL);
2156 #else
2157  throw();
2158 #endif
2159  INLINE void Resize(cmatrix &A) throw();
2162  INLINE void Resize(cmatrix &A,const int &m, const int &n)
2163 #if(CXSC_INDEX_CHECK)
2164  throw(ERROR_CMATRIX_WRONG_BOUNDARIES);
2165 #else
2166  throw();
2167 #endif
2168  INLINE void Resize(cmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2170 #if(CXSC_INDEX_CHECK)
2171  throw(ERROR_CMATRIX_WRONG_BOUNDARIES);
2172 #else
2173  throw();
2174 #endif
2175 
2177  INLINE rmatrix abs(const cmatrix &m) throw();
2179  INLINE rmatrix abs(const cmatrix_slice &ms) throw();
2181  INLINE rmatrix Im(const cmatrix &m) throw();
2183  INLINE rmatrix Re(const cmatrix &m) throw();
2185  INLINE rmatrix Im(const cmatrix_slice &m) throw();
2187  INLINE rmatrix Re(const cmatrix_slice &m) throw();
2189  INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix &rm)
2190 #if(CXSC_INDEX_CHECK)
2191  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2192 #else
2193  throw();
2194 #endif
2195  INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix &rm)
2197 #if(CXSC_INDEX_CHECK)
2198  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2199 #else
2200  throw();
2201 #endif
2202  INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix_slice &rm)
2204 #if(CXSC_INDEX_CHECK)
2205  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2206 #else
2207  throw();
2208 #endif
2209  INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix_slice &rm)
2211 #if(CXSC_INDEX_CHECK)
2212  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2213 #else
2214  throw();
2215 #endif
2216  INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix &rm)
2218 #if(CXSC_INDEX_CHECK)
2219  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2220 #else
2221  throw();
2222 #endif
2223  INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix &rm)
2225 #if(CXSC_INDEX_CHECK)
2226  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2227 #else
2228  throw();
2229 #endif
2230  INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix_slice &rm)
2232 #if(CXSC_INDEX_CHECK)
2233  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2234 #else
2235  throw();
2236 #endif
2237  INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix_slice &rm)
2239 #if(CXSC_INDEX_CHECK)
2240  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2241 #else
2242  throw();
2243 #endif
2244 
2245 //===================== Matrix / Scalar ===============================
2246 
2248  INLINE cmatrix operator *(const complex &c, const cmatrix &m) throw();
2250  INLINE cmatrix operator *(const complex &c, const cmatrix_slice &ms) throw();
2252  INLINE cmatrix operator *(const cmatrix &m,const complex &c) throw();
2254  INLINE cmatrix operator *(const cmatrix_slice &ms,const complex &c) throw();
2256  INLINE cmatrix &operator *=(cmatrix &m,const complex &c) throw();
2258  INLINE cmatrix operator /(const cmatrix &m,const complex &c) throw();
2260  INLINE cmatrix operator /(const cmatrix_slice &ms, const complex &c) throw();
2262  INLINE cmatrix &operator /=(cmatrix &m,const complex &c) throw();
2263 
2264 //------------ real - cmatrix -----------------------------------------------
2265 
2267  INLINE cmatrix operator *(const real &c, const cmatrix &m) throw();
2269  INLINE cmatrix operator *(const real &c, const cmatrix_slice &ms) throw();
2271  INLINE cmatrix operator *(const cmatrix &m,const real &c) throw();
2273  INLINE cmatrix operator *(const cmatrix_slice &ms,const real &c) throw();
2275  INLINE cmatrix &operator *=(cmatrix &m,const real &c) throw();
2277  INLINE cmatrix operator /(const cmatrix &m,const real &c) throw();
2279  INLINE cmatrix operator /(const cmatrix_slice &ms, const real &c) throw();
2281  INLINE cmatrix &operator /=(cmatrix &m,const real &c) throw();
2282 //----------------- rmatrix - complex ----------------
2283 
2285  INLINE cmatrix operator *(const complex &c, const rmatrix &m) throw();
2287  INLINE cmatrix operator *(const complex &c, const rmatrix_slice &ms) throw();
2289  INLINE cmatrix operator *(const rmatrix &m,const complex &c) throw();
2291  INLINE cmatrix operator *(const rmatrix_slice &ms,const complex &c) throw();
2293  INLINE cmatrix operator /(const rmatrix &m,const complex &c) throw();
2295  INLINE cmatrix operator /(const rmatrix_slice &ms, const complex &c) throw();
2296 
2297 
2298 //============================ Matrix / Vector ===================================
2299 
2300 
2302  INLINE cvector operator *(const cmatrix &m,const cvector &v)
2303 #if(CXSC_INDEX_CHECK)
2304  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2305 #else
2306  throw();
2307 #endif
2308  INLINE cvector operator *(const cmatrix_slice &ms,const cvector &v)
2310 #if(CXSC_INDEX_CHECK)
2311  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2312 #else
2313  throw();
2314 #endif
2315  INLINE cvector operator *(const cvector &v,const cmatrix &m)
2317 #if(CXSC_INDEX_CHECK)
2318  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2319 #else
2320  throw();
2321 #endif
2322  INLINE cvector operator *(const cvector &v,const cmatrix_slice &ms)
2324 #if(CXSC_INDEX_CHECK)
2325  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2326 #else
2327  throw();
2328 #endif
2329  INLINE cvector &operator *=(cvector &v,const cmatrix &m)
2331 #if(CXSC_INDEX_CHECK)
2332  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2333 #else
2334  throw();
2335 #endif
2336  INLINE cvector &operator *=(cvector &v,const cmatrix_slice &ms)
2338 #if(CXSC_INDEX_CHECK)
2339  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2340 #else
2341  throw();
2342 #endif
2343 
2345  INLINE cvector operator *(const cvector_slice &v,const cmatrix &m)
2346 #if(CXSC_INDEX_CHECK)
2347  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2348 #else
2349  throw();
2350 #endif
2351  INLINE cvector operator *(const cvector_slice &v,const cmatrix_slice &m)
2353 #if(CXSC_INDEX_CHECK)
2354  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2355 #else
2356  throw();
2357 #endif
2358 
2359 //----------------- real -------------------------------------
2360 
2362  INLINE cvector operator *(const rvector &v,const cmatrix &m)
2363 #if(CXSC_INDEX_CHECK)
2364  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2365 #else
2366  throw();
2367 #endif
2368  INLINE cvector operator *(const rvector &v,const cmatrix_slice &ms)
2370 #if(CXSC_INDEX_CHECK)
2371  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2372 #else
2373  throw();
2374 #endif
2375  INLINE cvector operator *(const rvector_slice &v,const cmatrix &m)
2377 #if(CXSC_INDEX_CHECK)
2378  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2379 #else
2380  throw();
2381 #endif
2382 
2384  INLINE cvector operator *(const cmatrix &m,const rvector &v)
2385 #if(CXSC_INDEX_CHECK)
2386  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2387 #else
2388  throw();
2389 #endif
2390  INLINE cvector operator *(const cmatrix_slice &ms,const rvector &v)
2392 #if(CXSC_INDEX_CHECK)
2393  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2394 #else
2395  throw();
2396 #endif
2397 
2398 
2399 //================ Matrix / Matrix ============================
2400 
2402  INLINE const cmatrix &operator +(const cmatrix &m1) throw();
2404  INLINE cmatrix operator +(const cmatrix_slice &ms) throw();
2406  INLINE cmatrix operator +(const cmatrix &m1,const cmatrix &m2)
2407 #if(CXSC_INDEX_CHECK)
2408  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2409 #else
2410  throw();
2411 #endif
2412  INLINE cmatrix operator +(const cmatrix &m,const cmatrix_slice &ms)
2414 #if(CXSC_INDEX_CHECK)
2415  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2416 #else
2417  throw();
2418 #endif
2419  INLINE cmatrix operator +(const cmatrix_slice &ms,const cmatrix &m)
2421 #if(CXSC_INDEX_CHECK)
2422  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2423 #else
2424  throw();
2425 #endif
2426  INLINE cmatrix operator +(const cmatrix_slice &m1,const cmatrix_slice &m2)
2428 #if(CXSC_INDEX_CHECK)
2429  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2430 #else
2431  throw();
2432 #endif
2433  INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix &m2)
2435 #if(CXSC_INDEX_CHECK)
2436  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2437 #else
2438  throw();
2439 #endif
2440  INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix_slice &ms)
2442 #if(CXSC_INDEX_CHECK)
2443  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2444 #else
2445  throw();
2446 #endif
2447 
2449  INLINE cmatrix operator -(const cmatrix &m) throw();
2451  INLINE cmatrix operator -(const cmatrix_slice &ms) throw();
2453  INLINE cmatrix operator -(const cmatrix &m1,const cmatrix &m2)
2454 #if(CXSC_INDEX_CHECK)
2455  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2456 #else
2457  throw();
2458 #endif
2459  INLINE cmatrix operator -(const cmatrix &m,const cmatrix_slice &ms)
2461 #if(CXSC_INDEX_CHECK)
2462  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2463 #else
2464  throw();
2465 #endif
2466  INLINE cmatrix operator -(const cmatrix_slice &ms,const cmatrix &m)
2468 #if(CXSC_INDEX_CHECK)
2469  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2470 #else
2471  throw();
2472 #endif
2473  INLINE cmatrix operator -(const cmatrix_slice &ms1,const cmatrix_slice &ms2)
2475 #if(CXSC_INDEX_CHECK)
2476  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2477 #else
2478  throw();
2479 #endif
2480  INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix &m2)
2482 #if(CXSC_INDEX_CHECK)
2483  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2484 #else
2485  throw();
2486 #endif
2487  INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix_slice &ms)
2489 #if(CXSC_INDEX_CHECK)
2490  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2491 #else
2492  throw();
2493 #endif
2494 
2496  INLINE cmatrix operator *(const cmatrix &m1, const cmatrix &m2)
2497 #if(CXSC_INDEX_CHECK)
2498  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2499 #else
2500  throw();
2501 #endif
2502  INLINE cmatrix operator *(const cmatrix &m1, const cmatrix_slice &ms)
2504 #if(CXSC_INDEX_CHECK)
2505  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2506 #else
2507  throw();
2508 #endif
2509  INLINE cmatrix operator *(const cmatrix_slice &ms, const cmatrix &m1)
2511 #if(CXSC_INDEX_CHECK)
2512  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2513 #else
2514  throw();
2515 #endif
2516  INLINE cmatrix operator *(const cmatrix_slice &ms1, const cmatrix_slice &ms2)
2518 #if(CXSC_INDEX_CHECK)
2519  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2520 #else
2521  throw();
2522 #endif
2523  INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix &m2)
2525 #if(CXSC_INDEX_CHECK)
2526  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2527 #else
2528  throw();
2529 #endif
2530  INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix_slice &ms)
2532 #if(CXSC_INDEX_CHECK)
2533  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2534 #else
2535  throw();
2536 #endif
2537 
2538 
2539  //---------- rmatrix-cmatrix ------------------
2541  INLINE cmatrix operator +(const rmatrix &m1,const cmatrix &m2)
2542 #if(CXSC_INDEX_CHECK)
2543  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2544 #else
2545  throw();
2546 #endif
2547  INLINE cmatrix operator +(const cmatrix &m1,const rmatrix &m2)
2549 #if(CXSC_INDEX_CHECK)
2550  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2551 #else
2552  throw();
2553 #endif
2554  INLINE cmatrix operator +(const rmatrix &m,const cmatrix_slice &ms)
2556 #if(CXSC_INDEX_CHECK)
2557  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2558 #else
2559  throw();
2560 #endif
2561  INLINE cmatrix operator +(const cmatrix &m,const rmatrix_slice &ms)
2563 #if(CXSC_INDEX_CHECK)
2564  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2565 #else
2566  throw();
2567 #endif
2568  INLINE cmatrix operator +(const rmatrix_slice &ms,const cmatrix &m)
2570 #if(CXSC_INDEX_CHECK)
2571  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2572 #else
2573  throw();
2574 #endif
2575  INLINE cmatrix operator +(const cmatrix_slice &ms,const rmatrix &m)
2577 #if(CXSC_INDEX_CHECK)
2578  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2579 #else
2580  throw();
2581 #endif
2582  INLINE cmatrix operator +(const rmatrix_slice &m1,const cmatrix_slice &m2)
2584 #if(CXSC_INDEX_CHECK)
2585  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2586 #else
2587  throw();
2588 #endif
2589  INLINE cmatrix operator +(const cmatrix_slice &m1,const rmatrix_slice &m2)
2591 #if(CXSC_INDEX_CHECK)
2592  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2593 #else
2594  throw();
2595 #endif
2596  INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix &m2)
2598 #if(CXSC_INDEX_CHECK)
2599  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2600 #else
2601  throw();
2602 #endif
2603  INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix_slice &ms)
2605 #if(CXSC_INDEX_CHECK)
2606  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2607 #else
2608  throw();
2609 #endif
2610 
2612  INLINE cmatrix operator -(const rmatrix &m1,const cmatrix &m2)
2613 #if(CXSC_INDEX_CHECK)
2614  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2615 #else
2616  throw();
2617 #endif
2618  INLINE cmatrix operator -(const cmatrix &m1,const rmatrix &m2)
2620 #if(CXSC_INDEX_CHECK)
2621  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2622 #else
2623  throw();
2624 #endif
2625  INLINE cmatrix operator -(const rmatrix &m,const cmatrix_slice &ms)
2627 #if(CXSC_INDEX_CHECK)
2628  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2629 #else
2630  throw();
2631 #endif
2632  INLINE cmatrix operator -(const cmatrix &m,const rmatrix_slice &ms)
2634 #if(CXSC_INDEX_CHECK)
2635  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2636 #else
2637  throw();
2638 #endif
2639  INLINE cmatrix operator -(const rmatrix_slice &ms,const cmatrix &m)
2641 #if(CXSC_INDEX_CHECK)
2642  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2643 #else
2644  throw();
2645 #endif
2646  INLINE cmatrix operator -(const cmatrix_slice &ms,const rmatrix &m)
2648 #if(CXSC_INDEX_CHECK)
2649  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2650 #else
2651  throw();
2652 #endif
2653  INLINE cmatrix operator -(const rmatrix_slice &ms1,const cmatrix_slice &ms2)
2655 #if(CXSC_INDEX_CHECK)
2656  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2657 #else
2658  throw();
2659 #endif
2660  INLINE cmatrix operator -(const cmatrix_slice &ms1,const rmatrix_slice &ms2)
2662 #if(CXSC_INDEX_CHECK)
2663  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2664 #else
2665  throw();
2666 #endif
2667  INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix &m2)
2669 #if(CXSC_INDEX_CHECK)
2670  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2671 #else
2672  throw();
2673 #endif
2674  INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix_slice &ms)
2676 #if(CXSC_INDEX_CHECK)
2677  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2678 #else
2679  throw();
2680 #endif
2681 
2683  INLINE cmatrix operator *(const rmatrix &m1, const cmatrix &m2)
2684 #if(CXSC_INDEX_CHECK)
2685  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2686 #else
2687  throw();
2688 #endif
2689  INLINE cmatrix operator *(const cmatrix &m1, const rmatrix &m2)
2691 #if(CXSC_INDEX_CHECK)
2692  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2693 #else
2694  throw();
2695 #endif
2696  INLINE cmatrix operator *(const rmatrix &m1, const cmatrix_slice &ms)
2698 #if(CXSC_INDEX_CHECK)
2699  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2700 #else
2701  throw();
2702 #endif
2703  INLINE cmatrix operator *(const cmatrix &m1, const rmatrix_slice &ms)
2705 #if(CXSC_INDEX_CHECK)
2706  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2707 #else
2708  throw();
2709 #endif
2710  INLINE cmatrix operator *(const rmatrix_slice &ms, const cmatrix &m1)
2712 #if(CXSC_INDEX_CHECK)
2713  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2714 #else
2715  throw();
2716 #endif
2717  INLINE cmatrix operator *(const cmatrix_slice &ms, const rmatrix &m1)
2719 #if(CXSC_INDEX_CHECK)
2720  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2721 #else
2722  throw();
2723 #endif
2724  INLINE cmatrix operator *(const rmatrix_slice &ms1, const cmatrix_slice &ms2)
2726 #if(CXSC_INDEX_CHECK)
2727  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2728 #else
2729  throw();
2730 #endif
2731  INLINE cmatrix operator *(const cmatrix_slice &ms1, const rmatrix_slice &ms2)
2733 #if(CXSC_INDEX_CHECK)
2734  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2735 #else
2736  throw();
2737 #endif
2738  INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix &m2)
2740 #if(CXSC_INDEX_CHECK)
2741  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2742 #else
2743  throw();
2744 #endif
2745  INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix_slice &ms)
2747 #if(CXSC_INDEX_CHECK)
2748  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
2749 #else
2750  throw();
2751 #endif
2752 
2753 
2754 //============== Compare Operator ==========================
2755 
2756 //-------------- Matrix - Matrix -------------------------
2757 
2759  INLINE bool operator ==(const cmatrix &m1,const cmatrix &m2) throw();
2761  INLINE bool operator !=(const cmatrix &m1,const cmatrix &m2) throw();
2762 /* INLINE bool operator <(const cmatrix &m1,const cmatrix &m2) throw();
2763  INLINE bool operator <=(const cmatrix &m1,const cmatrix &m2) throw();
2764  INLINE bool operator >(const cmatrix &m1,const cmatrix &m2) throw();
2765  INLINE bool operator >=(const cmatrix &m1,const cmatrix &m2) throw();*/
2767  INLINE bool operator ==(const cmatrix &m1,const cmatrix_slice &ms) throw();
2769  INLINE bool operator !=(const cmatrix &m1,const cmatrix_slice &ms) throw();
2770 /* INLINE bool operator <(const cmatrix &m1,const cmatrix_slice &ms) throw();
2771  INLINE bool operator <=(const cmatrix &m1,const cmatrix_slice &ms) throw();
2772  INLINE bool operator >(const cmatrix &m1,const cmatrix_slice &ms) throw();
2773  INLINE bool operator >=(const cmatrix &m1,const cmatrix_slice &ms) throw();
2774 */
2775 //---------------- Matrix - Matrix_slice ----------------------
2776 
2778  INLINE bool operator ==(const cmatrix_slice &m1,const cmatrix_slice &m2) throw();
2780  INLINE bool operator !=(const cmatrix_slice &m1,const cmatrix_slice &m2) throw();
2781 /* INLINE bool operator <(const cmatrix_slice &m1,const cmatrix_slice &m2) throw();
2782  INLINE bool operator <=(const cmatrix_slice &m1,const cmatrix_slice &m2) throw();
2783  INLINE bool operator >(const cmatrix_slice &m1,const cmatrix_slice &m2) throw();
2784  INLINE bool operator >=(const cmatrix_slice &m1,const cmatrix_slice &m2) throw();
2785 */
2786 //=================== Not Operator =============================
2787 
2789  INLINE bool operator !(const cmatrix &ms) throw();
2791  INLINE bool operator !(const cmatrix_slice &ms) throw();
2792 
2793 //======================== Input / Output ========================
2794 
2796  INLINE std::ostream &operator <<(std::ostream &s,const cmatrix &r) throw();
2798  INLINE std::ostream &operator <<(std::ostream &s,const cmatrix_slice &r) throw();
2800  INLINE std::istream &operator >>(std::istream &s,cmatrix &r) throw();
2802  INLINE std::istream &operator >>(std::istream &s,cmatrix_slice &r) throw();
2803 
2805  INLINE int RowLen ( const cmatrix& );
2807  INLINE int ColLen ( const cmatrix& );
2809  INLINE int RowLen ( const cmatrix_slice& );
2811  INLINE int ColLen ( const cmatrix_slice& );
2813  rmatrix CompMat ( const cmatrix& );
2815  cmatrix Id ( cmatrix& );
2817  cmatrix transp ( const cmatrix& );
2819  void DoubleSize ( cmatrix& );
2820 
2821 } // namespace cxsc
2822 
2823 
2824 #ifdef _CXSC_INCL_INL
2825 #include "matrix.inl"
2826 #include "cmatrix.inl"
2827 #endif
2828 
2829 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
2830 # ifdef _CXSC_INCL_INL
2831 # include "civeccmat.inl"
2832 # else
2833 # include "civeccmat.hpp"
2834 # endif
2835 #endif
2836 
2837 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
2838 # ifdef _CXSC_INCL_INL
2839 # include "iveccmat.inl"
2840 # else
2841 # include "iveccmat.hpp"
2842 # endif
2843 #endif
2844 
2845 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
2846 # ifdef _CXSC_INCL_INL
2847 # include "cmatimat.inl"
2848 # else
2849 # include "cmatimat.hpp"
2850 # endif
2851 #endif
2852 
2853 
2854 #ifdef CXSC_USE_BLAS
2855 #define _CXSC_BLAS_CMATRIX
2856 #include "cxsc_blas.inl"
2857 #endif
2858 
2859 #endif
cxsc::cmatrix_slice::cmatrix_slice
cmatrix_slice(cmatrix &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class cmatrix_slice.
Definition: cmatrix.hpp:1579
cxsc::cmatrix::operator+=
cmatrix & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1728
cxsc::cmatrix_subv::Col
friend cmatrix_subv Col(cmatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: cmatrix.inl:162
cxsc::cmatrix_slice::operator=
cmatrix_slice & operator=(const cmatrix &m)
Implementation of standard assigning operator.
Definition: cmatrix.inl:450
cxsc::Row
cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
cxsc::srvector
A sparse real vector.
Definition: srvector.hpp:58
cxsc::cmatrix_subv::cmatrix_subv
cmatrix_subv(const cmatrix_subv &v)
Constructor of class cmatrix_subv.
Definition: cmatrix.hpp:261
cxsc::scvector
A sparse complex vector.
Definition: scvector.hpp:58
cxsc::cmatrix_slice::operator()
cmatrix_slice & operator()()
Operator for accessing the whole matrix.
Definition: cmatrix.hpp:1698
cxsc::CompMat
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
Definition: cimatrix.cpp:45
cxsc::srmatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
cxsc::cmatrix_subv::operator+=
cmatrix_subv & operator+=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scmatrix.hpp:4326
cxsc::cmatrix
The Data Type cmatrix.
Definition: cmatrix.hpp:514
cxsc::cmatrix::cmatrix
cmatrix()
Constructor of class cmatrix.
Definition: cmatrix.inl:31
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::RowLen
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cxsc::scmatrix_slice
A slice of a sparse complex matrix.
Definition: scmatrix.hpp:1956
cxsc::srmatrix
A sparse real matrix.
Definition: srmatrix.hpp:77
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:52
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::cvector
The Data Type cvector.
Definition: cvector.hpp:58
cxsc::cmatrix_slice::operator|=
cmatrix_slice & operator|=(const cmatrix &m1)
Allocates the convex hull of the arguments to the first argument.
cxsc::srvector_slice
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
cxsc::ColLen
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cxsc::cmatrix_subv::Row
friend cmatrix_subv Row(cmatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: cmatrix.inl:151
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::cmatrix_slice::operator*=
cmatrix_slice & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1768
cxsc::cmatrix_subv::operator*=
cmatrix_subv & operator*=(const complex &c)
Implementation of multiplication and allocation operation.
Definition: cmatrix.inl:512
cxsc::cvector::cvector
cvector()
Constructor of class cvector.
Definition: cvector.inl:31
cxsc::scmatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
cxsc::scmatrix
A sparse complex matrix.
Definition: scmatrix.hpp:69
cxsc::cmatrix_slice
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1203
cxsc::Col
cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::accumulate_approx
void accumulate_approx(cdotprecision &dp, const cmatrix_subv &rv1, const cmatrix_subv &rv2)
The accurate scalar product of the last two arguments added to the value of the first argument (witho...
Definition: cmatrix.cpp:99
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::cmatrix_slice::cmatrix_slice
cmatrix_slice(const cmatrix_slice &ms)
Constructor of class cmatrix_slice.
Definition: cmatrix.hpp:1584
cxsc::cmatrix_subv::VecLen
friend int VecLen(const cmatrix_subv &rv)
Returns the size of the vector.
Definition: cmatrix.hpp:270
cxsc::cmatrix::operator()
cmatrix & operator()()
Operator for accessing the whole matrix.
Definition: cmatrix.hpp:1175
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::cmatrix_slice::operator-=
cmatrix_slice & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1752
cxsc::cmatrix_slice::operator/=
cmatrix_slice & operator/=(const complex &c)
Implementation of division and allocation operation.
Definition: cmatrix.inl:890
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::cmatrix_subv::operator[]
complex & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: cmatrix.inl:195
cxsc::scvector_slice
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
cxsc::cmatrix_subv::cmatrix_subv
cmatrix_subv(complex *d, const int &l, const int &u, const int &s, const int &st, const int &o)
Constructor of class cmatrix_subv.
Definition: cmatrix.hpp:258
cxsc::cmatrix::operator*=
cmatrix & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1760
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::_cmatrix
cmatrix _cmatrix(const cmatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: cmatrix.inl:708
cxsc::cmatrix_slice::cmatrix_slice
cmatrix_slice(cmatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class cmatrix_slice.
Definition: cmatrix.hpp:1581
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::Lb
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::cmatrix_subv::operator-=
cmatrix_subv & operator-=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scmatrix.hpp:4356
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::DoubleSize
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
cxsc::cmatrix_slice::operator[]
cmatrix_subv operator[](const int &i)
Operator for accessing a single row of the matrix.
Definition: cmatrix.inl:300
cxsc::transp
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition: cimatrix.cpp:74
cxsc::cmatrix_subv::Ub
friend int Ub(const cmatrix_subv &rv)
Returns the upper bound of the vector.
Definition: cmatrix.hpp:268
cxsc::cmatrix_subv::operator=
cmatrix_subv & operator=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scmatrix.hpp:4386
cxsc::cmatrix_subv::operator()
cmatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: cmatrix.hpp:289
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::Ub
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::cmatrix_subv
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:54
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::cmatrix_subv::operator/=
cmatrix_subv & operator/=(const complex &c)
Implementation of division and allocation operation.
Definition: cmatrix.inl:515
cxsc::cmatrix_subv::Lb
friend int Lb(const cmatrix_subv &rv)
Returns the lower bound of the vector.
Definition: cmatrix.hpp:266
cxsc::cmatrix::operator[]
cmatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
Definition: cmatrix.inl:222
cxsc::cmatrix::operator-=
cmatrix & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1744
cxsc::cimatrix
The Data Type cimatrix.
Definition: cimatrix.hpp:908
cxsc::Id
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
cxsc::complex
The Scalar Type complex.
Definition: complex.hpp:50
cxsc::cvector_slice
The Data Type cvector_slice.
Definition: cvector.hpp:845
cxsc::cmatrix::operator=
cmatrix & operator=(const complex &r)
Implementation of standard assigning operator.
Definition: cmatrix.inl:438
cxsc::cmatrix_slice::operator+=
cmatrix_slice & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1736
cxsc::civector
The Data Type civector.
Definition: civector.hpp:57
cxsc::intmatrix
The Data Type intmatrix.
Definition: intmatrix.hpp:314
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:114
cxsc::srmatrix_slice
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360