00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef _CXSC_RMATRIX_HPP_INCLUDED
00027 #define _CXSC_RMATRIX_HPP_INCLUDED
00028
00029 #include "xscclass.hpp"
00030
00031 #include "dot.hpp"
00032 #include "idot.hpp"
00033 #include "cidot.hpp"
00034 #include "rvector.hpp"
00035 #include "except.hpp"
00036 #include "matrix.hpp"
00037
00038 namespace cxsc {
00039
00040 class rmatrix;
00041 class rmatrix_slice;
00042 class srmatrix;
00043 class srmatrix_slice;
00044 class srmatrix_subv;
00045 class srvector;
00046 class srvector_slice;
00047
00048
00050
00053 class rmatrix_subv
00054 {
00055 friend class rvector;
00056 friend class ivector;
00057 friend class cvector;
00058 friend class civector;
00059 friend class l_rvector;
00060 friend class l_ivector;
00061 friend class rmatrix;
00062 friend class rmatrix_slice;
00063 private:
00064 real *dat;
00065 int lb,ub;
00066 int size,start,offset;
00067
00068 public:
00070 friend INLINE rmatrix_subv Row(rmatrix &m,const int &i)
00071 #if(CXSC_INDEX_CHECK)
00072 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00073 #else
00074 throw();
00075 #endif
00076
00077 friend INLINE rmatrix_subv Col(rmatrix &m,const int &i)
00078 #if(CXSC_INDEX_CHECK)
00079 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00080 #else
00081 throw();
00082 #endif
00083
00084 friend INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
00085 #if(CXSC_INDEX_CHECK)
00086 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00087 #else
00088 throw();
00089 #endif
00090
00091 friend INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
00092 #if(CXSC_INDEX_CHECK)
00093 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00094 #else
00095 throw();
00096 #endif
00097
00098
00099
00100
00101 #ifdef _CXSC_FRIEND_TPL
00102
00103 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
00104 #if(CXSC_INDEX_CHECK)
00105 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00106 #else
00107 throw();
00108 #endif
00109 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
00110 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
00111 #if(CXSC_INDEX_CHECK)
00112 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00113 #else
00114 throw();
00115 #endif
00116 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
00117 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
00118 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00119 #if(CXSC_INDEX_CHECK)
00120 throw(OP_WITH_WRONG_DIM);
00121 #else
00122 throw();
00123 #endif
00124
00125 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
00126 #if(CXSC_INDEX_CHECK)
00127 throw(OP_WITH_WRONG_DIM);
00128 #else
00129 throw();
00130 #endif
00131
00132 template <class MV1,class MV2,class S> friend S _mvmvmult(const MV1 & rv1, const MV2 &rv2)
00133 #if(CXSC_INDEX_CHECK)
00134 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00135 #else
00136 throw();
00137 #endif
00138 template <class V,class MV,class S> friend S _vmvmult(const V &rv1, const MV &rv2)
00139 #if(CXSC_INDEX_CHECK)
00140 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00141 #else
00142 throw();
00143 #endif
00144 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
00145 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00146 #if(CXSC_INDEX_CHECK)
00147 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00148 #else
00149 throw();
00150 #endif
00151 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00152 #if(CXSC_INDEX_CHECK)
00153 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00154 #else
00155 throw();
00156 #endif
00157 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
00158 #if(CXSC_INDEX_CHECK)
00159 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00160 #else
00161 throw();
00162 #endif
00163 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
00164 #if(CXSC_INDEX_CHECK)
00165 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00166 #else
00167 throw();
00168 #endif
00169 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
00170 #if(CXSC_INDEX_CHECK)
00171 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00172 #else
00173 throw();
00174 #endif
00175 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
00176 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
00177 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
00178 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
00179 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
00180 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
00181 #if(CXSC_INDEX_CHECK)
00182 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00183 #else
00184 throw();
00185 #endif
00186 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
00187 #if(CXSC_INDEX_CHECK)
00188 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00189 #else
00190 throw();
00191 #endif
00192 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
00193 #if(CXSC_INDEX_CHECK)
00194 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00195 #else
00196 throw();
00197 #endif
00198 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
00199 #if(CXSC_INDEX_CHECK)
00200 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00201 #else
00202 throw();
00203 #endif
00204 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00205 #if(CXSC_INDEX_CHECK)
00206 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00207 #else
00208 throw();
00209 #endif
00210 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
00211 #if(CXSC_INDEX_CHECK)
00212 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00213 #else
00214 throw();
00215 #endif
00216
00217
00218
00219
00220 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
00221 #if(CXSC_INDEX_CHECK)
00222 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00223 #else
00224 throw();
00225 #endif
00226 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
00227 #if(CXSC_INDEX_CHECK)
00228 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00229 #else
00230 throw();
00231 #endif
00232 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
00233 #if(CXSC_INDEX_CHECK)
00234 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00235 #else
00236 throw();
00237 #endif
00238 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
00239 #if(CXSC_INDEX_CHECK)
00240 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00241 #else
00242 throw();
00243 #endif
00244
00245
00246
00247
00248 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
00249 #if(CXSC_INDEX_CHECK)
00250 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00251 #else
00252 throw();
00253 #endif
00254 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
00255 #if(CXSC_INDEX_CHECK)
00256 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00257 #else
00258 throw();
00259 #endif
00260
00261 #endif
00262
00263
00264
00266 explicit INLINE rmatrix_subv (real *d, const int &l, const int &u, const int &s, const int &st, const int &o) throw():dat(d),lb(l),ub(u),size(s),start(st),offset(o) { }
00267 public:
00269 INLINE rmatrix_subv(const rmatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
00270 public:
00271
00272
00273
00274 friend INLINE rvector::rvector(const rmatrix_subv &) throw();
00276 INLINE rmatrix_subv &operator =(const rmatrix_subv &rv) throw();
00278 INLINE rmatrix_subv &operator =(const real &r) throw();
00280 INLINE rmatrix_subv &operator =(const srmatrix_subv &m);
00282 INLINE rmatrix_subv &operator =(const srvector &m);
00284 INLINE rmatrix_subv &operator =(const srvector_slice &m);
00286 INLINE rmatrix_subv &operator =(const rmatrix &m)
00287 #if(CXSC_INDEX_CHECK)
00288 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00289 #else
00290 throw();
00291 #endif
00292
00293 INLINE rmatrix_subv &operator =(const rmatrix_slice &m)
00294 #if(CXSC_INDEX_CHECK)
00295 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00296 #else
00297 throw();
00298 #endif
00299
00300 INLINE rmatrix_subv &operator =(const rvector &v)
00301 #if(CXSC_INDEX_CHECK)
00302 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
00303 #else
00304 throw();
00305 #endif
00306
00307 INLINE rmatrix_subv &operator =(const rvector_slice &v)
00308 #if(CXSC_INDEX_CHECK)
00309 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
00310 #else
00311 throw();
00312 #endif
00313
00314 friend INLINE int Lb(const rmatrix_subv &rv) throw() { return rv.lb; }
00316 friend INLINE int Ub(const rmatrix_subv &rv) throw() { return rv.ub; }
00318 friend INLINE int VecLen(const rmatrix_subv &rv) throw() { return rv.size; }
00319
00321 INLINE real &operator [](const int &i) const
00322 #if(CXSC_INDEX_CHECK)
00323 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
00324 #else
00325 throw();
00326 #endif
00327
00329 INLINE real &operator [](const int &i)
00330 #if(CXSC_INDEX_CHECK)
00331 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
00332 #else
00333 throw();
00334 #endif
00335
00337 INLINE rmatrix_subv &operator ()() throw() { return *this; }
00339 INLINE rmatrix_subv operator ()(const int &i)
00340 #if(CXSC_INDEX_CHECK)
00341 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
00342 #else
00343 throw();
00344 #endif
00345
00346 INLINE rmatrix_subv operator ()(const int &i1,const int &i2)
00347 #if(CXSC_INDEX_CHECK)
00348 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
00349 #else
00350 throw();
00351 #endif
00352
00354 INLINE rmatrix_subv &operator *=(const real &c) throw();
00356 INLINE rmatrix_subv &operator +=(const real &c) throw();
00358 INLINE rmatrix_subv &operator -=(const real &c) throw();
00360 INLINE rmatrix_subv &operator /=(const real &c) throw();
00361
00363 INLINE rmatrix_subv &operator +=(const srvector &rv);
00365 INLINE rmatrix_subv &operator +=(const srvector_slice &rv);
00367 INLINE rmatrix_subv &operator +=(const srmatrix_subv &rv);
00368
00370 INLINE rmatrix_subv &operator -=(const srvector &rv);
00372 INLINE rmatrix_subv &operator -=(const srvector_slice &rv);
00374 INLINE rmatrix_subv &operator -=(const srmatrix_subv &rv);
00375
00377 INLINE rmatrix_subv &operator -=(const rvector &rv)
00378 #if(CXSC_INDEX_CHECK)
00379 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
00380 #else
00381 throw();
00382 #endif
00383
00384 INLINE rmatrix_subv &operator -=(const rvector_slice &rv)
00385 #if(CXSC_INDEX_CHECK)
00386 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
00387 #else
00388 throw();
00389 #endif
00390
00391 INLINE rmatrix_subv &operator +=(const rvector &rv)
00392 #if(CXSC_INDEX_CHECK)
00393 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
00394 #else
00395 throw();
00396 #endif
00397
00398 INLINE rmatrix_subv &operator +=(const rvector_slice &rv)
00399 #if(CXSC_INDEX_CHECK)
00400 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
00401 #else
00402 throw();
00403 #endif
00404
00405
00406
00407 };
00408
00409
00411 INLINE rmatrix_subv Row(rmatrix &m,const int &i)
00412 #if(CXSC_INDEX_CHECK)
00413 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00414 #else
00415 throw();
00416 #endif
00417
00419 INLINE rmatrix_subv Col(rmatrix &m,const int &i)
00420 #if(CXSC_INDEX_CHECK)
00421 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00422 #else
00423 throw();
00424 #endif
00425
00427 INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
00428 #if(CXSC_INDEX_CHECK)
00429 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00430 #else
00431 throw();
00432 #endif
00433
00435 INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
00436 #if(CXSC_INDEX_CHECK)
00437 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
00438 #else
00439 throw();
00440 #endif
00441
00442
00443
00444
00445 class rmatrix_slice;
00446
00448
00470 class rmatrix
00471 {
00472 friend class rmatrix_slice;
00473 friend class rmatrix_subv;
00474 friend class imatrix;
00475 friend class cmatrix;
00476 friend class cimatrix;
00477 friend class l_rmatrix;
00478 friend class l_imatrix;
00479 private:
00480 real *dat;
00481 int lb1,ub1,lb2,ub2,xsize,ysize;
00482
00483 public:
00484 double* to_blas_array() const { return (double*)dat; }
00485
00486 #ifdef _CXSC_FRIEND_TPL
00487
00488 template <class S,class M> friend void _smconstr(S &s,const M &m)
00489 #if(CXSC_INDEX_CHECK)
00490 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
00491 #else
00492 throw();
00493 #endif
00494 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
00495 #if(CXSC_INDEX_CHECK)
00496 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00497 #else
00498 throw();
00499 #endif
00500 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
00501 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
00502 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
00503 #if(CXSC_INDEX_CHECK)
00504 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00505 #else
00506 throw();
00507 #endif
00508 template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
00509 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
00510 #if(CXSC_INDEX_CHECK)
00511 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00512 #else
00513 throw();
00514 #endif
00515 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
00516 template <class M> friend int _mlb(const M &m, const int &i)
00517 #if(CXSC_INDEX_CHECK)
00518 throw(ERROR__WRONG_ROW_OR_COL<M>);
00519 #else
00520 throw();
00521 #endif
00522 template <class M> friend int _mub(const M &m, const int &i)
00523 #if(CXSC_INDEX_CHECK)
00524 throw(ERROR__WRONG_ROW_OR_COL<M>);
00525 #else
00526 throw();
00527 #endif
00528 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
00529 #if(CXSC_INDEX_CHECK)
00530 throw(ERROR__WRONG_ROW_OR_COL<M>);
00531 #else
00532 throw();
00533 #endif
00534 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
00535 #if(CXSC_INDEX_CHECK)
00536 throw(ERROR__WRONG_ROW_OR_COL<M>);
00537 #else
00538 throw();
00539 #endif
00540 template <class M> friend void _mresize(M &A) throw();
00541 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
00542 #if(CXSC_INDEX_CHECK)
00543 throw(ERROR__WRONG_BOUNDARIES<M>);
00544 #else
00545 throw();
00546 #endif
00547 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
00548 #if(CXSC_INDEX_CHECK)
00549 throw(ERROR__WRONG_BOUNDARIES<M>);
00550 #else
00551 throw();
00552 #endif
00553 template <class M,class E> friend E _mabs(const M &m) throw();
00554 template <class MS,class E> friend E _msabs(const MS &ms) throw();
00555
00556 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
00557 #if(CXSC_INDEX_CHECK)
00558 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00559 #else
00560 throw();
00561 #endif
00562 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
00563 #if(CXSC_INDEX_CHECK)
00564 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00565 #else
00566 throw();
00567 #endif
00568 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
00569 #if(CXSC_INDEX_CHECK)
00570 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00571 #else
00572 throw();
00573 #endif
00574 template <class M> friend M _mminus(const M &m) throw();
00575 template <class MS,class E> friend E _msminus(const MS &ms) throw();
00576 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
00577 #if(CXSC_INDEX_CHECK)
00578 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00579 #else
00580 throw();
00581 #endif
00582 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
00583 #if(CXSC_INDEX_CHECK)
00584 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00585 #else
00586 throw();
00587 #endif
00588 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
00589 #if(CXSC_INDEX_CHECK)
00590 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00591 #else
00592 throw();
00593 #endif
00594 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
00595 #if(CXSC_INDEX_CHECK)
00596 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00597 #else
00598 throw();
00599 #endif
00600 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
00601 #if(CXSC_INDEX_CHECK)
00602 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00603 #else
00604 throw();
00605 #endif
00606 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
00607 #if(CXSC_INDEX_CHECK)
00608 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00609 #else
00610 throw();
00611 #endif
00612 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
00613 #if(CXSC_INDEX_CHECK)
00614 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00615 #else
00616 throw();
00617 #endif
00618 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
00619 #if(CXSC_INDEX_CHECK)
00620 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00621 #else
00622 throw();
00623 #endif
00624 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
00625 #if(CXSC_INDEX_CHECK)
00626 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00627 #else
00628 throw();
00629 #endif
00630 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
00631 #if(CXSC_INDEX_CHECK)
00632 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00633 #else
00634 throw();
00635 #endif
00636 template <class M1,class M2,class E> friend E _mmmult(const M1 &m1, const M2 &m2)
00637 #if(CXSC_INDEX_CHECK)
00638 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00639 #else
00640 throw();
00641 #endif
00642 template <class M1,class M2,class S> friend M1 &_mmmultassign(M1 &m1,const M2 &m2)
00643 #if(CXSC_INDEX_CHECK)
00644 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00645 #else
00646 throw();
00647 #endif
00648 template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms)
00649 #if(CXSC_INDEX_CHECK)
00650 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00651 #else
00652 throw();
00653 #endif
00654 template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2)
00655 #if(CXSC_INDEX_CHECK)
00656 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00657 #else
00658 throw();
00659 #endif
00660 template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
00661 #if(CXSC_INDEX_CHECK)
00662 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00663 #else
00664 throw();
00665 #endif
00666 template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2)
00667 #if(CXSC_INDEX_CHECK)
00668 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00669 #else
00670 throw();
00671 #endif
00672 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
00673 #if(CXSC_INDEX_CHECK)
00674 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00675 #else
00676 throw();
00677 #endif
00678 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
00679 #if(CXSC_INDEX_CHECK)
00680 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00681 #else
00682 throw();
00683 #endif
00684
00685 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
00686 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
00687 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
00688 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
00689 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
00690 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
00691
00692 template <class M,class V,class E> friend E _mvmult(const M &m,const V &v)
00693 #if(CXSC_INDEX_CHECK)
00694 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00695 #else
00696 throw();
00697 #endif
00698 template <class V,class M,class E> friend E _vmmult(const V &v,const M &m)
00699 #if(CXSC_INDEX_CHECK)
00700 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00701 #else
00702 throw();
00703 #endif
00704 template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m)
00705 #if(CXSC_INDEX_CHECK)
00706 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00707 #else
00708 throw();
00709 #endif
00710 template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m)
00711 #if(CXSC_INDEX_CHECK)
00712 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00713 #else
00714 throw();
00715 #endif
00716
00717 template <class M> friend void *_mvoid(const M &m) throw();
00718 template <class M> friend bool _mnot(const M &m) throw();
00719 template <class MS> friend void *_msvoid(const MS &ms) throw();
00720 template <class MS> friend bool _msnot(const MS &ms) throw();
00721 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
00722 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
00723 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
00724 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
00725 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
00726 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
00727 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
00728 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
00729 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
00730 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
00731 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
00732 template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
00733
00734
00735
00736 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
00737 #if(CXSC_INDEX_CHECK)
00738 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00739 #else
00740 throw();
00741 #endif
00742
00743 template <class M,class E> friend E _mdiam(const M &m) throw();
00744 template <class M,class E> friend E _mmid(const M &m) throw();
00745 template <class MS,class E> friend E _msdiam(const MS &ms) throw();
00746 template <class MS,class E> friend E _msmid(const MS &ms) throw();
00747 template <class M,class E> friend E _minf(const M &m) throw();
00748 template <class M,class E> friend E _msup(const M &m) throw();
00749 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
00750 #if(CXSC_INDEX_CHECK)
00751 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00752 #else
00753 throw();
00754 #endif
00755 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
00756 #if(CXSC_INDEX_CHECK)
00757 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00758 #else
00759 throw();
00760 #endif
00761 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
00762 #if(CXSC_INDEX_CHECK)
00763 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00764 #else
00765 throw();
00766 #endif
00767 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
00768 #if(CXSC_INDEX_CHECK)
00769 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00770 #else
00771 throw();
00772 #endif
00773 template <class MS,class E> friend E _msinf(const MS &ms) throw();
00774 template <class MS,class E> friend E _mssup(const MS &ms) throw();
00775 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
00776 #if(CXSC_INDEX_CHECK)
00777 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
00778 #else
00779 throw();
00780 #endif
00781 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
00782 #if(CXSC_INDEX_CHECK)
00783 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
00784 #else
00785 throw();
00786 #endif
00787 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
00788 #if(CXSC_INDEX_CHECK)
00789 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
00790 #else
00791 throw();
00792 #endif
00793 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
00794 #if(CXSC_INDEX_CHECK)
00795 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
00796 #else
00797 throw();
00798 #endif
00799
00800
00801 template <class M1,class M2,class E> friend E _mmimult(const M1 &m1, const M2 &m2)
00802 #if(CXSC_INDEX_CHECK)
00803 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00804 #else
00805 throw();
00806 #endif
00807
00808 template <class M1,class M2,class S> friend M1 &_mmimultassign(M1 &m1,const M2 &m2)
00809 #if(CXSC_INDEX_CHECK)
00810 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00811 #else
00812 throw();
00813 #endif
00814 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
00815 #if(CXSC_INDEX_CHECK)
00816 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00817 #else
00818 throw();
00819 #endif
00820
00821 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
00822 #if(CXSC_INDEX_CHECK)
00823 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00824 #else
00825 throw();
00826 #endif
00827
00828 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
00829 #if(CXSC_INDEX_CHECK)
00830 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00831 #else
00832 throw();
00833 #endif
00834 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
00835 #if(CXSC_INDEX_CHECK)
00836 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00837 #else
00838 throw();
00839 #endif
00840
00841 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
00842 #if(CXSC_INDEX_CHECK)
00843 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00844 #else
00845 throw();
00846 #endif
00847 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
00848 #if(CXSC_INDEX_CHECK)
00849 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00850 #else
00851 throw();
00852 #endif
00853 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
00854 #if(CXSC_INDEX_CHECK)
00855 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00856 #else
00857 throw();
00858 #endif
00859 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
00860 #if(CXSC_INDEX_CHECK)
00861 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00862 #else
00863 throw();
00864 #endif
00865 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
00866 #if(CXSC_INDEX_CHECK)
00867 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00868 #else
00869 throw();
00870 #endif
00871 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
00872 #if(CXSC_INDEX_CHECK)
00873 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00874 #else
00875 throw();
00876 #endif
00877
00878 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
00879 #if(CXSC_INDEX_CHECK)
00880 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00881 #else
00882 throw();
00883 #endif
00884 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
00885 #if(CXSC_INDEX_CHECK)
00886 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00887 #else
00888 throw();
00889 #endif
00890 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
00891 #if(CXSC_INDEX_CHECK)
00892 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00893 #else
00894 throw();
00895 #endif
00896 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
00897 #if(CXSC_INDEX_CHECK)
00898 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00899 #else
00900 throw();
00901 #endif
00902
00903 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
00904 #if(CXSC_INDEX_CHECK)
00905 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00906 #else
00907 throw();
00908 #endif
00909 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
00910 #if(CXSC_INDEX_CHECK)
00911 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00912 #else
00913 throw();
00914 #endif
00915 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
00916 #if(CXSC_INDEX_CHECK)
00917 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00918 #else
00919 throw();
00920 #endif
00921
00922
00923 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
00924 #if(CXSC_INDEX_CHECK)
00925 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00926 #else
00927 throw();
00928 #endif
00929 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
00930 #if(CXSC_INDEX_CHECK)
00931 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00932 #else
00933 throw();
00934 #endif
00935 template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
00936 #if(CXSC_INDEX_CHECK)
00937 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00938 #else
00939 throw();
00940 #endif
00941
00942
00943
00944
00945 template <class M,class E> friend E _mre(const M &m) throw();
00946 template <class M,class E> friend E _mim(const M &m) throw();
00947 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
00948 #if(CXSC_INDEX_CHECK)
00949 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00950 #else
00951 throw();
00952 #endif
00953 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
00954 #if(CXSC_INDEX_CHECK)
00955 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00956 #else
00957 throw();
00958 #endif
00959 template <class MS,class E> friend E _msre(const MS &ms) throw();
00960 template <class MS,class E> friend E _msim(const MS &ms) throw();
00961 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
00962 #if(CXSC_INDEX_CHECK)
00963 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
00964 #else
00965 throw();
00966 #endif
00967 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
00968 #if(CXSC_INDEX_CHECK)
00969 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
00970 #else
00971 throw();
00972 #endif
00973
00974
00975 template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2)
00976 #if(CXSC_INDEX_CHECK)
00977 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00978 #else
00979 throw();
00980 #endif
00981
00982 template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2)
00983 #if(CXSC_INDEX_CHECK)
00984 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00985 #else
00986 throw();
00987 #endif
00988 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
00989 #if(CXSC_INDEX_CHECK)
00990 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00991 #else
00992 throw();
00993 #endif
00994
00995 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
00996 #if(CXSC_INDEX_CHECK)
00997 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00998 #else
00999 throw();
01000 #endif
01001
01002 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
01003 #if(CXSC_INDEX_CHECK)
01004 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01005 #else
01006 throw();
01007 #endif
01008 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
01009 #if(CXSC_INDEX_CHECK)
01010 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01011 #else
01012 throw();
01013 #endif
01014
01015
01016 template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
01017 #if(CXSC_INDEX_CHECK)
01018 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01019 #else
01020 throw();
01021 #endif
01022 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
01023 #if(CXSC_INDEX_CHECK)
01024 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01025 #else
01026 throw();
01027 #endif
01028 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
01029 #if(CXSC_INDEX_CHECK)
01030 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01031 #else
01032 throw();
01033 #endif
01034
01035 template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
01036 #if(CXSC_INDEX_CHECK)
01037 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01038 #else
01039 throw();
01040 #endif
01041 template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
01042 #if(CXSC_INDEX_CHECK)
01043 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01044 #else
01045 throw();
01046 #endif
01047 template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
01048 #if(CXSC_INDEX_CHECK)
01049 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01050 #else
01051 throw();
01052 #endif
01053
01054
01055
01056
01058 friend INLINE rmatrix SupRe(const cimatrix &v) throw();
01060 friend INLINE rmatrix SupIm(const cimatrix &v) throw();
01062 friend INLINE rmatrix InfRe(const cimatrix &v) throw();
01064 friend INLINE rmatrix InfIm(const cimatrix &v) throw();
01066 friend INLINE rmatrix SupRe(const cimatrix_slice &v) throw();
01068 friend INLINE rmatrix SupIm(const cimatrix_slice &v) throw();
01070 friend INLINE rmatrix InfRe(const cimatrix_slice &v) throw();
01072 friend INLINE rmatrix InfIm(const cimatrix_slice &v) throw();
01073
01074
01075
01076 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
01077 #if(CXSC_INDEX_CHECK)
01078 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01079 #else
01080 throw();
01081 #endif
01082 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
01083 #if(CXSC_INDEX_CHECK)
01084 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01085 #else
01086 throw();
01087 #endif
01088 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
01089 #if(CXSC_INDEX_CHECK)
01090 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01091 #else
01092 throw();
01093 #endif
01094 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
01095 #if(CXSC_INDEX_CHECK)
01096 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01097 #else
01098 throw();
01099 #endif
01100 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
01101 #if(CXSC_INDEX_CHECK)
01102 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01103 #else
01104 throw();
01105 #endif
01106 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01107 #if(CXSC_INDEX_CHECK)
01108 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01109 #else
01110 throw();
01111 #endif
01112
01113
01114 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
01115 #if(CXSC_INDEX_CHECK)
01116 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01117 #else
01118 throw();
01119 #endif
01120 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
01121 #if(CXSC_INDEX_CHECK)
01122 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01123 #else
01124 throw();
01125 #endif
01126 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
01127 #if(CXSC_INDEX_CHECK)
01128 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01129 #else
01130 throw();
01131 #endif
01132
01133 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
01134 #if(CXSC_INDEX_CHECK)
01135 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01136 #else
01137 throw();
01138 #endif
01139 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
01140 #if(CXSC_INDEX_CHECK)
01141 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01142 #else
01143 throw();
01144 #endif
01145 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
01146 #if(CXSC_INDEX_CHECK)
01147 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01148 #else
01149 throw();
01150 #endif
01151
01152
01153
01154 template <class M1,class M2,class E> friend E _mmlmult(const M1 &m1, const M2 &m2)
01155 #if(CXSC_INDEX_CHECK)
01156 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01157 #else
01158 throw();
01159 #endif
01160 template <class M1,class M2,class S> friend M1 &_mmlmultassign(M1 &m1,const M2 &m2)
01161 #if(CXSC_INDEX_CHECK)
01162 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01163 #else
01164 throw();
01165 #endif
01166 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
01167 #if(CXSC_INDEX_CHECK)
01168 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01169 #else
01170 throw();
01171 #endif
01172
01173 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
01174 #if(CXSC_INDEX_CHECK)
01175 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01176 #else
01177 throw();
01178 #endif
01179
01180 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
01181 #if(CXSC_INDEX_CHECK)
01182 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01183 #else
01184 throw();
01185 #endif
01186 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
01187 #if(CXSC_INDEX_CHECK)
01188 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01189 #else
01190 throw();
01191 #endif
01192
01193 template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v)
01194 #if(CXSC_INDEX_CHECK)
01195 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01196 #else
01197 throw();
01198 #endif
01199 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
01200 #if(CXSC_INDEX_CHECK)
01201 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01202 #else
01203 throw();
01204 #endif
01205 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
01206 #if(CXSC_INDEX_CHECK)
01207 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01208 #else
01209 throw();
01210 #endif
01211
01212 template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m)
01213 #if(CXSC_INDEX_CHECK)
01214 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01215 #else
01216 throw();
01217 #endif
01218 template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m)
01219 #if(CXSC_INDEX_CHECK)
01220 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01221 #else
01222 throw();
01223 #endif
01224
01225
01226
01227 template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
01228 #if(CXSC_INDEX_CHECK)
01229 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01230 #else
01231 throw();
01232 #endif
01233
01234 template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
01235 #if(CXSC_INDEX_CHECK)
01236 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01237 #else
01238 throw();
01239 #endif
01240 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
01241 #if(CXSC_INDEX_CHECK)
01242 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01243 #else
01244 throw();
01245 #endif
01246
01247 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
01248 #if(CXSC_INDEX_CHECK)
01249 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01250 #else
01251 throw();
01252 #endif
01253
01254 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
01255 #if(CXSC_INDEX_CHECK)
01256 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01257 #else
01258 throw();
01259 #endif
01260 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01261 #if(CXSC_INDEX_CHECK)
01262 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01263 #else
01264 throw();
01265 #endif
01266
01267
01268
01269 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
01270 #if(CXSC_INDEX_CHECK)
01271 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01272 #else
01273 throw();
01274 #endif
01275 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
01276 #if(CXSC_INDEX_CHECK)
01277 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01278 #else
01279 throw();
01280 #endif
01281 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
01282 #if(CXSC_INDEX_CHECK)
01283 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01284 #else
01285 throw();
01286 #endif
01287
01288 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
01289 #if(CXSC_INDEX_CHECK)
01290 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01291 #else
01292 throw();
01293 #endif
01294 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
01295 #if(CXSC_INDEX_CHECK)
01296 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01297 #else
01298 throw();
01299 #endif
01300 template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
01301 #if(CXSC_INDEX_CHECK)
01302 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01303 #else
01304 throw();
01305 #endif
01306
01307 #endif
01308
01309
01310
01312 INLINE rmatrix(const rmatrix &rm) throw();
01314 INLINE rmatrix(const rmatrix_slice &rm) throw();
01316 INLINE rmatrix() throw();
01318 explicit INLINE rmatrix(const int &m, const int &n)
01319 #if(CXSC_INDEX_CHECK)
01320 throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
01321 #else
01322 throw();
01323 #endif
01324
01325 explicit INLINE rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
01326 #if(CXSC_INDEX_CHECK)
01327 throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
01328 #else
01329 throw();
01330 #endif
01331
01332 explicit INLINE rmatrix(const rvector &v) throw();
01334 explicit INLINE rmatrix(const rvector_slice &v) throw();
01336 explicit INLINE rmatrix(const real &r) throw();
01338 INLINE rmatrix(const srmatrix&);
01340 INLINE rmatrix(const srmatrix_slice&);
01342 INLINE rmatrix(const intmatrix&);
01343
01344
01346 INLINE rmatrix &operator =(const real &r) throw();
01348 INLINE rmatrix &operator =(const rmatrix &m) throw();
01350 INLINE rmatrix &operator =(const rmatrix_slice &ms) throw();
01352 INLINE rmatrix &operator =(const rvector &v) throw();
01354 INLINE rmatrix &operator =(const rvector_slice &v) throw();
01356 INLINE rmatrix &operator =(const srmatrix&);
01358 INLINE rmatrix &operator =(const srmatrix_slice&);
01359
01361 INLINE rmatrix &operator *=(const srmatrix &m);
01363 INLINE rmatrix &operator *=(const srmatrix_slice &m);
01365 INLINE rmatrix &operator +=(const srmatrix &m);
01367 INLINE rmatrix &operator +=(const srmatrix_slice &m);
01369 INLINE rmatrix &operator -=(const srmatrix &m);
01371 INLINE rmatrix &operator -=(const srmatrix_slice &m);
01372
01374 INLINE rmatrix operator()(const intvector& p, const intvector& q);
01376 INLINE rmatrix operator()(const intmatrix& P, const intmatrix& Q);
01378 INLINE rmatrix operator()(const intvector& p);
01380 INLINE rmatrix operator()(const intmatrix& P);
01381
01382
01383
01384 INLINE ~rmatrix() throw() { delete [] dat; }
01385
01386
01387
01388 friend INLINE real::real(const rmatrix &m)
01389 #if(CXSC_INDEX_CHECK)
01390 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_RMATRIX_USE_OF_UNINITIALIZED_OBJ);
01391 #else
01392 throw();
01393 #endif
01394 friend INLINE rvector::rvector(const rmatrix &m)
01395 #if(CXSC_INDEX_CHECK)
01396 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01397 #else
01398 throw();
01399 #endif
01400
01401 INLINE rmatrix_subv operator [](const int &i) const
01402 #if(CXSC_INDEX_CHECK)
01403 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
01404 #else
01405 throw();
01406 #endif
01407
01408 INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
01409 #if(CXSC_INDEX_CHECK)
01410 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
01411 #else
01412 throw();
01413 #endif
01414
01415 INLINE rmatrix &operator ()() throw() { return *this; }
01417 INLINE rmatrix_slice operator ()(const int &m, const int &n)
01418 #if(CXSC_INDEX_CHECK)
01419 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
01420 #else
01421 throw();
01422 #endif
01423
01424 INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01425 #if(CXSC_INDEX_CHECK)
01426 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
01427 #else
01428 throw();
01429 #endif
01430 INLINE operator void*() throw();
01431
01432
01433 };
01434
01436
01441 class rmatrix_slice
01442 {
01443 friend class rmatrix;
01444 friend class imatrix;
01445 friend class cmatrix;
01446 friend class cimatrix;
01447 friend class l_rmatrix;
01448 friend class l_imatrix;
01449 private:
01450 real *dat;
01451 int offset1,offset2,mxsize,mysize;
01452 int start1,end1,start2,end2,sxsize,sysize;
01453
01454 public:
01455
01456 #ifdef _CXSC_FRIEND_TPL
01457
01458 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
01459 #if(CXSC_INDEX_CHECK)
01460 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01461 #else
01462 throw();
01463 #endif
01464 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
01465 #if(CXSC_INDEX_CHECK)
01466 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01467 #else
01468 throw();
01469 #endif
01470 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
01471 #if(CXSC_INDEX_CHECK)
01472 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01473 #else
01474 throw();
01475 #endif
01476 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
01477 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
01478 template <class MS> friend int _mslb(const MS &ms, const int &i)
01479 #if(CXSC_INDEX_CHECK)
01480 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01481 #else
01482 throw();
01483 #endif
01484 template <class MS> friend int _msub(const MS &ms, const int &i)
01485 #if(CXSC_INDEX_CHECK)
01486 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01487 #else
01488 throw();
01489 #endif
01490 template <class MS,class E> friend E _msabs(const MS &ms) throw();
01491
01492 template <class MS,class E> friend E _msminus(const MS &ms) throw();
01493 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
01494 #if(CXSC_INDEX_CHECK)
01495 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01496 #else
01497 throw();
01498 #endif
01499 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
01500 #if(CXSC_INDEX_CHECK)
01501 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01502 #else
01503 throw();
01504 #endif
01505 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
01506 #if(CXSC_INDEX_CHECK)
01507 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01508 #else
01509 throw();
01510 #endif
01511 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
01512 #if(CXSC_INDEX_CHECK)
01513 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01514 #else
01515 throw();
01516 #endif
01517 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
01518 #if(CXSC_INDEX_CHECK)
01519 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01520 #else
01521 throw();
01522 #endif
01523 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
01524 #if(CXSC_INDEX_CHECK)
01525 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01526 #else
01527 throw();
01528 #endif
01529 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
01530 #if(CXSC_INDEX_CHECK)
01531 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01532 #else
01533 throw();
01534 #endif
01535 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01536 #if(CXSC_INDEX_CHECK)
01537 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01538 #else
01539 throw();
01540 #endif
01541 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
01542 #if(CXSC_INDEX_CHECK)
01543 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01544 #else
01545 throw();
01546 #endif
01547 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
01548 #if(CXSC_INDEX_CHECK)
01549 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01550 #else
01551 throw();
01552 #endif
01553 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
01554 #if(CXSC_INDEX_CHECK)
01555 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01556 #else
01557 throw();
01558 #endif
01559 template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms)
01560 #if(CXSC_INDEX_CHECK)
01561 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01562 #else
01563 throw();
01564 #endif
01565 template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2)
01566 #if(CXSC_INDEX_CHECK)
01567 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01568 #else
01569 throw();
01570 #endif
01571 template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
01572 #if(CXSC_INDEX_CHECK)
01573 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01574 #else
01575 throw();
01576 #endif
01577 template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2)
01578 #if(CXSC_INDEX_CHECK)
01579 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01580 #else
01581 throw();
01582 #endif
01583 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
01584 #if(CXSC_INDEX_CHECK)
01585 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01586 #else
01587 throw();
01588 #endif
01589 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
01590 #if(CXSC_INDEX_CHECK)
01591 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01592 #else
01593 throw();
01594 #endif
01595
01596 template <class MS,class V,class E> friend E _msvmult(const MS &ms,const V &v)
01597 #if(CXSC_INDEX_CHECK)
01598 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01599 #else
01600 throw();
01601 #endif
01602 template <class V,class MS,class E> friend E _vmsmult(const V &v,const MS &ms)
01603 #if(CXSC_INDEX_CHECK)
01604 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01605 #else
01606 throw();
01607 #endif
01608 template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms)
01609 #if(CXSC_INDEX_CHECK)
01610 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01611 #else
01612 throw();
01613 #endif
01614
01615 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
01616 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
01617 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
01618 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
01619
01620 template <class MS> friend void *_msvoid(const MS &ms) throw();
01621 template <class MS> friend bool _msnot(const MS &ms) throw();
01622 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01623 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01624 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01625 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01626 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01627 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01628 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
01629 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
01630 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
01631 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
01632 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
01633 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
01634
01635
01636 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
01637 #if(CXSC_INDEX_CHECK)
01638 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01639 #else
01640 throw();
01641 #endif
01642 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
01643 #if(CXSC_INDEX_CHECK)
01644 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01645 #else
01646 throw();
01647 #endif
01648 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
01649 #if(CXSC_INDEX_CHECK)
01650 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01651 #else
01652 throw();
01653 #endif
01654 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
01655 #if(CXSC_INDEX_CHECK)
01656 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01657 #else
01658 throw();
01659 #endif
01660 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
01661 #if(CXSC_INDEX_CHECK)
01662 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01663 #else
01664 throw();
01665 #endif
01666 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
01667 #if(CXSC_INDEX_CHECK)
01668 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01669 #else
01670 throw();
01671 #endif
01672 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
01673 #if(CXSC_INDEX_CHECK)
01674 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01675 #else
01676 throw();
01677 #endif
01678 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
01679 #if(CXSC_INDEX_CHECK)
01680 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01681 #else
01682 throw();
01683 #endif
01684
01685 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
01686 #if(CXSC_INDEX_CHECK)
01687 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01688 #else
01689 throw();
01690 #endif
01691 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
01692 #if(CXSC_INDEX_CHECK)
01693 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01694 #else
01695 throw();
01696 #endif
01697 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
01698 #if(CXSC_INDEX_CHECK)
01699 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01700 #else
01701 throw();
01702 #endif
01703
01704
01705
01706 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
01707 #if(CXSC_INDEX_CHECK)
01708 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01709 #else
01710 throw();
01711 #endif
01712 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
01713 #if(CXSC_INDEX_CHECK)
01714 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01715 #else
01716 throw();
01717 #endif
01718
01719 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
01720 #if(CXSC_INDEX_CHECK)
01721 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01722 #else
01723 throw();
01724 #endif
01725
01726 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
01727 #if(CXSC_INDEX_CHECK)
01728 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01729 #else
01730 throw();
01731 #endif
01732
01733 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
01734 #if(CXSC_INDEX_CHECK)
01735 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01736 #else
01737 throw();
01738 #endif
01739 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
01740 #if(CXSC_INDEX_CHECK)
01741 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01742 #else
01743 throw();
01744 #endif
01745 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
01746 #if(CXSC_INDEX_CHECK)
01747 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01748 #else
01749 throw();
01750 #endif
01751 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
01752 #if(CXSC_INDEX_CHECK)
01753 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01754 #else
01755 throw();
01756 #endif
01757 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
01758 #if(CXSC_INDEX_CHECK)
01759 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01760 #else
01761 throw();
01762 #endif
01763 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
01764 #if(CXSC_INDEX_CHECK)
01765 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01766 #else
01767 throw();
01768 #endif
01769
01770
01771
01772 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
01773 #if(CXSC_INDEX_CHECK)
01774 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01775 #else
01776 throw();
01777 #endif
01778 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
01779 #if(CXSC_INDEX_CHECK)
01780 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01781 #else
01782 throw();
01783 #endif
01784 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
01785 #if(CXSC_INDEX_CHECK)
01786 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01787 #else
01788 throw();
01789 #endif
01790 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
01791 #if(CXSC_INDEX_CHECK)
01792 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01793 #else
01794 throw();
01795 #endif
01796
01797 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
01798 #if(CXSC_INDEX_CHECK)
01799 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01800 #else
01801 throw();
01802 #endif
01803 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
01804 #if(CXSC_INDEX_CHECK)
01805 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01806 #else
01807 throw();
01808 #endif
01809 template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
01810 #if(CXSC_INDEX_CHECK)
01811 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01812 #else
01813 throw();
01814 #endif
01815
01816
01817
01818 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
01819 #if(CXSC_INDEX_CHECK)
01820 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01821 #else
01822 throw();
01823 #endif
01824 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
01825 #if(CXSC_INDEX_CHECK)
01826 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01827 #else
01828 throw();
01829 #endif
01830
01831 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
01832 #if(CXSC_INDEX_CHECK)
01833 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01834 #else
01835 throw();
01836 #endif
01837 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
01838 #if(CXSC_INDEX_CHECK)
01839 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01840 #else
01841 throw();
01842 #endif
01843
01844
01845 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
01846 #if(CXSC_INDEX_CHECK)
01847 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01848 #else
01849 throw();
01850 #endif
01851 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
01852 #if(CXSC_INDEX_CHECK)
01853 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01854 #else
01855 throw();
01856 #endif
01857 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
01858 #if(CXSC_INDEX_CHECK)
01859 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01860 #else
01861 throw();
01862 #endif
01863
01864
01865
01866
01867
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880
01881
01882
01883
01884 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
01885 #if(CXSC_INDEX_CHECK)
01886 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01887 #else
01888 throw();
01889 #endif
01890 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
01891 #if(CXSC_INDEX_CHECK)
01892 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01893 #else
01894 throw();
01895 #endif
01896 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
01897 #if(CXSC_INDEX_CHECK)
01898 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01899 #else
01900 throw();
01901 #endif
01902
01903 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01904 #if(CXSC_INDEX_CHECK)
01905 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01906 #else
01907 throw();
01908 #endif
01909
01910
01911 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
01912 #if(CXSC_INDEX_CHECK)
01913 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01914 #else
01915 throw();
01916 #endif
01917 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
01918 #if(CXSC_INDEX_CHECK)
01919 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01920 #else
01921 throw();
01922 #endif
01923 template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms)
01924 #if(CXSC_INDEX_CHECK)
01925 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01926 #else
01927 throw();
01928 #endif
01929
01930
01931 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
01932 #if(CXSC_INDEX_CHECK)
01933 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01934 #else
01935 throw();
01936 #endif
01937 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
01938 #if(CXSC_INDEX_CHECK)
01939 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01940 #else
01941 throw();
01942 #endif
01943
01944 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
01945 #if(CXSC_INDEX_CHECK)
01946 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01947 #else
01948 throw();
01949 #endif
01950 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
01951 #if(CXSC_INDEX_CHECK)
01952 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01953 #else
01954 throw();
01955 #endif
01956
01957
01958 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
01959 #if(CXSC_INDEX_CHECK)
01960 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01961 #else
01962 throw();
01963 #endif
01964 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
01965 #if(CXSC_INDEX_CHECK)
01966 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01967 #else
01968 throw();
01969 #endif
01970 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
01971 #if(CXSC_INDEX_CHECK)
01972 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01973 #else
01974 throw();
01975 #endif
01976
01977
01978
01979
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
01998 #if(CXSC_INDEX_CHECK)
01999 throw(ERROR__OP_WITH_WRONG_DIM<E>);
02000 #else
02001 throw();
02002 #endif
02003 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
02004 #if(CXSC_INDEX_CHECK)
02005 throw(ERROR__OP_WITH_WRONG_DIM<E>);
02006 #else
02007 throw();
02008 #endif
02009
02010 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
02011 #if(CXSC_INDEX_CHECK)
02012 throw(ERROR__OP_WITH_WRONG_DIM<M>);
02013 #else
02014 throw();
02015 #endif
02016
02017 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
02018 #if(CXSC_INDEX_CHECK)
02019 throw(ERROR__OP_WITH_WRONG_DIM<E>);
02020 #else
02021 throw();
02022 #endif
02023
02024
02025 #endif
02026
02027
02028
02029
02031 explicit INLINE rmatrix_slice(rmatrix &a,const int &l1,const int &u1,const int &l2, const int &u2) throw():dat(a.dat),offset1(l1-a.lb1),offset2(l2-a.lb2),mxsize(a.xsize),mysize(a.ysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
02033 explicit INLINE rmatrix_slice(rmatrix_slice &a,const int &l1,const int &u1,const int &l2, const int &u2) throw():dat(a.dat),offset1(a.offset1+l1-a.start1),offset2(a.offset2+l2-a.start2),mxsize(a.mxsize),mysize(a.mysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
02034 public:
02036 INLINE rmatrix_slice(const rmatrix_slice &ms) throw():dat(ms.dat),offset1(ms.offset1),offset2(ms.offset2),mxsize(ms.mxsize),mysize(ms.mysize),start1(ms.start1),end1(ms.end1),start2(ms.start2),end2(ms.end2),sxsize(ms.sxsize),sysize(ms.sysize) { }
02037 public:
02038
02039
02040
02041 friend rvector::rvector(const rmatrix_slice &sl)
02042 #if(CXSC_INDEX_CHECK)
02043 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
02044 #else
02045 throw();
02046 #endif
02047 friend INLINE rmatrix::rmatrix(const rmatrix_slice &) throw();
02049 INLINE rmatrix_slice &operator =(const srmatrix &m);
02051 INLINE rmatrix_slice &operator =(const srmatrix_slice &m);
02052
02054 INLINE rmatrix_slice &operator =(const rmatrix &m)
02055 #if(CXSC_INDEX_CHECK)
02056 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02057 #else
02058 throw();
02059 #endif
02060
02061 INLINE rmatrix_slice &operator =(const rmatrix_slice &ms)
02062 #if(CXSC_INDEX_CHECK)
02063 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02064 #else
02065 throw();
02066 #endif
02067
02068 INLINE rmatrix_slice &operator =(const real &r) throw();
02070 INLINE rmatrix_slice &operator =(const rvector &v)
02071 #if(CXSC_INDEX_CHECK)
02072 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02073 #else
02074 throw();
02075 #endif
02076
02077 INLINE rmatrix_slice &operator =(const rvector_slice &v)
02078 #if(CXSC_INDEX_CHECK)
02079 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02080 #else
02081 throw();
02082 #endif
02083
02084 INLINE rmatrix_slice &operator =(const rmatrix_subv &v)
02085 #if(CXSC_INDEX_CHECK)
02086 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02087 #else
02088 throw();
02089 #endif
02090
02091 INLINE rmatrix_subv operator [](const int &i) const
02092 #if(CXSC_INDEX_CHECK)
02093 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
02094 #else
02095 throw();
02096 #endif
02097
02098 INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
02099 #if(CXSC_INDEX_CHECK)
02100 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
02101 #else
02102 throw();
02103 #endif
02104
02105 INLINE rmatrix_slice &operator ()() throw() { return *this; }
02107 INLINE rmatrix_slice operator ()(const int &m, const int &n)
02108 #if(CXSC_INDEX_CHECK)
02109 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
02110 #else
02111 throw();
02112 #endif
02113
02114 INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
02115 #if(CXSC_INDEX_CHECK)
02116 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
02117 #else
02118 throw();
02119 #endif
02120
02122 INLINE rmatrix_slice &operator *=(const srmatrix &m);
02124 INLINE rmatrix_slice &operator *=(const srmatrix_slice &m);
02125
02127 INLINE rmatrix_slice &operator *=(const rmatrix &m)
02128 #if(CXSC_INDEX_CHECK)
02129 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02130 #else
02131 throw();
02132 #endif
02133
02134 INLINE rmatrix_slice &operator *=(const rmatrix_slice &ms2)
02135 #if(CXSC_INDEX_CHECK)
02136 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02137 #else
02138 throw();
02139 #endif
02140
02142 INLINE rmatrix_slice &operator +=(const srmatrix &m);
02144 INLINE rmatrix_slice &operator +=(const srmatrix_slice &m);
02145
02147 INLINE rmatrix_slice &operator +=(const rmatrix &m1)
02148 #if(CXSC_INDEX_CHECK)
02149 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02150 #else
02151 throw();
02152 #endif
02153
02154 INLINE rmatrix_slice &operator +=(const rmatrix_slice &ms2)
02155 #if(CXSC_INDEX_CHECK)
02156 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02157 #else
02158 throw();
02159 #endif
02160
02162 INLINE rmatrix_slice &operator -=(const srmatrix &m);
02164 INLINE rmatrix_slice &operator -=(const srmatrix_slice &m);
02165
02167 INLINE rmatrix_slice &operator -=(const rmatrix &m1)
02168 #if(CXSC_INDEX_CHECK)
02169 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02170 #else
02171 throw();
02172 #endif
02173
02174 INLINE rmatrix_slice &operator -=(const rmatrix_slice &ms2)
02175 #if(CXSC_INDEX_CHECK)
02176 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02177 #else
02178 throw();
02179 #endif
02180
02181 INLINE rmatrix_slice &operator *=(const real &c) throw();
02183 INLINE rmatrix_slice &operator /=(const real &c) throw();
02184 INLINE operator void*() throw();
02185
02186
02187 };
02188
02189
02190
02191
02192
02193
02195 INLINE rvector operator /(const rmatrix_subv &rv, const real &s) throw();
02197 INLINE rvector operator *(const rmatrix_subv &rv, const real &s) throw();
02199 INLINE rvector operator *(const real &s, const rmatrix_subv &rv) throw();
02201 INLINE rvector abs(const rmatrix_subv &mv) throw();
02202
02203
02204
02206 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02207 #if(CXSC_INDEX_CHECK)
02208 throw(OP_WITH_WRONG_DIM);
02209 #else
02210 throw();
02211 #endif
02212
02214 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2);
02215
02217 void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
02218 #if(CXSC_INDEX_CHECK)
02219 throw(OP_WITH_WRONG_DIM);
02220 #else
02221 throw();
02222 #endif
02223
02225 void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
02226
02228 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
02229 #if(CXSC_INDEX_CHECK)
02230 throw(OP_WITH_WRONG_DIM);
02231 #else
02232 throw();
02233 #endif
02234
02236 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
02237
02239 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02240 #if(CXSC_INDEX_CHECK)
02241 throw(OP_WITH_WRONG_DIM);
02242 #else
02243 throw();
02244 #endif
02245
02247 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2);
02248
02250 void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
02251 #if(CXSC_INDEX_CHECK)
02252 throw(OP_WITH_WRONG_DIM);
02253 #else
02254 throw();
02255 #endif
02256
02258 void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
02259
02261 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
02262 #if(CXSC_INDEX_CHECK)
02263 throw(OP_WITH_WRONG_DIM);
02264 #else
02265 throw();
02266 #endif
02267
02269 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
02270
02272 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02273 #if(CXSC_INDEX_CHECK)
02274 throw(OP_WITH_WRONG_DIM);
02275 #else
02276 throw();
02277 #endif
02278
02279 void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
02280 #if(CXSC_INDEX_CHECK)
02281 throw(OP_WITH_WRONG_DIM);
02282 #else
02283 throw();
02284 #endif
02285
02286 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
02287 #if(CXSC_INDEX_CHECK)
02288 throw(OP_WITH_WRONG_DIM);
02289 #else
02290 throw();
02291 #endif
02292
02293 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02294 #if(CXSC_INDEX_CHECK)
02295 throw(OP_WITH_WRONG_DIM);
02296 #else
02297 throw();
02298 #endif
02299
02300 void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
02301 #if(CXSC_INDEX_CHECK)
02302 throw(OP_WITH_WRONG_DIM);
02303 #else
02304 throw();
02305 #endif
02306
02307 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
02308 #if(CXSC_INDEX_CHECK)
02309 throw(OP_WITH_WRONG_DIM);
02310 #else
02311 throw();
02312 #endif
02313
02314 void accumulate(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv)
02315 #if(CXSC_INDEX_CHECK)
02316 throw(OP_WITH_WRONG_DIM);
02317 #else
02318 throw();
02319 #endif
02320
02322 void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv);
02323
02324
02326 void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
02327 #if(CXSC_INDEX_CHECK)
02328 throw(OP_WITH_WRONG_DIM);
02329 #else
02330 throw();
02331 #endif
02332
02334 void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2);
02335
02337 void accumulate(idotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
02338 #if(CXSC_INDEX_CHECK)
02339 throw(OP_WITH_WRONG_DIM);
02340 #else
02341 throw();
02342 #endif
02343
02345 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
02346 #if(CXSC_INDEX_CHECK)
02347 throw(OP_WITH_WRONG_DIM);
02348 #else
02349 throw();
02350 #endif
02351
02353 void accumulate(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs)
02354 #if(CXSC_INDEX_CHECK)
02355 throw(OP_WITH_WRONG_DIM);
02356 #else
02357 throw();
02358 #endif
02359
02361 void accumulate_approx(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs);
02362
02363
02365 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
02366 #if(CXSC_INDEX_CHECK)
02367 throw(OP_WITH_WRONG_DIM);
02368 #else
02369 throw();
02370 #endif
02371
02373 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2);
02374
02376 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
02377 #if(CXSC_INDEX_CHECK)
02378 throw(OP_WITH_WRONG_DIM);
02379 #else
02380 throw();
02381 #endif
02382
02384 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
02385 #if(CXSC_INDEX_CHECK)
02386 throw(OP_WITH_WRONG_DIM);
02387 #else
02388 throw();
02389 #endif
02390
02392 INLINE real operator *(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02393 #if(CXSC_INDEX_CHECK)
02394 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02395 #else
02396 throw();
02397 #endif
02398
02399 INLINE real operator *(const rvector & rv1, const rmatrix_subv &rv2)
02400 #if(CXSC_INDEX_CHECK)
02401 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02402 #else
02403 throw();
02404 #endif
02405
02406 INLINE real operator *(const rmatrix_subv &rv1,const rvector &rv2)
02407 #if(CXSC_INDEX_CHECK)
02408 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02409 #else
02410 throw();
02411 #endif
02412
02413 INLINE real operator *(const rvector_slice &sl,const rmatrix_subv &sv)
02414 #if(CXSC_INDEX_CHECK)
02415 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02416 #else
02417 throw();
02418 #endif
02419
02420 INLINE real operator *(const rmatrix_subv &mv,const rvector_slice &vs)
02421 #if(CXSC_INDEX_CHECK)
02422 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02423 #else
02424 throw();
02425 #endif
02426
02428 INLINE rvector operator +(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02429 #if(CXSC_INDEX_CHECK)
02430 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02431 #else
02432 throw();
02433 #endif
02434
02435 INLINE rvector operator +(const rmatrix_subv &rv1,const rvector &rv2)
02436 #if(CXSC_INDEX_CHECK)
02437 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02438 #else
02439 throw();
02440 #endif
02441
02442 INLINE rvector operator +(const rvector & rv1, const rmatrix_subv &rv2)
02443 #if(CXSC_INDEX_CHECK)
02444 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02445 #else
02446 throw();
02447 #endif
02448
02449 INLINE rvector operator +(const rvector_slice &sl,const rmatrix_subv &mv)
02450 #if(CXSC_INDEX_CHECK)
02451 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02452 #else
02453 throw();
02454 #endif
02455
02456 INLINE rvector operator +(const rmatrix_subv &mv,const rvector_slice &sl)
02457 #if(CXSC_INDEX_CHECK)
02458 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02459 #else
02460 throw();
02461 #endif
02462
02464 INLINE rvector operator -(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
02465 #if(CXSC_INDEX_CHECK)
02466 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02467 #else
02468 throw();
02469 #endif
02470
02471 INLINE rvector operator -(const rvector & rv1, const rmatrix_subv &rv2)
02472 #if(CXSC_INDEX_CHECK)
02473 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02474 #else
02475 throw();
02476 #endif
02477
02478 INLINE rvector operator -(const rmatrix_subv &rv1,const rvector &rv2)
02479 #if(CXSC_INDEX_CHECK)
02480 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02481 #else
02482 throw();
02483 #endif
02484
02485 INLINE rvector operator -(const rvector_slice &sl,const rmatrix_subv &mv)
02486 #if(CXSC_INDEX_CHECK)
02487 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02488 #else
02489 throw();
02490 #endif
02491
02492 INLINE rvector operator -(const rmatrix_subv &mv,const rvector_slice &sl)
02493 #if(CXSC_INDEX_CHECK)
02494 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
02495 #else
02496 throw();
02497 #endif
02498
02499
02500
02501
02503 INLINE rmatrix _rmatrix(const rmatrix &rm) throw();
02505 INLINE rmatrix _rmatrix(const rvector &v) throw();
02507 INLINE rmatrix _rmatrix(const rvector_slice &v) throw();
02509 INLINE rmatrix _rmatrix(const real &r) throw();
02510
02512 INLINE int Lb(const rmatrix &rm, const int &i)
02513 #if(CXSC_INDEX_CHECK)
02514 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
02515 #else
02516 throw();
02517 #endif
02518
02519 INLINE int Ub(const rmatrix &rm, const int &i)
02520 #if(CXSC_INDEX_CHECK)
02521 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
02522 #else
02523 throw();
02524 #endif
02525
02526 INLINE int Lb(const rmatrix_slice &rm, const int &i)
02527 #if(CXSC_INDEX_CHECK)
02528 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
02529 #else
02530 throw();
02531 #endif
02532
02533 INLINE int Ub(const rmatrix_slice &rm, const int &i)
02534 #if(CXSC_INDEX_CHECK)
02535 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
02536 #else
02537 throw();
02538 #endif
02539
02540 INLINE rmatrix &SetLb(rmatrix &m, const int &i,const int &j)
02541 #if(CXSC_INDEX_CHECK)
02542 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
02543 #else
02544 throw();
02545 #endif
02546
02547 INLINE rmatrix &SetUb(rmatrix &m, const int &i,const int &j)
02548 #if(CXSC_INDEX_CHECK)
02549 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
02550 #else
02551 throw();
02552 #endif
02553
02554 INLINE void Resize(rmatrix &A) throw();
02556 INLINE void Resize(rmatrix &A,const int &m, const int &n)
02557 #if(CXSC_INDEX_CHECK)
02558 throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
02559 #else
02560 throw();
02561 #endif
02562
02563 INLINE void Resize(rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
02564 #if(CXSC_INDEX_CHECK)
02565 throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
02566 #else
02567 throw();
02568 #endif
02569
02571 INLINE rmatrix abs(const rmatrix &m) throw();
02573 INLINE rmatrix abs(const rmatrix_slice &ms) throw();
02574
02575
02576
02578 INLINE rmatrix operator *(const real &c, const rmatrix &m) throw();
02580 INLINE rmatrix operator *(const real &c, const rmatrix_slice &ms) throw();
02582 INLINE rmatrix operator *(const rmatrix &m,const real &c) throw();
02584 INLINE rmatrix operator *(const rmatrix_slice &ms,const real &c) throw();
02586 INLINE rmatrix &operator *=(rmatrix &m,const real &c) throw();
02588 INLINE rmatrix operator /(const rmatrix &m,const real &c) throw();
02590 INLINE rmatrix operator /(const rmatrix_slice &ms, const real &c) throw();
02592 INLINE rmatrix &operator /=(rmatrix &m,const real &c) throw();
02593
02594
02595
02596
02597
02599 INLINE rvector operator *(const rmatrix &m,const rvector &v)
02600 #if(CXSC_INDEX_CHECK)
02601 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02602 #else
02603 throw();
02604 #endif
02605
02606 INLINE rvector operator *(const rmatrix_slice &ms,const rvector &v)
02607 #if(CXSC_INDEX_CHECK)
02608 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02609 #else
02610 throw();
02611 #endif
02612
02613 INLINE rvector operator *(const rvector &v,const rmatrix &m)
02614 #if(CXSC_INDEX_CHECK)
02615 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02616 #else
02617 throw();
02618 #endif
02619
02620 INLINE rvector operator *(const rvector &v,const rmatrix_slice &ms)
02621 #if(CXSC_INDEX_CHECK)
02622 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02623 #else
02624 throw();
02625 #endif
02626
02627 INLINE rvector &operator *=(rvector &v,const rmatrix &m)
02628 #if(CXSC_INDEX_CHECK)
02629 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02630 #else
02631 throw();
02632 #endif
02633
02634 INLINE rvector &operator *=(rvector &v,const rmatrix_slice &ms)
02635 #if(CXSC_INDEX_CHECK)
02636 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02637 #else
02638 throw();
02639 #endif
02640
02641
02643 INLINE rvector operator *(const rvector_slice &v,const rmatrix &m)
02644 #if(CXSC_INDEX_CHECK)
02645 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02646 #else
02647 throw();
02648 #endif
02649
02650
02651
02652
02653
02655 INLINE const rmatrix &operator +(const rmatrix &m1) throw();
02657 INLINE rmatrix operator +(const rmatrix_slice &ms) throw();
02659 INLINE rmatrix operator +(const rmatrix &m1,const rmatrix &m2)
02660 #if(CXSC_INDEX_CHECK)
02661 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02662 #else
02663 throw();
02664 #endif
02665
02666 INLINE rmatrix operator +(const rmatrix &m,const rmatrix_slice &ms)
02667 #if(CXSC_INDEX_CHECK)
02668 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02669 #else
02670 throw();
02671 #endif
02672
02673 INLINE rmatrix operator +(const rmatrix_slice &ms,const rmatrix &m)
02674 #if(CXSC_INDEX_CHECK)
02675 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02676 #else
02677 throw();
02678 #endif
02679
02680 INLINE rmatrix operator +(const rmatrix_slice &m1,const rmatrix_slice &m2)
02681 #if(CXSC_INDEX_CHECK)
02682 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02683 #else
02684 throw();
02685 #endif
02686
02687 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix &m2)
02688 #if(CXSC_INDEX_CHECK)
02689 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02690 #else
02691 throw();
02692 #endif
02693
02694 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix_slice &ms)
02695 #if(CXSC_INDEX_CHECK)
02696 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02697 #else
02698 throw();
02699 #endif
02700
02702 INLINE rmatrix operator -(const rmatrix &m) throw();
02704 INLINE rmatrix operator -(const rmatrix_slice &ms) throw();
02706 INLINE rmatrix operator -(const rmatrix &m1,const rmatrix &m2)
02707 #if(CXSC_INDEX_CHECK)
02708 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02709 #else
02710 throw();
02711 #endif
02712
02713 INLINE rmatrix operator -(const rmatrix &m,const rmatrix_slice &ms)
02714 #if(CXSC_INDEX_CHECK)
02715 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02716 #else
02717 throw();
02718 #endif
02719
02720 INLINE rmatrix operator -(const rmatrix_slice &ms,const rmatrix &m)
02721 #if(CXSC_INDEX_CHECK)
02722 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02723 #else
02724 throw();
02725 #endif
02726
02727 INLINE rmatrix operator -(const rmatrix_slice &ms1,const rmatrix_slice &ms2)
02728 #if(CXSC_INDEX_CHECK)
02729 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02730 #else
02731 throw();
02732 #endif
02733
02734 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix &m2)
02735 #if(CXSC_INDEX_CHECK)
02736 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02737 #else
02738 throw();
02739 #endif
02740
02741 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix_slice &ms)
02742 #if(CXSC_INDEX_CHECK)
02743 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02744 #else
02745 throw();
02746 #endif
02747
02749 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix &m2)
02750 #if(CXSC_INDEX_CHECK)
02751 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02752 #else
02753 throw();
02754 #endif
02755
02756 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix_slice &ms)
02757 #if(CXSC_INDEX_CHECK)
02758 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02759 #else
02760 throw();
02761 #endif
02762
02763 INLINE rmatrix operator *(const rmatrix_slice &ms, const rmatrix &m1)
02764 #if(CXSC_INDEX_CHECK)
02765 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02766 #else
02767 throw();
02768 #endif
02769
02770 INLINE rmatrix operator *(const rmatrix_slice &ms1, const rmatrix_slice &ms2)
02771 #if(CXSC_INDEX_CHECK)
02772 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02773 #else
02774 throw();
02775 #endif
02776
02777 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix &m2)
02778 #if(CXSC_INDEX_CHECK)
02779 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02780 #else
02781 throw();
02782 #endif
02783
02784 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix_slice &ms)
02785 #if(CXSC_INDEX_CHECK)
02786 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
02787 #else
02788 throw();
02789 #endif
02790
02791
02792
02793
02794
02795
02796
02798 INLINE bool operator ==(const rmatrix &m1,const rmatrix &m2) throw();
02800 INLINE bool operator !=(const rmatrix &m1,const rmatrix &m2) throw();
02802 INLINE bool operator <(const rmatrix &m1,const rmatrix &m2) throw();
02804 INLINE bool operator <=(const rmatrix &m1,const rmatrix &m2) throw();
02806 INLINE bool operator >(const rmatrix &m1,const rmatrix &m2) throw();
02808 INLINE bool operator >=(const rmatrix &m1,const rmatrix &m2) throw();
02810 INLINE bool operator ==(const rmatrix &m1,const rmatrix_slice &ms) throw();
02812 INLINE bool operator !=(const rmatrix &m1,const rmatrix_slice &ms) throw();
02814 INLINE bool operator <(const rmatrix &m1,const rmatrix_slice &ms) throw();
02816 INLINE bool operator <=(const rmatrix &m1,const rmatrix_slice &ms) throw();
02818 INLINE bool operator >(const rmatrix &m1,const rmatrix_slice &ms) throw();
02820 INLINE bool operator >=(const rmatrix &m1,const rmatrix_slice &ms) throw();
02821
02822
02823
02825 INLINE bool operator ==(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
02827 INLINE bool operator !=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
02829 INLINE bool operator <(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
02831 INLINE bool operator <=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
02833 INLINE bool operator >(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
02835 INLINE bool operator >=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
02836
02837
02838
02840 INLINE bool operator !(const rmatrix &ms) throw();
02842 INLINE bool operator !(const rmatrix_slice &ms) throw();
02843
02844
02845
02847 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix &r) throw();
02849 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix_slice &r) throw();
02851 INLINE std::istream &operator >>(std::istream &s,rmatrix &r) throw();
02853 INLINE std::istream &operator >>(std::istream &s,rmatrix_slice &r) throw();
02854
02855
02856
02858 INLINE int RowLen ( const rmatrix& );
02860 INLINE int ColLen ( const rmatrix& );
02862 INLINE int RowLen ( const rmatrix_slice& );
02864 INLINE int ColLen ( const rmatrix_slice& );
02866 rmatrix Id ( const rmatrix& );
02868 rmatrix transp ( const rmatrix& );
02870 void DoubleSize ( rmatrix& );
02871
02872
02873 }
02874
02875 #ifdef _CXSC_INCL_INL
02876 # include "matrix.inl"
02877 # include "rmatrix.inl"
02878 #endif
02879
02880 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
02881 # ifdef _CXSC_INCL_INL
02882 # include "ivecrmat.inl"
02883 # else
02884 # include "ivecrmat.hpp"
02885 # endif
02886 #endif
02887
02888 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
02889 # ifdef _CXSC_INCL_INL
02890 # include "cvecrmat.inl"
02891 # else
02892 # include "cvecrmat.hpp"
02893 # endif
02894 #endif
02895
02896 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
02897 # ifdef _CXSC_INCL_INL
02898 # include "civecrmat.inl"
02899 # else
02900 # include "civecrmat.hpp"
02901 # endif
02902 #endif
02903
02904 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED
02905 # ifdef _CXSC_INCL_INL
02906 # include "livecrmat.inl"
02907 # else
02908 # include "livecrmat.hpp"
02909 # endif
02910 #endif
02911
02912 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
02913 # ifdef _CXSC_INCL_INL
02914 # include "lrvecrmat.inl"
02915 # else
02916 # include "lrvecrmat.hpp"
02917 # endif
02918 #endif
02919
02920 #ifdef CXSC_USE_BLAS
02921 #define _CXSC_BLAS_RMATRIX
02922 #include "cxsc_blas.inl"
02923 #endif
02924
02925 #endif
