26 #ifndef _CXSC_CIMATRIX_HPP_INCLUDED 27 #define _CXSC_CIMATRIX_HPP_INCLUDED 29 #include "xscclass.hpp" 31 #include "civector.hpp" 34 #include "imatrix.hpp" 35 #include "cmatrix.hpp" 52 class scimatrix_slice;
76 int size,start,offset;
82 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
90 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
97 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
104 #if(CXSC_INDEX_CHECK) 105 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
111 #ifdef _CXSC_FRIEND_TPL 113 template <
class MV1,
class MV2>
friend MV1 &_mvmvassign(MV1 &v,
const MV2 &rv)
114 #if(CXSC_INDEX_CHECK) 115 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
119 template <
class MV,
class S>
friend MV &_mvsassign(MV &v,
const S &r)
throw();
120 template <
class MV,
class V>
friend MV &_mvvassign(MV &v,
const V &rv)
121 #if(CXSC_INDEX_CHECK) 122 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
126 template <
class V,
class MV2,
class S>
friend V &_vmvassign(V &v,
const MV2 &rv)
throw();
127 template <
class MV,
class V>
friend MV &_mvvsetinf(MV &v,
const V &rv)
128 #if(CXSC_INDEX_CHECK) 129 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
133 template <
class MV,
class V>
friend MV &_mvvsetsup(MV &v,
const V &rv)
134 #if(CXSC_INDEX_CHECK) 135 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
139 template <
class MV,
class V>
friend MV &_mvvusetinf(MV &v,
const V &rv)
140 #if(CXSC_INDEX_CHECK) 141 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
145 template <
class MV,
class V>
friend MV &_mvvusetsup(MV &v,
const V &rv)
146 #if(CXSC_INDEX_CHECK) 147 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
151 template <
class MV,
class V>
friend MV &_mvvsetre(MV &v,
const V &rv)
152 #if(CXSC_INDEX_CHECK) 153 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
157 template <
class MV,
class V>
friend MV &_mvvsetim(MV &v,
const V &rv)
158 #if(CXSC_INDEX_CHECK) 159 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
163 template <
class MV,
class V>
friend V _mvabs(
const MV &mv)
throw();
164 template <
class MV,
class V>
friend V _mvim(
const MV &mv)
throw();
165 template <
class MV,
class V>
friend V _mvre(
const MV &mv)
throw();
166 template <
class MV,
class V>
friend V _mvdiam(
const MV &mv)
throw();
167 template <
class MV,
class V>
friend V _mvmid(
const MV &mv)
throw();
168 template <
class MV,
class V>
friend V _mvinf(
const MV &mv)
throw();
169 template <
class MV,
class V>
friend V _mvsup(
const MV &mv)
throw();
171 template <
class MV,
class S>
friend MV &_mvssetinf(MV &mv,
const S &s)
throw();
172 template <
class MV,
class S>
friend MV &_mvssetsup(MV &mv,
const S &s)
throw();
173 template <
class MV,
class S>
friend MV &_mvsusetinf(MV &mv,
const S &s)
throw();
174 template <
class MV,
class S>
friend MV &_mvsusetsup(MV &mv,
const S &s)
throw();
175 template <
class MV,
class S>
friend MV &_mvssetim(MV &mv,
const S &s)
throw();
176 template <
class MV,
class S>
friend MV &_mvssetre(MV &mv,
const S &s)
throw();
177 template <
class DP,
class V,
class SV>
friend void _vmvaccu(DP &dp,
const V & rv1,
const SV &rv2)
178 #if(CXSC_INDEX_CHECK) 179 throw(OP_WITH_WRONG_DIM);
183 template <
class DP,
class MV1,
class MV2>
friend void _mvmvaccu(DP &dp,
const MV1 & rv1,
const MV2 &rv2)
184 #if(CXSC_INDEX_CHECK) 185 throw(OP_WITH_WRONG_DIM);
189 template <
class MV1,
class MV2,
class S>
friend S _mvmvcimult(
const MV1 & rv1,
const MV2 &rv2)
190 #if(CXSC_INDEX_CHECK) 191 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
195 template <
class V,
class MV,
class S>
friend S _vmvcimult(
const V &rv1,
const MV &rv2)
196 #if(CXSC_INDEX_CHECK) 197 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
201 template <
class MV,
class S,
class E>
friend E _mvsmult(
const MV &rv,
const S &s)
throw();
202 template <
class MV1,
class MV2,
class E>
friend E _mvmvplus(
const MV1 &rv1,
const MV2 &rv2)
203 #if(CXSC_INDEX_CHECK) 204 throw(ERROR__OP_WITH_WRONG_DIM<E>);
208 template <
class MV1,
class MV2,
class E>
friend E _mvmvminus(
const MV1 &rv1,
const MV2 &rv2)
209 #if(CXSC_INDEX_CHECK) 210 throw(ERROR__OP_WITH_WRONG_DIM<E>);
214 template <
class MV,
class V,
class E>
friend E _mvvplus(
const MV &rv1,
const V &rv2)
215 #if(CXSC_INDEX_CHECK) 216 throw(ERROR__OP_WITH_WRONG_DIM<E>);
220 template <
class MV,
class V,
class E>
friend E _mvvminus(
const MV &rv1,
const V &rv2)
221 #if(CXSC_INDEX_CHECK) 222 throw(ERROR__OP_WITH_WRONG_DIM<E>);
226 template <
class V,
class MV,
class E>
friend E _vmvminus(
const V &rv1,
const MV &rv2)
227 #if(CXSC_INDEX_CHECK) 228 throw(ERROR__OP_WITH_WRONG_DIM<E>);
232 template <
class MV,
class S,
class E>
friend E _mvsdiv(
const MV &rv,
const S &s)
throw();
233 template <
class MV,
class S>
friend MV &_mvsmultassign(MV &v,
const S &r)
throw();
234 template <
class MV,
class S>
friend MV &_mvsplusassign(MV &v,
const S &r)
throw();
235 template <
class MV,
class S>
friend MV &_mvsminusassign(MV &v,
const S &r)
throw();
236 template <
class MV,
class S>
friend MV &_mvsdivassign(MV &v,
const S &r)
throw();
237 template <
class MV,
class V>
friend MV &_mvvplusassign(MV &v,
const V &rv)
238 #if(CXSC_INDEX_CHECK) 239 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
243 template <
class V,
class MV>
friend V &_vmvplusassign(V &rv,
const MV &v)
244 #if(CXSC_INDEX_CHECK) 245 throw(ERROR__OP_WITH_WRONG_DIM<V>);
249 template <
class MV,
class V>
friend MV &_mvvminusassign(MV &v,
const V &rv)
250 #if(CXSC_INDEX_CHECK) 251 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
255 template <
class V,
class MV>
friend V &_vmvminusassign(V &rv,
const MV &v)
256 #if(CXSC_INDEX_CHECK) 257 throw(ERROR__OP_WITH_WRONG_DIM<V>);
261 template <
class MV1,
class MV2,
class E>
friend E _mvmvconv(
const MV1 &rv1,
const MV2 &rv2)
262 #if(CXSC_INDEX_CHECK) 263 throw(ERROR__OP_WITH_WRONG_DIM<E>);
267 template <
class MV,
class V,
class E>
friend E _mvvconv(
const MV &rv1,
const V &rv2)
268 #if(CXSC_INDEX_CHECK) 269 throw(ERROR__OP_WITH_WRONG_DIM<E>);
273 template <
class MV,
class V>
friend MV &_mvvconvassign(MV &v,
const V &rv)
274 #if(CXSC_INDEX_CHECK) 275 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
279 template <
class MV1,
class MV2,
class E>
friend E _mvmvsect(
const MV1 &rv1,
const MV2 &rv2)
280 #if(CXSC_INDEX_CHECK) 281 throw(ERROR__OP_WITH_WRONG_DIM<E>);
285 template <
class MV,
class V,
class E>
friend E _mvvsect(
const MV &rv1,
const V &rv2)
286 #if(CXSC_INDEX_CHECK) 287 throw(ERROR__OP_WITH_WRONG_DIM<E>);
291 template <
class MV,
class V>
friend MV &_mvvsectassign(MV &v,
const V &rv)
292 #if(CXSC_INDEX_CHECK) 293 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
297 template <
class V,
class MV>
friend V &_vmvsectassign(V &rv,
const MV &v)
298 #if(CXSC_INDEX_CHECK) 299 throw(ERROR__OP_WITH_WRONG_DIM<V>);
315 explicit INLINE
cimatrix_subv (
cinterval *d,
const int &l,
const int &u,
const int &s,
const int &st,
const int &o)
throw():dat(d),lb(l),ub(u),size(s),start(st),offset(o) { }
356 #if(CXSC_INDEX_CHECK) 357 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
363 #if(CXSC_INDEX_CHECK) 364 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
370 #if(CXSC_INDEX_CHECK) 371 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
377 #if(CXSC_INDEX_CHECK) 378 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
387 #if(CXSC_INDEX_CHECK) 388 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
394 #if(CXSC_INDEX_CHECK) 395 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
401 #if(CXSC_INDEX_CHECK) 402 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
408 #if(CXSC_INDEX_CHECK) 409 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
421 #if(CXSC_INDEX_CHECK) 422 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
428 #if(CXSC_INDEX_CHECK) 429 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
435 #if(CXSC_INDEX_CHECK) 436 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
442 #if(CXSC_INDEX_CHECK) 443 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
455 #if(CXSC_INDEX_CHECK) 456 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
462 #if(CXSC_INDEX_CHECK) 463 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
469 #if(CXSC_INDEX_CHECK) 470 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
476 #if(CXSC_INDEX_CHECK) 477 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
493 #if(CXSC_INDEX_CHECK) 494 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
501 #if(CXSC_INDEX_CHECK) 502 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
511 #if(CXSC_INDEX_CHECK) 512 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
518 #if(CXSC_INDEX_CHECK) 519 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
559 #if(CXSC_INDEX_CHECK) 560 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
566 #if(CXSC_INDEX_CHECK) 567 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
573 #if(CXSC_INDEX_CHECK) 574 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
580 #if(CXSC_INDEX_CHECK) 581 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
587 #if(CXSC_INDEX_CHECK) 588 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
594 #if(CXSC_INDEX_CHECK) 595 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
601 #if(CXSC_INDEX_CHECK) 602 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
608 #if(CXSC_INDEX_CHECK) 609 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
642 #if(CXSC_INDEX_CHECK) 643 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
649 #if(CXSC_INDEX_CHECK) 650 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
656 #if(CXSC_INDEX_CHECK) 657 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
663 #if(CXSC_INDEX_CHECK) 664 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
670 #if(CXSC_INDEX_CHECK) 671 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
677 #if(CXSC_INDEX_CHECK) 678 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
684 #if(CXSC_INDEX_CHECK) 685 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
691 #if(CXSC_INDEX_CHECK) 692 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
727 #if(CXSC_INDEX_CHECK) 728 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
734 #if(CXSC_INDEX_CHECK) 735 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
741 #if(CXSC_INDEX_CHECK) 742 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
748 #if(CXSC_INDEX_CHECK) 749 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
755 #if(CXSC_INDEX_CHECK) 756 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
762 #if(CXSC_INDEX_CHECK) 763 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
769 #if(CXSC_INDEX_CHECK) 770 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
776 #if(CXSC_INDEX_CHECK) 777 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
816 #if(CXSC_INDEX_CHECK) 817 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
823 #if(CXSC_INDEX_CHECK) 824 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
830 #if(CXSC_INDEX_CHECK) 831 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
837 #if(CXSC_INDEX_CHECK) 838 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
844 #if(CXSC_INDEX_CHECK) 845 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
851 #if(CXSC_INDEX_CHECK) 852 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
858 #if(CXSC_INDEX_CHECK) 859 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
865 #if(CXSC_INDEX_CHECK) 866 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
877 INLINE cimatrix_subv
Row(cimatrix &m,
const int &i)
878 #if(CXSC_INDEX_CHECK) 879 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
883 INLINE cimatrix_subv
Col(cimatrix &m,
const int &i)
885 #if(CXSC_INDEX_CHECK) 886 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
894 class cimatrix_slice;
913 int lb1,ub1,lb2,ub2,xsize,ysize;
917 #ifdef _CXSC_FRIEND_TPL 919 template <
class S,
class M>
friend void _smconstr(S &s,
const M &m)
920 #if(CXSC_INDEX_CHECK) 921 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
925 template <
class V,
class M,
class S>
friend void _vmconstr(V &v,
const M &m)
926 #if(CXSC_INDEX_CHECK) 927 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
931 template <
class M1,
class M2,
class S>
friend M1 &_mmassign(M1 &m1,
const M2 &m,S ms)
throw();
932 template <
class M,
class MS2,
class S>
friend M &_mmsassign(M &m,
const MS2 &ms)
throw();
933 template <
class MS,
class M>
friend MS &_msmassign(MS &ms,
const M &m)
934 #if(CXSC_INDEX_CHECK) 935 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
939 template <
class M,
class S>
friend M &_msassign(M &m,
const S &r)
throw();
940 template <
class V,
class M,
class S>
friend V &_vmassign(V &v,
const M &m)
941 #if(CXSC_INDEX_CHECK) 942 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
946 template <
class M,
class V,
class S>
friend M &_mvassign(M &m,
const V &v)
throw();
947 template <
class M>
friend int _mlb(
const M &m,
const int &i)
948 #if(CXSC_INDEX_CHECK) 949 throw(ERROR__WRONG_ROW_OR_COL<M>);
953 template <
class M>
friend int _mub(
const M &m,
const int &i)
954 #if(CXSC_INDEX_CHECK) 955 throw(ERROR__WRONG_ROW_OR_COL<M>);
959 template <
class M>
friend M &_msetlb(M &m,
const int &i,
const int &j)
960 #if(CXSC_INDEX_CHECK) 961 throw(ERROR__WRONG_ROW_OR_COL<M>);
965 template <
class M>
friend M &_msetub(M &m,
const int &i,
const int &j)
966 #if(CXSC_INDEX_CHECK) 967 throw(ERROR__WRONG_ROW_OR_COL<M>);
971 template <
class M>
friend void _mresize(M &A)
throw();
972 template <
class M,
class S>
friend void _mresize(M &A,
const int &m,
const int &n)
973 #if(CXSC_INDEX_CHECK) 974 throw(ERROR__WRONG_BOUNDARIES<M>);
978 template <
class M,
class S>
friend void _mresize(M &A,
const int &m1,
const int &m2,
const int &n1,
const int &n2)
979 #if(CXSC_INDEX_CHECK) 980 throw(ERROR__WRONG_BOUNDARIES<M>);
984 template <
class M,
class E>
friend E _mabs(
const M &m)
throw();
985 template <
class M,
class E>
friend E _mdiam(
const M &m)
throw();
986 template <
class M,
class E>
friend E _mmid(
const M &m)
throw();
987 template <
class M,
class E>
friend E _mre(
const M &m)
throw();
988 template <
class M,
class E>
friend E _mim(
const M &m)
throw();
993 template <
class M1,
class M2>
friend M1 &_mmsetre(M1 &m1,
const M2 &m2)
994 #if(CXSC_INDEX_CHECK) 995 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
999 template <
class M1,
class M2>
friend M1 &_mmsetim(M1 &m1,
const M2 &m2)
1000 #if(CXSC_INDEX_CHECK) 1001 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1005 template <
class M1,
class MS2>
friend M1 &_mmssetre(M1 &m1,
const MS2 &ms2)
1006 #if(CXSC_INDEX_CHECK) 1007 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1011 template <
class M1,
class MS2>
friend M1 &_mmssetim(M1 &m1,
const MS2 &ms2)
1012 #if(CXSC_INDEX_CHECK) 1013 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1017 template <
class M,
class E>
friend E _minf(
const M &m)
throw();
1018 template <
class M,
class E>
friend E _msup(
const M &m)
throw();
1019 template <
class M1,
class M2>
friend M1 &_mmsetinf(M1 &m1,
const M2 &m2)
1020 #if(CXSC_INDEX_CHECK) 1021 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1025 template <
class M1,
class M2>
friend M1 &_mmsetsup(M1 &m1,
const M2 &m2)
1026 #if(CXSC_INDEX_CHECK) 1027 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1031 template <
class M1,
class MS2>
friend M1 &_mmssetinf(M1 &m1,
const MS2 &ms2)
1032 #if(CXSC_INDEX_CHECK) 1033 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1037 template <
class M1,
class MS2>
friend M1 &_mmssetsup(M1 &m1,
const MS2 &ms2)
1038 #if(CXSC_INDEX_CHECK) 1039 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1043 template <
class M1,
class M2>
friend M1 &_mmusetinf(M1 &m1,
const M2 &m2)
1044 #if(CXSC_INDEX_CHECK) 1045 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1049 template <
class M1,
class M2>
friend M1 &_mmusetsup(M1 &m1,
const M2 &m2)
1050 #if(CXSC_INDEX_CHECK) 1051 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1055 template <
class M1,
class MS2>
friend M1 &_mmsusetinf(M1 &m1,
const MS2 &ms2)
1056 #if(CXSC_INDEX_CHECK) 1057 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1061 template <
class M1,
class MS2>
friend M1 &_mmsusetsup(M1 &m1,
const MS2 &ms2)
1062 #if(CXSC_INDEX_CHECK) 1063 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1068 template <
class M1,
class M2,
class E>
friend E _mmplus(
const M1 &m1,
const M2 &m2)
1069 #if(CXSC_INDEX_CHECK) 1070 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1074 template <
class M,
class MS,
class E>
friend E _mmsplus(
const M &m,
const MS &ms)
1075 #if(CXSC_INDEX_CHECK) 1076 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1080 template <
class M>
friend M _mminus(
const M &m)
throw();
1081 template <
class MS,
class E>
friend E _msminus(
const MS &ms)
throw();
1082 template <
class M1,
class M2,
class E>
friend E _mmminus(
const M1 &m1,
const M2 &m2)
1083 #if(CXSC_INDEX_CHECK) 1084 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1088 template <
class M1,
class M2>
friend M1 &_mmplusassign(M1 &m1,
const M2 &m2)
1089 #if(CXSC_INDEX_CHECK) 1090 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1094 template <
class M,
class MS>
friend M &_mmsplusassign(M &m1,
const MS &ms)
1095 #if(CXSC_INDEX_CHECK) 1096 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1100 template <
class MS,
class M>
friend MS &_msmplusassign(MS &ms,
const M &m1)
1101 #if(CXSC_INDEX_CHECK) 1102 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1106 template <
class MS1,
class MS2,
class E>
friend E _msmsplus(
const MS1 &m1,
const MS2 &m2)
1107 #if(CXSC_INDEX_CHECK) 1108 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1112 template <
class M,
class MS,
class E>
friend E _mmsminus(
const M &m,
const MS &ms)
1113 #if(CXSC_INDEX_CHECK) 1114 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1118 template <
class MS,
class M,
class E>
friend E _msmminus(
const MS &ms,
const M &m)
1119 #if(CXSC_INDEX_CHECK) 1120 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1124 template <
class MS1,
class MS2,
class E>
friend E _msmsminus(
const MS1 &ms1,
const MS2 &ms2)
1125 #if(CXSC_INDEX_CHECK) 1126 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1130 template <
class M1,
class M2>
friend M1 &_mmminusassign(M1 &m1,
const M2 &m2)
1131 #if(CXSC_INDEX_CHECK) 1132 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1136 template <
class M,
class MS>
friend M &_mmsminusassign(M &m1,
const MS &ms)
1137 #if(CXSC_INDEX_CHECK) 1138 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1142 template <
class MS,
class M>
friend MS &_msmminusassign(MS &ms,
const M &m1)
1143 #if(CXSC_INDEX_CHECK) 1144 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1148 template <
class M1,
class M2,
class E>
friend E _mmcimult(
const M1 &m1,
const M2 &m2)
1149 #if(CXSC_INDEX_CHECK) 1150 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1154 template <
class M1,
class M2,
class S>
friend M1 &_mmcimultassign(M1 &m1,
const M2 &m2)
1155 #if(CXSC_INDEX_CHECK) 1156 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1160 template <
class M,
class MS,
class E>
friend E _mmscimult(
const M &m1,
const MS &ms)
1161 #if(CXSC_INDEX_CHECK) 1162 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1166 template <
class MS,
class M,
class E>
friend E _msmcimult(
const MS &ms,
const M &m2)
1167 #if(CXSC_INDEX_CHECK) 1168 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1172 template <
class M,
class MS,
class S>
friend M &_mmscimultassign(M &m1,
const MS &ms)
1173 #if(CXSC_INDEX_CHECK) 1174 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1178 template <
class MS1,
class MS2,
class E>
friend E _msmscimult(
const MS1 &ms1,
const MS2 &ms2)
1179 #if(CXSC_INDEX_CHECK) 1180 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1184 template <
class M1,
class M2,
class E>
friend E _mmconv(
const M1 &m1,
const M2 &m2)
1185 #if(CXSC_INDEX_CHECK) 1186 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1190 template <
class M,
class MS,
class E>
friend E _mmsconv(
const M &m,
const MS &ms)
1191 #if(CXSC_INDEX_CHECK) 1192 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1196 template <
class M1,
class M2>
friend M1 &_mmconvassign(M1 &m1,
const M2 &m2)
1197 #if(CXSC_INDEX_CHECK) 1198 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1202 template <
class M,
class MS>
friend M &_mmsconvassign(M &m1,
const MS &ms)
1203 #if(CXSC_INDEX_CHECK) 1204 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1208 template <
class MS,
class M>
friend MS &_msmconvassign(MS &ms,
const M &m1)
1209 #if(CXSC_INDEX_CHECK) 1210 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1214 template <
class MS1,
class MS2,
class E>
friend E _msmsconv(
const MS1 &m1,
const MS2 &m2)
1215 #if(CXSC_INDEX_CHECK) 1216 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1220 template <
class M1,
class M2,
class E>
friend E _mmsect(
const M1 &m1,
const M2 &m2)
1221 #if(CXSC_INDEX_CHECK) 1222 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1226 template <
class M,
class MS,
class E>
friend E _mmssect(
const M &m,
const MS &ms)
1227 #if(CXSC_INDEX_CHECK) 1228 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1232 template <
class M1,
class M2>
friend M1 &_mmsectassign(M1 &m1,
const M2 &m2)
1233 #if(CXSC_INDEX_CHECK) 1234 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1238 template <
class M,
class MS>
friend M &_mmssectassign(M &m1,
const MS &ms)
1239 #if(CXSC_INDEX_CHECK) 1240 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1244 template <
class MS,
class M>
friend MS &_msmsectassign(MS &ms,
const M &m1)
1245 #if(CXSC_INDEX_CHECK) 1246 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1250 template <
class MS1,
class MS2,
class E>
friend E _msmssect(
const MS1 &m1,
const MS2 &m2)
1251 #if(CXSC_INDEX_CHECK) 1252 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1257 template <
class S,
class M,
class E>
friend E _smmult(
const S &c,
const M &m)
throw();
1258 template <
class M,
class S>
friend M &_msmultassign(M &m,
const S &c)
throw();
1259 template <
class S,
class MS,
class E>
friend E _smsmult(
const S &c,
const MS &ms)
throw();
1260 template <
class M,
class S,
class E>
friend E _msdiv(
const M &m,
const S &c)
throw();
1261 template <
class M,
class S>
friend M &_msdivassign(M &m,
const S &c)
throw();
1262 template <
class MS,
class S,
class E>
friend E _mssdiv(
const MS &ms,
const S &c)
throw();
1264 template <
class M,
class V,
class E>
friend E _mvcimult(
const M &m,
const V &v)
1265 #if(CXSC_INDEX_CHECK) 1266 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1270 template <
class V,
class M,
class E>
friend E _vmcimult(
const V &v,
const M &m)
1271 #if(CXSC_INDEX_CHECK) 1272 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1276 template <
class V,
class M,
class S>
friend V &_vmcimultassign(V &v,
const M &m)
1277 #if(CXSC_INDEX_CHECK) 1278 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1282 template <
class VS,
class M,
class S>
friend VS &_vsmcimultassign(VS &v,
const M &m)
1283 #if(CXSC_INDEX_CHECK) 1284 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1289 template <
class M>
friend void *_mvoid(
const M &m)
throw();
1290 template <
class M>
friend bool _mnot(
const M &m)
throw();
1291 template <
class MS>
friend void *_msvoid(
const MS &ms)
throw();
1292 template <
class MS>
friend bool _msnot(
const MS &ms)
throw();
1293 template <
class M1,
class M2>
friend bool _mmeq(
const M1 &m1,
const M2 &m2)
throw();
1294 template <
class M1,
class M2>
friend bool _mmneq(
const M1 &m1,
const M2 &m2)
throw();
1295 template <
class M1,
class M2>
friend bool _mmless(
const M1 &m1,
const M2 &m2)
throw();
1296 template <
class M1,
class M2>
friend bool _mmleq(
const M1 &m1,
const M2 &m2)
throw();
1297 template <
class M,
class MS>
friend bool _mmseq(
const M &m1,
const MS &ms)
throw();
1298 template <
class M,
class MS>
friend bool _mmsneq(
const M &m1,
const MS &ms)
throw();
1299 template <
class M,
class MS>
friend bool _mmsless(
const M &m1,
const MS &ms)
throw();
1300 template <
class M,
class MS>
friend bool _mmsleq(
const M &m1,
const MS &ms)
throw();
1301 template <
class MS,
class M>
friend bool _msmless(
const MS &ms,
const M &m1)
throw();
1302 template <
class MS,
class M>
friend bool _msmleq(
const MS &ms,
const M &m1)
throw();
1303 template <
class M>
friend std::ostream &_mout(std::ostream &s,
const M &r)
throw();
1304 template <
class M>
friend std::istream &_min(std::istream &s,M &r)
throw();
1313 template <
class MS,
class V,
class E>
friend E _msvcimult(
const MS &ms,
const V &v)
1314 #if(CXSC_INDEX_CHECK) 1315 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1319 template <
class V,
class MS,
class E>
friend E _vmscimult(
const V &v,
const MS &ms)
1320 #if(CXSC_INDEX_CHECK) 1321 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1370 explicit INLINE
cimatrix(
const int &m,
const int &n)
1371 #if(CXSC_INDEX_CHECK) 1372 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
1376 explicit INLINE
cimatrix(
const int &m1,
const int &n1,
const int &m2,
const int &n2)
1378 #if(CXSC_INDEX_CHECK) 1379 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
1495 INLINE ~
cimatrix()
throw() {
delete [] dat; }
1595 #if(CXSC_INDEX_CHECK) 1596 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1602 #if(CXSC_INDEX_CHECK) 1603 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1609 #if(CXSC_INDEX_CHECK) 1610 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1616 #if(CXSC_INDEX_CHECK) 1617 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
1626 #if(CXSC_INDEX_CHECK) 1627 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
1633 #if(CXSC_INDEX_CHECK) 1634 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
1638 INLINE
operator void*()
throw();
1655 int offset1,offset2,mxsize,mysize;
1656 int start1,end1,start2,end2,sxsize,sysize;
1660 #ifdef _CXSC_FRIEND_TPL 1662 template <
class V,
class MS,
class S>
friend void _vmsconstr(V &v,
const MS &m)
1663 #if(CXSC_INDEX_CHECK) 1664 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1668 template <
class MS,
class M>
friend MS &_msmassign(MS &ms,
const M &m)
1669 #if(CXSC_INDEX_CHECK) 1670 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1674 template <
class MS1,
class MS2>
friend MS1 &_msmsassign(MS1 &ms1,
const MS2 &ms)
1675 #if(CXSC_INDEX_CHECK) 1676 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1680 template <
class M,
class MS2,
class S>
friend M &_mmsassign(M &m,
const MS2 &ms)
throw();
1681 template <
class MS,
class S>
friend MS &_mssassign(MS &ms,
const S &r)
throw();
1682 template <
class MS>
friend int _mslb(
const MS &ms,
const int &i)
1683 #if(CXSC_INDEX_CHECK) 1684 throw(ERROR__WRONG_ROW_OR_COL<MS>);
1688 template <
class MS>
friend int _msub(
const MS &ms,
const int &i)
1689 #if(CXSC_INDEX_CHECK) 1690 throw(ERROR__WRONG_ROW_OR_COL<MS>);
1694 template <
class MS,
class E>
friend E _msabs(
const MS &ms)
throw();
1695 template <
class MS,
class E>
friend E _msinf(
const MS &ms)
throw();
1696 template <
class MS,
class E>
friend E _mssup(
const MS &ms)
throw();
1697 template <
class MS,
class E>
friend E _msdiam(
const MS &ms)
throw();
1698 template <
class MS,
class E>
friend E _msmid(
const MS &ms)
throw();
1699 template <
class MS,
class E>
friend E _msre(
const MS &ms)
throw();
1700 template <
class MS,
class E>
friend E _msim(
const MS &ms)
throw();
1705 template <
class MS1,
class M2>
friend MS1 &_msmsetre(MS1 &ms1,
const M2 &m2)
1706 #if(CXSC_INDEX_CHECK) 1707 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1711 template <
class MS1,
class M2>
friend MS1 &_msmsetim(MS1 &ms1,
const M2 &m2)
1712 #if(CXSC_INDEX_CHECK) 1713 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1717 template <
class MS1,
class MS2>
friend MS1 &_msmssetre(MS1 &ms1,
const MS2 &ms2)
1718 #if(CXSC_INDEX_CHECK) 1719 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1723 template <
class MS1,
class MS2>
friend MS1 &_msmssetim(MS1 &ms1,
const MS2 &ms2)
1724 #if(CXSC_INDEX_CHECK) 1725 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1729 template <
class MS1,
class M2>
friend MS1 &_msmsetinf(MS1 &ms1,
const M2 &m2)
1730 #if(CXSC_INDEX_CHECK) 1731 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1735 template <
class MS1,
class M2>
friend MS1 &_msmsetsup(MS1 &ms1,
const M2 &m2)
1736 #if(CXSC_INDEX_CHECK) 1737 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1741 template <
class MS1,
class MS2>
friend MS1 &_msmssetinf(MS1 &ms1,
const MS2 &ms2)
1742 #if(CXSC_INDEX_CHECK) 1743 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1747 template <
class MS1,
class MS2>
friend MS1 &_msmssetsup(MS1 &ms1,
const MS2 &ms2)
1748 #if(CXSC_INDEX_CHECK) 1749 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1753 template <
class MS1,
class M2>
friend MS1 &_msmusetinf(MS1 &ms1,
const M2 &m2)
1754 #if(CXSC_INDEX_CHECK) 1755 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1759 template <
class MS1,
class M2>
friend MS1 &_msmusetsup(MS1 &ms1,
const M2 &m2)
1760 #if(CXSC_INDEX_CHECK) 1761 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1765 template <
class MS1,
class MS2>
friend MS1 &_msmsusetinf(MS1 &ms1,
const MS2 &ms2)
1766 #if(CXSC_INDEX_CHECK) 1767 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1771 template <
class MS1,
class MS2>
friend MS1 &_msmsusetsup(MS1 &ms1,
const MS2 &ms2)
1772 #if(CXSC_INDEX_CHECK) 1773 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1778 template <
class MS,
class E>
friend E _msminus(
const MS &ms)
throw();
1779 template <
class M,
class MS,
class E>
friend E _mmsplus(
const M &m,
const MS &ms)
1780 #if(CXSC_INDEX_CHECK) 1781 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1785 template <
class MS1,
class MS2,
class E>
friend E _msmsplus(
const MS1 &m1,
const MS2 &m2)
1786 #if(CXSC_INDEX_CHECK) 1787 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1791 template <
class M,
class MS>
friend M &_mmsplusassign(M &m1,
const MS &ms)
1792 #if(CXSC_INDEX_CHECK) 1793 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1797 template <
class MS,
class M>
friend MS &_msmplusassign(MS &ms,
const M &m1)
1798 #if(CXSC_INDEX_CHECK) 1799 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1803 template <
class MS1,
class MS2>
friend MS1 &_msmsplusassign(MS1 &ms1,
const MS2 &ms2)
1804 #if(CXSC_INDEX_CHECK) 1805 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1809 template <
class M,
class MS,
class E>
friend E _mmsminus(
const M &m,
const MS &ms)
1810 #if(CXSC_INDEX_CHECK) 1811 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1815 template <
class MS,
class M,
class E>
friend E _msmminus(
const MS &ms,
const M &m)
1816 #if(CXSC_INDEX_CHECK) 1817 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1821 template <
class MS1,
class MS2,
class E>
friend E _msmsminus(
const MS1 &ms1,
const MS2 &ms2)
1822 #if(CXSC_INDEX_CHECK) 1823 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1827 template <
class M,
class MS>
friend M &_mmsminusassign(M &m1,
const MS &ms)
1828 #if(CXSC_INDEX_CHECK) 1829 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1833 template <
class MS,
class M>
friend MS &_msmminusassign(MS &ms,
const M &m1)
1834 #if(CXSC_INDEX_CHECK) 1835 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1839 template <
class MS1,
class MS2>
friend MS1 &_msmsminusassign(MS1 &ms1,
const MS2 &ms2)
1840 #if(CXSC_INDEX_CHECK) 1841 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1845 template <
class M,
class MS,
class E>
friend E _mmscimult(
const M &m1,
const MS &ms)
1846 #if(CXSC_INDEX_CHECK) 1847 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1851 template <
class MS,
class M,
class E>
friend E _msmcimult(
const MS &ms,
const M &m2)
1852 #if(CXSC_INDEX_CHECK) 1853 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1857 template <
class M,
class MS,
class S>
friend M &_mmscimultassign(M &m1,
const MS &ms)
1858 #if(CXSC_INDEX_CHECK) 1859 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1863 template <
class MS1,
class MS2,
class E>
friend E _msmscimult(
const MS1 &ms1,
const MS2 &ms2)
1864 #if(CXSC_INDEX_CHECK) 1865 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1869 template <
class M,
class MS,
class E>
friend E _mmsconv(
const M &m,
const MS &ms)
1870 #if(CXSC_INDEX_CHECK) 1871 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1875 template <
class M,
class MS>
friend M &_mmsconvassign(M &m1,
const MS &ms)
1876 #if(CXSC_INDEX_CHECK) 1877 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1881 template <
class MS,
class M>
friend MS &_msmconvassign(MS &ms,
const M &m1)
1882 #if(CXSC_INDEX_CHECK) 1883 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1887 template <
class MS1,
class MS2>
friend MS1 &_msmsconvassign(MS1 &ms1,
const MS2 &ms2)
1888 #if(CXSC_INDEX_CHECK) 1889 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1893 template <
class MS1,
class MS2,
class E>
friend E _msmsconv(
const MS1 &m1,
const MS2 &m2)
1894 #if(CXSC_INDEX_CHECK) 1895 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1899 template <
class M,
class MS,
class E>
friend E _mmssect(
const M &m,
const MS &ms)
1900 #if(CXSC_INDEX_CHECK) 1901 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1905 template <
class M,
class MS>
friend M &_mmssectassign(M &m1,
const MS &ms)
1906 #if(CXSC_INDEX_CHECK) 1907 throw(ERROR__OP_WITH_WRONG_DIM<M>);
1911 template <
class MS,
class M>
friend MS &_msmsectassign(MS &ms,
const M &m1)
1912 #if(CXSC_INDEX_CHECK) 1913 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1917 template <
class MS1,
class MS2>
friend MS1 &_msmssectassign(MS1 &ms1,
const MS2 &ms2)
1918 #if(CXSC_INDEX_CHECK) 1919 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1923 template <
class MS1,
class MS2,
class E>
friend E _msmssect(
const MS1 &m1,
const MS2 &m2)
1924 #if(CXSC_INDEX_CHECK) 1925 throw(ERROR__OP_WITH_WRONG_DIM<E>);
1930 template <
class MS,
class V,
class E>
friend E _msvcimult(
const MS &ms,
const V &v)
1931 #if(CXSC_INDEX_CHECK) 1932 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1936 template <
class V,
class MS,
class E>
friend E _vmscimult(
const V &v,
const MS &ms)
1937 #if(CXSC_INDEX_CHECK) 1938 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1942 template <
class V,
class MS,
class S>
friend V &_vmscimultassign(V &v,
const MS &ms)
1943 #if(CXSC_INDEX_CHECK) 1944 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1949 template <
class S,
class MS,
class E>
friend E _smsmult(
const S &c,
const MS &ms)
throw();
1950 template <
class MS,
class S>
friend MS &_mssmultassign(MS &ms,
const S &c)
throw();
1951 template <
class MS,
class S,
class E>
friend E _mssdiv(
const MS &ms,
const S &c)
throw();
1952 template <
class MS,
class S>
friend MS &_mssdivassign(MS &ms,
const S &c)
throw();
1954 template <
class MS>
friend void *_msvoid(
const MS &ms)
throw();
1955 template <
class MS>
friend bool _msnot(
const MS &ms)
throw();
1956 template <
class M,
class MS>
friend bool _mmseq(
const M &m1,
const MS &ms)
throw();
1957 template <
class M,
class MS>
friend bool _mmsneq(
const M &m1,
const MS &ms)
throw();
1958 template <
class M,
class MS>
friend bool _mmsless(
const M &m1,
const MS &ms)
throw();
1959 template <
class M,
class MS>
friend bool _mmsleq(
const M &m1,
const MS &ms)
throw();
1960 template <
class MS,
class M>
friend bool _msmless(
const MS &ms,
const M &m1)
throw();
1961 template <
class MS,
class M>
friend bool _msmleq(
const MS &ms,
const M &m1)
throw();
1962 template <
class MS1,
class MS2>
friend bool _msmseq(
const MS1 &ms1,
const MS2 &ms2)
throw();
1963 template <
class MS1,
class MS2>
friend bool _msmsneq(
const MS1 &ms1,
const MS2 &ms2)
throw();
1964 template <
class MS1,
class MS2>
friend bool _msmsless(
const MS1 &ms1,
const MS2 &ms2)
throw();
1965 template <
class MS1,
class MS2>
friend bool _msmsleq(
const MS1 &ms1,
const MS2 &ms2)
throw();
1966 template <
class MS>
friend std::ostream &_msout(std::ostream &s,
const MS &r)
throw();
1967 template <
class MS>
friend std::istream &_msin(std::istream &s,MS &r)
throw();
2003 explicit INLINE
cimatrix_slice(
cimatrix &a,
const int &l1,
const int &u1,
const int &l2,
const int &u2)
throw():dat(a.dat),offset1(l1-a.lb1),offset2(l2-a.lb2),mxsize(a.xsize),mysize(a.ysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
2005 explicit INLINE
cimatrix_slice(
cimatrix_slice &a,
const int &l1,
const int &u1,
const int &l2,
const int &u2)
throw():dat(a.dat),offset1(a.offset1+l1-a.start1),offset2(a.offset2+l2-a.start2),mxsize(a.mxsize),mysize(a.mysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
2008 INLINE
cimatrix_slice(
const cimatrix_slice &ms)
throw():dat(ms.dat),offset1(ms.offset1),offset2(ms.offset2),mxsize(ms.mxsize),mysize(ms.mysize),start1(ms.start1),end1(ms.end1),start2(ms.start2),end2(ms.end2),sxsize(ms.sxsize),sysize(ms.sysize) { }
2014 #if(CXSC_INDEX_CHECK) 2015 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
2022 #if(CXSC_INDEX_CHECK) 2023 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2029 #if(CXSC_INDEX_CHECK) 2030 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2044 #if(CXSC_INDEX_CHECK) 2045 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2051 #if(CXSC_INDEX_CHECK) 2052 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2058 #if(CXSC_INDEX_CHECK) 2059 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2072 #if(CXSC_INDEX_CHECK) 2073 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2079 #if(CXSC_INDEX_CHECK) 2080 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2088 #if(CXSC_INDEX_CHECK) 2089 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2095 #if(CXSC_INDEX_CHECK) 2096 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2102 #if(CXSC_INDEX_CHECK) 2103 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2117 #if(CXSC_INDEX_CHECK) 2118 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2124 #if(CXSC_INDEX_CHECK) 2125 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2133 #if(CXSC_INDEX_CHECK) 2134 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2140 #if(CXSC_INDEX_CHECK) 2141 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2147 #if(CXSC_INDEX_CHECK) 2148 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2162 #if(CXSC_INDEX_CHECK) 2163 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2169 #if(CXSC_INDEX_CHECK) 2170 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2178 #if(CXSC_INDEX_CHECK) 2179 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2185 #if(CXSC_INDEX_CHECK) 2186 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2192 #if(CXSC_INDEX_CHECK) 2193 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2200 #if(CXSC_INDEX_CHECK) 2201 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2207 #if(CXSC_INDEX_CHECK) 2208 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2215 #if(CXSC_INDEX_CHECK) 2216 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2222 #if(CXSC_INDEX_CHECK) 2223 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
2232 #if(CXSC_INDEX_CHECK) 2233 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
2239 #if(CXSC_INDEX_CHECK) 2240 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
2244 INLINE
operator void*()
throw();
2277 #if(CXSC_INDEX_CHECK) 2278 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2284 #if(CXSC_INDEX_CHECK) 2285 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2291 #if(CXSC_INDEX_CHECK) 2292 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2298 #if(CXSC_INDEX_CHECK) 2299 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2305 #if(CXSC_INDEX_CHECK) 2306 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2312 #if(CXSC_INDEX_CHECK) 2313 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2319 #if(CXSC_INDEX_CHECK) 2320 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2326 #if(CXSC_INDEX_CHECK) 2327 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2333 #if(CXSC_INDEX_CHECK) 2334 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2340 #if(CXSC_INDEX_CHECK) 2341 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2377 #if(CXSC_INDEX_CHECK) 2378 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2384 #if(CXSC_INDEX_CHECK) 2385 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2391 #if(CXSC_INDEX_CHECK) 2392 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2398 #if(CXSC_INDEX_CHECK) 2399 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2405 #if(CXSC_INDEX_CHECK) 2406 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2412 #if(CXSC_INDEX_CHECK) 2413 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2419 #if(CXSC_INDEX_CHECK) 2420 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2426 #if(CXSC_INDEX_CHECK) 2427 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2433 #if(CXSC_INDEX_CHECK) 2434 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2440 #if(CXSC_INDEX_CHECK) 2441 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2477 #if(CXSC_INDEX_CHECK) 2478 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2484 #if(CXSC_INDEX_CHECK) 2485 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2491 #if(CXSC_INDEX_CHECK) 2492 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2498 #if(CXSC_INDEX_CHECK) 2499 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2505 #if(CXSC_INDEX_CHECK) 2506 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2512 #if(CXSC_INDEX_CHECK) 2513 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2519 #if(CXSC_INDEX_CHECK) 2520 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2526 #if(CXSC_INDEX_CHECK) 2527 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2533 #if(CXSC_INDEX_CHECK) 2534 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2540 #if(CXSC_INDEX_CHECK) 2541 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2577 #if(CXSC_INDEX_CHECK) 2578 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2584 #if(CXSC_INDEX_CHECK) 2585 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2591 #if(CXSC_INDEX_CHECK) 2592 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2598 #if(CXSC_INDEX_CHECK) 2599 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2605 #if(CXSC_INDEX_CHECK) 2606 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2612 #if(CXSC_INDEX_CHECK) 2613 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2619 #if(CXSC_INDEX_CHECK) 2620 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2626 #if(CXSC_INDEX_CHECK) 2627 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2633 #if(CXSC_INDEX_CHECK) 2634 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2640 #if(CXSC_INDEX_CHECK) 2641 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2656 INLINE civector
operator /(
const cimatrix_subv &rv,
const cinterval &s)
throw();
2658 INLINE civector
operator *(
const cimatrix_subv &rv,
const cinterval &s)
throw();
2660 INLINE civector
operator *(
const cinterval &s,
const cimatrix_subv &rv)
throw();
2662 INLINE ivector
abs(
const cimatrix_subv &mv)
throw();
2664 INLINE cvector
diam(
const cimatrix_subv &mv)
throw();
2666 INLINE cvector
mid(
const cimatrix_subv &mv)
throw();
2668 INLINE cvector Inf(
const cimatrix_subv &mv)
throw();
2670 INLINE cvector Sup(
const cimatrix_subv &mv)
throw();
2672 INLINE ivector Im(
const cimatrix_subv &mv)
throw();
2674 INLINE ivector Re(
const cimatrix_subv &mv)
throw();
2676 INLINE rmatrix SupRe(
const cimatrix &v)
throw();
2678 INLINE rmatrix SupIm(
const cimatrix &v)
throw();
2680 INLINE rmatrix InfRe(
const cimatrix &v)
throw();
2682 INLINE rmatrix InfIm(
const cimatrix &v)
throw();
2684 INLINE rmatrix SupRe(
const cimatrix_slice &v)
throw();
2686 INLINE rmatrix SupIm(
const cimatrix_slice &v)
throw();
2688 INLINE rmatrix InfRe(
const cimatrix_slice &v)
throw();
2690 INLINE rmatrix InfIm(
const cimatrix_slice &v)
throw();
2692 INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,
const cvector &rv)
2693 #if(CXSC_INDEX_CHECK) 2694 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2698 INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,
const cvector &rv)
2700 #if(CXSC_INDEX_CHECK) 2701 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2705 INLINE cimatrix_subv &UncheckedSetInf(cimatrix_subv &iv,
const cvector &rv)
2707 #if(CXSC_INDEX_CHECK) 2708 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2712 INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,
const cvector &rv)
2714 #if(CXSC_INDEX_CHECK) 2715 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2719 INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,
const ivector &rv)
2721 #if(CXSC_INDEX_CHECK) 2722 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2726 INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,
const ivector &rv)
2728 #if(CXSC_INDEX_CHECK) 2729 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
2735 INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,
const complex &r)
throw();
2737 INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,
const complex &r)
throw();
2739 INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,
const complex &r)
throw();
2741 INLINE cimatrix_subv &
SetUncheckedInf(cimatrix_subv &iv,
const complex &r)
throw();
2743 INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,
const interval &r)
throw();
2745 INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,
const interval &r)
throw();
2751 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const cimatrix_subv &rv2)
2752 #if(CXSC_INDEX_CHECK) 2753 throw(OP_WITH_WRONG_DIM);
2757 void accumulate(cidotprecision &dp,
const civector & rv1,
const cimatrix_subv &rv2)
2759 #if(CXSC_INDEX_CHECK) 2760 throw(OP_WITH_WRONG_DIM);
2764 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const civector &rv2)
2766 #if(CXSC_INDEX_CHECK) 2767 throw(OP_WITH_WRONG_DIM);
2771 void accumulate(cidotprecision &dp,
const civector_slice & sl1,
const cimatrix_subv &rv2)
2773 #if(CXSC_INDEX_CHECK) 2774 throw(OP_WITH_WRONG_DIM);
2778 void accumulate(cidotprecision &dp,
const civector_slice & sl1,
const rmatrix_subv &rv2)
2780 #if(CXSC_INDEX_CHECK) 2781 throw(OP_WITH_WRONG_DIM);
2785 void accumulate(cidotprecision &dp,
const civector_slice & sl1,
const cmatrix_subv &rv2)
2787 #if(CXSC_INDEX_CHECK) 2788 throw(OP_WITH_WRONG_DIM);
2794 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const civector_slice &sl2)
2795 #if(CXSC_INDEX_CHECK) 2796 throw(OP_WITH_WRONG_DIM);
2802 INLINE cinterval
operator *(
const cimatrix_subv & rv1,
const cimatrix_subv &rv2)
2803 #if(CXSC_INDEX_CHECK) 2804 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2808 INLINE cinterval
operator *(
const civector & rv1,
const cimatrix_subv &rv2)
2810 #if(CXSC_INDEX_CHECK) 2811 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2815 INLINE cinterval
operator *(
const cimatrix_subv &rv1,
const civector &rv2)
2817 #if(CXSC_INDEX_CHECK) 2818 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2822 INLINE cinterval
operator *(
const civector_slice &sl,
const cimatrix_subv &sv)
2824 #if(CXSC_INDEX_CHECK) 2825 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2829 INLINE cinterval
operator *(
const cimatrix_subv &mv,
const civector_slice &vs)
2831 #if(CXSC_INDEX_CHECK) 2832 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2838 INLINE civector operator +(
const cimatrix_subv & rv1,
const cimatrix_subv &rv2)
2839 #if(CXSC_INDEX_CHECK) 2840 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2844 INLINE civector operator +(
const cimatrix_subv &rv1,
const civector &rv2)
2846 #if(CXSC_INDEX_CHECK) 2847 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2851 INLINE civector operator +(
const civector & rv1,
const cimatrix_subv &rv2)
2853 #if(CXSC_INDEX_CHECK) 2854 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2858 INLINE civector operator +(
const civector_slice &sl,
const cimatrix_subv &mv)
2860 #if(CXSC_INDEX_CHECK) 2861 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2865 INLINE civector operator +(
const cimatrix_subv &mv,
const civector_slice &sl)
2867 #if(CXSC_INDEX_CHECK) 2868 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2874 INLINE civector operator -(
const cimatrix_subv & rv1,
const cimatrix_subv &rv2)
2875 #if(CXSC_INDEX_CHECK) 2876 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2880 INLINE civector operator -(
const civector & rv1,
const cimatrix_subv &rv2)
2882 #if(CXSC_INDEX_CHECK) 2883 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2887 INLINE civector operator -(
const cimatrix_subv &rv1,
const civector &rv2)
2889 #if(CXSC_INDEX_CHECK) 2890 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2894 INLINE civector operator -(
const civector_slice &sl,
const cimatrix_subv &mv)
2896 #if(CXSC_INDEX_CHECK) 2897 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2901 INLINE civector operator -(
const cimatrix_subv &mv,
const civector_slice &sl)
2903 #if(CXSC_INDEX_CHECK) 2904 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2912 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const rmatrix_subv &rv2)
2913 #if(CXSC_INDEX_CHECK) 2914 throw(OP_WITH_WRONG_DIM);
2918 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const rvector_slice &sl2)
2920 #if(CXSC_INDEX_CHECK) 2921 throw(OP_WITH_WRONG_DIM);
2925 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const rvector &rv2)
2927 #if(CXSC_INDEX_CHECK) 2928 throw(OP_WITH_WRONG_DIM);
2932 void accumulate(cidotprecision &dp,
const rvector & rv1,
const cimatrix_subv &rv2)
2934 #if(CXSC_INDEX_CHECK) 2935 throw(OP_WITH_WRONG_DIM);
2939 void accumulate(cidotprecision &dp,
const rmatrix_subv & rv1,
const cimatrix_subv &rv2)
2941 #if(CXSC_INDEX_CHECK) 2942 throw(OP_WITH_WRONG_DIM);
2946 void accumulate(cidotprecision &dp,
const rvector_slice & sl1,
const cimatrix_subv &rv2)
2948 #if(CXSC_INDEX_CHECK) 2949 throw(OP_WITH_WRONG_DIM);
2957 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const cmatrix_subv &rv2)
2958 #if(CXSC_INDEX_CHECK) 2959 throw(OP_WITH_WRONG_DIM);
2963 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const cvector_slice &sl2)
2965 #if(CXSC_INDEX_CHECK) 2966 throw(OP_WITH_WRONG_DIM);
2970 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const cvector &rv2)
2972 #if(CXSC_INDEX_CHECK) 2973 throw(OP_WITH_WRONG_DIM);
2977 void accumulate(cidotprecision &dp,
const cvector & rv1,
const cimatrix_subv &rv2)
2979 #if(CXSC_INDEX_CHECK) 2980 throw(OP_WITH_WRONG_DIM);
2984 void accumulate(cidotprecision &dp,
const cmatrix_subv & rv1,
const cimatrix_subv &rv2)
2986 #if(CXSC_INDEX_CHECK) 2987 throw(OP_WITH_WRONG_DIM);
2991 void accumulate(cidotprecision &dp,
const cvector_slice & sl1,
const cimatrix_subv &rv2)
2993 #if(CXSC_INDEX_CHECK) 2994 throw(OP_WITH_WRONG_DIM);
3002 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const imatrix_subv &rv2)
3003 #if(CXSC_INDEX_CHECK) 3004 throw(OP_WITH_WRONG_DIM);
3008 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const ivector_slice &sl2)
3010 #if(CXSC_INDEX_CHECK) 3011 throw(OP_WITH_WRONG_DIM);
3015 void accumulate(cidotprecision &dp,
const cimatrix_subv & rv1,
const ivector &rv2)
3017 #if(CXSC_INDEX_CHECK) 3018 throw(OP_WITH_WRONG_DIM);
3022 void accumulate(cidotprecision &dp,
const ivector & rv1,
const cimatrix_subv &rv2)
3024 #if(CXSC_INDEX_CHECK) 3025 throw(OP_WITH_WRONG_DIM);
3029 void accumulate(cidotprecision &dp,
const imatrix_subv & rv1,
const cimatrix_subv &rv2)
3031 #if(CXSC_INDEX_CHECK) 3032 throw(OP_WITH_WRONG_DIM);
3036 void accumulate(cidotprecision &dp,
const ivector_slice & sl1,
const cimatrix_subv &rv2)
3038 #if(CXSC_INDEX_CHECK) 3039 throw(OP_WITH_WRONG_DIM);
3043 void accumulate(cidotprecision &dp,
const cmatrix_subv & rv1,
const imatrix_subv &rv2)
3045 #if(CXSC_INDEX_CHECK) 3046 throw(OP_WITH_WRONG_DIM);
3050 void accumulate(cidotprecision &dp,
const imatrix_subv & rv1,
const cmatrix_subv &rv2)
3052 #if(CXSC_INDEX_CHECK) 3053 throw(OP_WITH_WRONG_DIM);
3063 INLINE cimatrix
_imatrix(
const cimatrix &rm)
throw();
3065 INLINE cimatrix
_imatrix(
const civector &v)
throw();
3067 INLINE cimatrix
_imatrix(
const civector_slice &v)
throw();
3069 INLINE cimatrix
_imatrix(
const cinterval &r)
throw();
3072 INLINE
int Lb(
const cimatrix &rm,
const int &i)
3073 #if(CXSC_INDEX_CHECK) 3074 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3078 INLINE
int Ub(
const cimatrix &rm,
const int &i)
3080 #if(CXSC_INDEX_CHECK) 3081 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3085 INLINE
int Lb(
const cimatrix_slice &rm,
const int &i)
3087 #if(CXSC_INDEX_CHECK) 3088 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3092 INLINE
int Ub(
const cimatrix_slice &rm,
const int &i)
3094 #if(CXSC_INDEX_CHECK) 3095 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3099 INLINE cimatrix &
SetLb(cimatrix &m,
const int &i,
const int &j)
3101 #if(CXSC_INDEX_CHECK) 3102 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3106 INLINE cimatrix &
SetUb(cimatrix &m,
const int &i,
const int &j)
3108 #if(CXSC_INDEX_CHECK) 3109 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
3113 INLINE
void Resize(cimatrix &A)
throw();
3116 INLINE
void Resize(cimatrix &A,
const int &m,
const int &n)
3117 #if(CXSC_INDEX_CHECK) 3118 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
3122 INLINE
void Resize(cimatrix &A,
const int &m1,
const int &m2,
const int &n1,
const int &n2)
3124 #if(CXSC_INDEX_CHECK) 3125 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
3131 INLINE imatrix
abs(
const cimatrix &m)
throw();
3133 INLINE imatrix
abs(
const cimatrix_slice &ms)
throw();
3135 INLINE cmatrix
diam(
const cimatrix &m)
throw();
3137 INLINE cmatrix
diam(
const cimatrix_slice &m)
throw();
3139 INLINE cmatrix
mid(
const cimatrix &m)
throw();
3141 INLINE cmatrix
mid(
const cimatrix_slice &m)
throw();
3143 INLINE cmatrix Inf(
const cimatrix &m)
throw();
3145 INLINE cmatrix Sup(
const cimatrix &m)
throw();
3147 INLINE cmatrix Inf(
const cimatrix_slice &m)
throw();
3149 INLINE cmatrix Sup(
const cimatrix_slice &m)
throw();
3151 INLINE cimatrix &SetInf(cimatrix &cm,
const cmatrix &rm)
3152 #if(CXSC_INDEX_CHECK) 3153 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3157 INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,
const cmatrix &rm)
3159 #if(CXSC_INDEX_CHECK) 3160 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3164 INLINE cimatrix &SetInf(cimatrix &cm,
const cmatrix_slice &rm)
3166 #if(CXSC_INDEX_CHECK) 3167 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3171 INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,
const cmatrix_slice &rm)
3173 #if(CXSC_INDEX_CHECK) 3174 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3178 INLINE cimatrix &SetSup(cimatrix &cm,
const cmatrix &rm)
3180 #if(CXSC_INDEX_CHECK) 3181 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3185 INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,
const cmatrix &rm)
3187 #if(CXSC_INDEX_CHECK) 3188 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3192 INLINE cimatrix &SetSup(cimatrix &cm,
const cmatrix_slice &rm)
3194 #if(CXSC_INDEX_CHECK) 3195 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3199 INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,
const cmatrix_slice &rm)
3201 #if(CXSC_INDEX_CHECK) 3202 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3206 INLINE cimatrix &UncheckedSetInf(cimatrix &cm,
const cmatrix &rm)
3208 #if(CXSC_INDEX_CHECK) 3209 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3213 INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,
const cmatrix &rm)
3215 #if(CXSC_INDEX_CHECK) 3216 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3220 INLINE cimatrix &UncheckedSetInf(cimatrix &cm,
const cmatrix_slice &rm)
3222 #if(CXSC_INDEX_CHECK) 3223 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3227 INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,
const cmatrix_slice &rm)
3229 #if(CXSC_INDEX_CHECK) 3230 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3234 INLINE cimatrix &UncheckedSetSup(cimatrix &cm,
const cmatrix &rm)
3236 #if(CXSC_INDEX_CHECK) 3237 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3241 INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,
const cmatrix &rm)
3243 #if(CXSC_INDEX_CHECK) 3244 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3248 INLINE cimatrix &UncheckedSetSup(cimatrix &cm,
const cmatrix_slice &rm)
3250 #if(CXSC_INDEX_CHECK) 3251 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3255 INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,
const cmatrix_slice &rm)
3257 #if(CXSC_INDEX_CHECK) 3258 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3264 INLINE imatrix Im(
const cimatrix &m)
throw();
3266 INLINE imatrix Re(
const cimatrix &m)
throw();
3268 INLINE imatrix Im(
const cimatrix_slice &m)
throw();
3270 INLINE imatrix Re(
const cimatrix_slice &m)
throw();
3272 INLINE cimatrix &SetIm(cimatrix &cm,
const imatrix &rm)
3273 #if(CXSC_INDEX_CHECK) 3274 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3278 INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,
const imatrix &rm)
3280 #if(CXSC_INDEX_CHECK) 3281 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3285 INLINE cimatrix &SetIm(cimatrix &cm,
const imatrix_slice &rm)
3287 #if(CXSC_INDEX_CHECK) 3288 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3292 INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,
const imatrix_slice &rm)
3294 #if(CXSC_INDEX_CHECK) 3295 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3299 INLINE cimatrix &SetRe(cimatrix &cm,
const imatrix &rm)
3301 #if(CXSC_INDEX_CHECK) 3302 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3306 INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,
const imatrix &rm)
3308 #if(CXSC_INDEX_CHECK) 3309 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3313 INLINE cimatrix &SetRe(cimatrix &cm,
const imatrix_slice &rm)
3315 #if(CXSC_INDEX_CHECK) 3316 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3320 INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,
const imatrix_slice &rm)
3322 #if(CXSC_INDEX_CHECK) 3323 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3331 INLINE cimatrix
operator *(
const cinterval &c,
const cimatrix &m)
throw();
3333 INLINE cimatrix
operator *(
const cinterval &c,
const cimatrix_slice &ms)
throw();
3335 INLINE cimatrix
operator *(
const cimatrix &m,
const cinterval &c)
throw();
3337 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const cinterval &c)
throw();
3339 INLINE cimatrix &
operator *=(cimatrix &m,
const cinterval &c)
throw();
3341 INLINE cimatrix
operator /(
const cimatrix &m,
const cinterval &c)
throw();
3343 INLINE cimatrix
operator /(
const cimatrix_slice &ms,
const cinterval &c)
throw();
3345 INLINE cimatrix &
operator /=(cimatrix &m,
const cinterval &c)
throw();
3350 INLINE cimatrix
operator *(
const real &c,
const cimatrix &m)
throw();
3352 INLINE cimatrix
operator *(
const real &c,
const cimatrix_slice &ms)
throw();
3354 INLINE cimatrix
operator *(
const cimatrix &m,
const real &c)
throw();
3356 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const real &c)
throw();
3358 INLINE cimatrix &
operator *=(cimatrix &m,
const real &c)
throw();
3360 INLINE cimatrix
operator /(
const cimatrix &m,
const real &c)
throw();
3362 INLINE cimatrix
operator /(
const cimatrix_slice &ms,
const real &c)
throw();
3364 INLINE cimatrix &
operator /=(cimatrix &m,
const real &c)
throw();
3368 INLINE cimatrix
operator *(
const cinterval &c,
const rmatrix &m)
throw();
3370 INLINE cimatrix
operator *(
const cinterval &c,
const rmatrix_slice &ms)
throw();
3372 INLINE cimatrix
operator *(
const rmatrix &m,
const cinterval &c)
throw();
3374 INLINE cimatrix
operator *(
const rmatrix_slice &ms,
const cinterval &c)
throw();
3376 INLINE cimatrix
operator /(
const rmatrix &m,
const cinterval &c)
throw();
3378 INLINE cimatrix
operator /(
const rmatrix_slice &ms,
const cinterval &c)
throw();
3383 INLINE cimatrix
operator *(
const complex &c,
const cimatrix &m)
throw();
3385 INLINE cimatrix
operator *(
const complex &c,
const cimatrix_slice &ms)
throw();
3387 INLINE cimatrix
operator *(
const cimatrix &m,
const complex &c)
throw();
3389 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const complex &c)
throw();
3391 INLINE cimatrix &
operator *=(cimatrix &m,
const complex &c)
throw();
3393 INLINE cimatrix
operator /(
const cimatrix &m,
const complex &c)
throw();
3395 INLINE cimatrix
operator /(
const cimatrix_slice &ms,
const complex &c)
throw();
3397 INLINE cimatrix &
operator /=(cimatrix &m,
const complex &c)
throw();
3401 INLINE cimatrix
operator *(
const cinterval &c,
const cmatrix &m)
throw();
3403 INLINE cimatrix
operator *(
const cinterval &c,
const cmatrix_slice &ms)
throw();
3405 INLINE cimatrix
operator *(
const cmatrix &m,
const cinterval &c)
throw();
3407 INLINE cimatrix
operator *(
const cmatrix_slice &ms,
const cinterval &c)
throw();
3409 INLINE cimatrix
operator /(
const cmatrix &m,
const cinterval &c)
throw();
3411 INLINE cimatrix
operator /(
const cmatrix_slice &ms,
const cinterval &c)
throw();
3416 INLINE cimatrix
operator *(
const interval &c,
const cimatrix &m)
throw();
3418 INLINE cimatrix
operator *(
const interval &c,
const cimatrix_slice &ms)
throw();
3420 INLINE cimatrix
operator *(
const cimatrix &m,
const interval &c)
throw();
3422 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const interval &c)
throw();
3424 INLINE cimatrix &
operator *=(cimatrix &m,
const interval &c)
throw();
3426 INLINE cimatrix
operator /(
const cimatrix &m,
const interval &c)
throw();
3428 INLINE cimatrix
operator /(
const cimatrix_slice &ms,
const interval &c)
throw();
3430 INLINE cimatrix &
operator /=(cimatrix &m,
const interval &c)
throw();
3434 INLINE cimatrix
operator *(
const cinterval &c,
const imatrix &m)
throw();
3436 INLINE cimatrix
operator *(
const cinterval &c,
const imatrix_slice &ms)
throw();
3438 INLINE cimatrix
operator *(
const imatrix &m,
const cinterval &c)
throw();
3440 INLINE cimatrix
operator *(
const imatrix_slice &ms,
const cinterval &c)
throw();
3442 INLINE cimatrix
operator /(
const imatrix &m,
const cinterval &c)
throw();
3444 INLINE cimatrix
operator /(
const imatrix_slice &ms,
const cinterval &c)
throw();
3451 INLINE civector
operator *(
const cimatrix &m,
const civector &v)
3452 #if(CXSC_INDEX_CHECK) 3453 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3457 INLINE civector
operator *(
const cimatrix_slice &ms,
const civector &v)
3459 #if(CXSC_INDEX_CHECK) 3460 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3464 INLINE civector
operator *(
const civector &v,
const cimatrix &m)
3466 #if(CXSC_INDEX_CHECK) 3467 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3471 INLINE civector
operator *(
const civector &v,
const cimatrix_slice &ms)
3473 #if(CXSC_INDEX_CHECK) 3474 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3478 INLINE civector &
operator *=(civector &v,
const cimatrix &m)
3480 #if(CXSC_INDEX_CHECK) 3481 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3485 INLINE civector &
operator *=(civector &v,
const cimatrix_slice &ms)
3487 #if(CXSC_INDEX_CHECK) 3488 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3494 INLINE civector
operator *(
const civector_slice &v,
const cimatrix &m)
3495 #if(CXSC_INDEX_CHECK) 3496 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3500 INLINE civector
operator *(
const civector_slice &v,
const cimatrix_slice &m)
3502 #if(CXSC_INDEX_CHECK) 3503 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3511 INLINE civector
operator *(
const rvector &v,
const cimatrix &m)
3512 #if(CXSC_INDEX_CHECK) 3513 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3517 INLINE civector
operator *(
const rvector &v,
const cimatrix_slice &ms)
3519 #if(CXSC_INDEX_CHECK) 3520 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3524 INLINE civector
operator *(
const rvector_slice &v,
const cimatrix &m)
3526 #if(CXSC_INDEX_CHECK) 3527 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3533 INLINE civector
operator *(
const cimatrix &m,
const rvector &v)
3534 #if(CXSC_INDEX_CHECK) 3535 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3539 INLINE civector
operator *(
const cimatrix_slice &ms,
const rvector &v)
3541 #if(CXSC_INDEX_CHECK) 3542 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3550 INLINE civector
operator *(
const cvector &v,
const cimatrix &m)
3551 #if(CXSC_INDEX_CHECK) 3552 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3556 INLINE civector
operator *(
const cvector &v,
const cimatrix_slice &ms)
3558 #if(CXSC_INDEX_CHECK) 3559 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3563 INLINE civector
operator *(
const cvector_slice &v,
const cimatrix &m)
3565 #if(CXSC_INDEX_CHECK) 3566 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3572 INLINE civector
operator *(
const cimatrix &m,
const cvector &v)
3573 #if(CXSC_INDEX_CHECK) 3574 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3578 INLINE civector
operator *(
const cimatrix_slice &ms,
const cvector &v)
3580 #if(CXSC_INDEX_CHECK) 3581 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3589 INLINE civector
operator *(
const ivector &v,
const cimatrix &m)
3590 #if(CXSC_INDEX_CHECK) 3591 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3595 INLINE civector
operator *(
const ivector &v,
const cimatrix_slice &ms)
3597 #if(CXSC_INDEX_CHECK) 3598 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3602 INLINE civector
operator *(
const ivector_slice &v,
const cimatrix &m)
3604 #if(CXSC_INDEX_CHECK) 3605 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3611 INLINE civector
operator *(
const cimatrix &m,
const ivector &v)
3612 #if(CXSC_INDEX_CHECK) 3613 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3617 INLINE civector
operator *(
const cimatrix_slice &ms,
const ivector &v)
3619 #if(CXSC_INDEX_CHECK) 3620 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3629 INLINE
const cimatrix &operator +(
const cimatrix &m1)
throw();
3631 INLINE cimatrix operator +(
const cimatrix_slice &ms)
throw();
3633 INLINE cimatrix operator +(
const cimatrix &m1,
const cimatrix &m2)
3634 #if(CXSC_INDEX_CHECK) 3635 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3639 INLINE cimatrix operator +(
const cimatrix &m,
const cimatrix_slice &ms)
3641 #if(CXSC_INDEX_CHECK) 3642 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3646 INLINE cimatrix operator +(
const cimatrix_slice &ms,
const cimatrix &m)
3648 #if(CXSC_INDEX_CHECK) 3649 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3653 INLINE cimatrix operator +(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
3655 #if(CXSC_INDEX_CHECK) 3656 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3660 INLINE cimatrix &
operator +=(cimatrix &m1,
const cimatrix &m2)
3662 #if(CXSC_INDEX_CHECK) 3663 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3667 INLINE cimatrix &
operator +=(cimatrix &m1,
const cimatrix_slice &ms)
3669 #if(CXSC_INDEX_CHECK) 3670 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3676 INLINE cimatrix operator -(
const cimatrix &m)
throw();
3678 INLINE cimatrix operator -(
const cimatrix_slice &ms)
throw();
3680 INLINE cimatrix operator -(
const cimatrix &m1,
const cimatrix &m2)
3681 #if(CXSC_INDEX_CHECK) 3682 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3686 INLINE cimatrix operator -(
const cimatrix &m,
const cimatrix_slice &ms)
3688 #if(CXSC_INDEX_CHECK) 3689 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3693 INLINE cimatrix operator -(
const cimatrix_slice &ms,
const cimatrix &m)
3695 #if(CXSC_INDEX_CHECK) 3696 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3700 INLINE cimatrix operator -(
const cimatrix_slice &ms1,
const cimatrix_slice &ms2)
3702 #if(CXSC_INDEX_CHECK) 3703 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3707 INLINE cimatrix &operator -=(cimatrix &m1,
const cimatrix &m2)
3709 #if(CXSC_INDEX_CHECK) 3710 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3714 INLINE cimatrix &operator -=(cimatrix &m1,
const cimatrix_slice &ms)
3716 #if(CXSC_INDEX_CHECK) 3717 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3723 INLINE cimatrix
operator *(
const cimatrix &m1,
const cimatrix &m2)
3724 #if(CXSC_INDEX_CHECK) 3725 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3729 INLINE cimatrix
operator *(
const cimatrix &m1,
const cimatrix_slice &ms)
3731 #if(CXSC_INDEX_CHECK) 3732 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3736 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const cimatrix &m1)
3738 #if(CXSC_INDEX_CHECK) 3739 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3743 INLINE cimatrix
operator *(
const cimatrix_slice &ms1,
const cimatrix_slice &ms2)
3745 #if(CXSC_INDEX_CHECK) 3746 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3750 INLINE cimatrix &
operator *=(cimatrix &m1,
const cimatrix &m2)
3752 #if(CXSC_INDEX_CHECK) 3753 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3757 INLINE cimatrix &
operator *=(cimatrix &m1,
const cimatrix_slice &ms)
3759 #if(CXSC_INDEX_CHECK) 3760 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3767 INLINE cimatrix operator |(
const cimatrix &m1,
const cimatrix &m2)
3768 #if(CXSC_INDEX_CHECK) 3769 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3773 INLINE cimatrix operator |(
const cimatrix &m,
const cimatrix_slice &ms)
3775 #if(CXSC_INDEX_CHECK) 3776 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3780 INLINE cimatrix operator |(
const cimatrix_slice &ms,
const cimatrix &m)
3782 #if(CXSC_INDEX_CHECK) 3783 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3787 INLINE cimatrix operator |(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
3789 #if(CXSC_INDEX_CHECK) 3790 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3794 INLINE cimatrix &operator |=(cimatrix &m1,
const cimatrix &m2)
3796 #if(CXSC_INDEX_CHECK) 3797 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3801 INLINE cimatrix &operator |=(cimatrix &m1,
const cimatrix_slice &ms)
3803 #if(CXSC_INDEX_CHECK) 3804 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3810 INLINE cimatrix operator &(
const cimatrix &m1,
const cimatrix &m2)
3811 #if(CXSC_INDEX_CHECK) 3812 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3816 INLINE cimatrix operator &(
const cimatrix &m,
const cimatrix_slice &ms)
3818 #if(CXSC_INDEX_CHECK) 3819 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3823 INLINE cimatrix operator &(
const cimatrix_slice &ms,
const cimatrix &m)
3825 #if(CXSC_INDEX_CHECK) 3826 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3830 INLINE cimatrix operator &(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
3832 #if(CXSC_INDEX_CHECK) 3833 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3837 INLINE cimatrix &operator &=(cimatrix &m1,
const cimatrix &m2)
3839 #if(CXSC_INDEX_CHECK) 3840 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3844 INLINE cimatrix &operator &=(cimatrix &m1,
const cimatrix_slice &ms)
3846 #if(CXSC_INDEX_CHECK) 3847 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3854 INLINE cimatrix operator +(
const rmatrix &m1,
const cimatrix &m2)
3855 #if(CXSC_INDEX_CHECK) 3856 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3860 INLINE cimatrix operator +(
const cimatrix &m1,
const rmatrix &m2)
3862 #if(CXSC_INDEX_CHECK) 3863 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3867 INLINE cimatrix operator +(
const rmatrix &m,
const cimatrix_slice &ms)
3869 #if(CXSC_INDEX_CHECK) 3870 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3874 INLINE cimatrix operator +(
const cimatrix &m,
const rmatrix_slice &ms)
3876 #if(CXSC_INDEX_CHECK) 3877 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3881 INLINE cimatrix operator +(
const rmatrix_slice &ms,
const cimatrix &m)
3883 #if(CXSC_INDEX_CHECK) 3884 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3888 INLINE cimatrix operator +(
const cimatrix_slice &ms,
const rmatrix &m)
3890 #if(CXSC_INDEX_CHECK) 3891 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3895 INLINE cimatrix operator +(
const rmatrix_slice &m1,
const cimatrix_slice &m2)
3897 #if(CXSC_INDEX_CHECK) 3898 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3902 INLINE cimatrix operator +(
const cimatrix_slice &m1,
const rmatrix_slice &m2)
3904 #if(CXSC_INDEX_CHECK) 3905 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3909 INLINE cimatrix &
operator +=(cimatrix &m1,
const rmatrix &m2)
3911 #if(CXSC_INDEX_CHECK) 3912 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3916 INLINE cimatrix &
operator +=(cimatrix &m1,
const rmatrix_slice &ms)
3918 #if(CXSC_INDEX_CHECK) 3919 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3925 INLINE cimatrix operator -(
const rmatrix &m1,
const cimatrix &m2)
3926 #if(CXSC_INDEX_CHECK) 3927 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3931 INLINE cimatrix operator -(
const cimatrix &m1,
const rmatrix &m2)
3933 #if(CXSC_INDEX_CHECK) 3934 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3938 INLINE cimatrix operator -(
const rmatrix &m,
const cimatrix_slice &ms)
3940 #if(CXSC_INDEX_CHECK) 3941 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3945 INLINE cimatrix operator -(
const cimatrix &m,
const rmatrix_slice &ms)
3947 #if(CXSC_INDEX_CHECK) 3948 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3952 INLINE cimatrix operator -(
const rmatrix_slice &ms,
const cimatrix &m)
3954 #if(CXSC_INDEX_CHECK) 3955 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3959 INLINE cimatrix operator -(
const cimatrix_slice &ms,
const rmatrix &m)
3961 #if(CXSC_INDEX_CHECK) 3962 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3966 INLINE cimatrix operator -(
const rmatrix_slice &ms1,
const cimatrix_slice &ms2)
3968 #if(CXSC_INDEX_CHECK) 3969 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3973 INLINE cimatrix operator -(
const cimatrix_slice &ms1,
const rmatrix_slice &ms2)
3975 #if(CXSC_INDEX_CHECK) 3976 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3980 INLINE cimatrix &operator -=(cimatrix &m1,
const rmatrix &m2)
3982 #if(CXSC_INDEX_CHECK) 3983 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3987 INLINE cimatrix &operator -=(cimatrix &m1,
const rmatrix_slice &ms)
3989 #if(CXSC_INDEX_CHECK) 3990 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
3996 INLINE cimatrix
operator *(
const rmatrix &m1,
const cimatrix &m2)
3997 #if(CXSC_INDEX_CHECK) 3998 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4002 INLINE cimatrix
operator *(
const cimatrix &m1,
const rmatrix &m2)
4004 #if(CXSC_INDEX_CHECK) 4005 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4009 INLINE cimatrix
operator *(
const rmatrix &m1,
const cimatrix_slice &ms)
4011 #if(CXSC_INDEX_CHECK) 4012 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4016 INLINE cimatrix
operator *(
const cimatrix &m1,
const rmatrix_slice &ms)
4018 #if(CXSC_INDEX_CHECK) 4019 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4023 INLINE cimatrix
operator *(
const rmatrix_slice &ms,
const cimatrix &m1)
4025 #if(CXSC_INDEX_CHECK) 4026 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4030 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const rmatrix &m1)
4032 #if(CXSC_INDEX_CHECK) 4033 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4037 INLINE cimatrix
operator *(
const rmatrix_slice &ms1,
const cimatrix_slice &ms2)
4039 #if(CXSC_INDEX_CHECK) 4040 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4044 INLINE cimatrix
operator *(
const cimatrix_slice &ms1,
const rmatrix_slice &ms2)
4046 #if(CXSC_INDEX_CHECK) 4047 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4051 INLINE cimatrix &
operator *=(cimatrix &m1,
const rmatrix &m2)
4053 #if(CXSC_INDEX_CHECK) 4054 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4058 INLINE cimatrix &
operator *=(cimatrix &m1,
const rmatrix_slice &ms)
4060 #if(CXSC_INDEX_CHECK) 4061 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4067 INLINE cimatrix operator |(
const rmatrix &m1,
const cimatrix &m2)
4068 #if(CXSC_INDEX_CHECK) 4069 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4073 INLINE cimatrix operator |(
const cimatrix &m1,
const rmatrix &m2)
4075 #if(CXSC_INDEX_CHECK) 4076 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4080 INLINE cimatrix operator |(
const rmatrix &m,
const cimatrix_slice &ms)
4082 #if(CXSC_INDEX_CHECK) 4083 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4087 INLINE cimatrix operator |(
const cimatrix &m,
const rmatrix_slice &ms)
4089 #if(CXSC_INDEX_CHECK) 4090 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4094 INLINE cimatrix operator |(
const rmatrix_slice &ms,
const cimatrix &m)
4096 #if(CXSC_INDEX_CHECK) 4097 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4101 INLINE cimatrix operator |(
const cimatrix_slice &ms,
const rmatrix &m)
4103 #if(CXSC_INDEX_CHECK) 4104 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4108 INLINE cimatrix operator |(
const rmatrix_slice &m1,
const cimatrix_slice &m2)
4110 #if(CXSC_INDEX_CHECK) 4111 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4115 INLINE cimatrix operator |(
const cimatrix_slice &m1,
const rmatrix_slice &m2)
4117 #if(CXSC_INDEX_CHECK) 4118 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4122 INLINE cimatrix &operator |=(cimatrix &m1,
const rmatrix &m2)
4124 #if(CXSC_INDEX_CHECK) 4125 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4129 INLINE cimatrix &operator |=(cimatrix &m1,
const rmatrix_slice &ms)
4131 #if(CXSC_INDEX_CHECK) 4132 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4138 INLINE cimatrix operator &(
const rmatrix &m1,
const cimatrix &m2)
4139 #if(CXSC_INDEX_CHECK) 4140 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4144 INLINE cimatrix operator &(
const cimatrix &m1,
const rmatrix &m2)
4146 #if(CXSC_INDEX_CHECK) 4147 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4151 INLINE cimatrix operator &(
const rmatrix &m,
const cimatrix_slice &ms)
4153 #if(CXSC_INDEX_CHECK) 4154 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4158 INLINE cimatrix operator &(
const cimatrix &m,
const rmatrix_slice &ms)
4160 #if(CXSC_INDEX_CHECK) 4161 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4165 INLINE cimatrix operator &(
const rmatrix_slice &ms,
const cimatrix &m)
4167 #if(CXSC_INDEX_CHECK) 4168 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4172 INLINE cimatrix operator &(
const cimatrix_slice &ms,
const rmatrix &m)
4174 #if(CXSC_INDEX_CHECK) 4175 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4179 INLINE cimatrix operator &(
const rmatrix_slice &m1,
const cimatrix_slice &m2)
4181 #if(CXSC_INDEX_CHECK) 4182 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4186 INLINE cimatrix operator &(
const cimatrix_slice &m1,
const rmatrix_slice &m2)
4188 #if(CXSC_INDEX_CHECK) 4189 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4193 INLINE cimatrix &operator &=(cimatrix &m1,
const rmatrix &m2)
4195 #if(CXSC_INDEX_CHECK) 4196 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4200 INLINE cimatrix &operator &=(cimatrix &m1,
const rmatrix_slice &ms)
4202 #if(CXSC_INDEX_CHECK) 4203 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4210 INLINE cimatrix operator +(
const cmatrix &m1,
const cimatrix &m2)
4211 #if(CXSC_INDEX_CHECK) 4212 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4216 INLINE cimatrix operator +(
const cimatrix &m1,
const cmatrix &m2)
4218 #if(CXSC_INDEX_CHECK) 4219 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4223 INLINE cimatrix operator +(
const cmatrix &m,
const cimatrix_slice &ms)
4225 #if(CXSC_INDEX_CHECK) 4226 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4230 INLINE cimatrix operator +(
const cimatrix &m,
const cmatrix_slice &ms)
4232 #if(CXSC_INDEX_CHECK) 4233 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4237 INLINE cimatrix operator +(
const cmatrix_slice &ms,
const cimatrix &m)
4239 #if(CXSC_INDEX_CHECK) 4240 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4244 INLINE cimatrix operator +(
const cimatrix_slice &ms,
const cmatrix &m)
4246 #if(CXSC_INDEX_CHECK) 4247 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4251 INLINE cimatrix operator +(
const cmatrix_slice &m1,
const cimatrix_slice &m2)
4253 #if(CXSC_INDEX_CHECK) 4254 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4258 INLINE cimatrix operator +(
const cimatrix_slice &m1,
const cmatrix_slice &m2)
4260 #if(CXSC_INDEX_CHECK) 4261 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4265 INLINE cimatrix &
operator +=(cimatrix &m1,
const cmatrix &m2)
4267 #if(CXSC_INDEX_CHECK) 4268 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4272 INLINE cimatrix &
operator +=(cimatrix &m1,
const cmatrix_slice &ms)
4274 #if(CXSC_INDEX_CHECK) 4275 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4281 INLINE cimatrix operator -(
const cmatrix &m1,
const cimatrix &m2)
4282 #if(CXSC_INDEX_CHECK) 4283 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4287 INLINE cimatrix operator -(
const cimatrix &m1,
const cmatrix &m2)
4289 #if(CXSC_INDEX_CHECK) 4290 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4294 INLINE cimatrix operator -(
const cmatrix &m,
const cimatrix_slice &ms)
4296 #if(CXSC_INDEX_CHECK) 4297 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4301 INLINE cimatrix operator -(
const cimatrix &m,
const cmatrix_slice &ms)
4303 #if(CXSC_INDEX_CHECK) 4304 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4308 INLINE cimatrix operator -(
const cmatrix_slice &ms,
const cimatrix &m)
4310 #if(CXSC_INDEX_CHECK) 4311 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4315 INLINE cimatrix operator -(
const cimatrix_slice &ms,
const cmatrix &m)
4317 #if(CXSC_INDEX_CHECK) 4318 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4322 INLINE cimatrix operator -(
const cmatrix_slice &ms1,
const cimatrix_slice &ms2)
4324 #if(CXSC_INDEX_CHECK) 4325 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4329 INLINE cimatrix operator -(
const cimatrix_slice &ms1,
const cmatrix_slice &ms2)
4331 #if(CXSC_INDEX_CHECK) 4332 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4336 INLINE cimatrix &operator -=(cimatrix &m1,
const cmatrix &m2)
4338 #if(CXSC_INDEX_CHECK) 4339 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4343 INLINE cimatrix &operator -=(cimatrix &m1,
const cmatrix_slice &ms)
4345 #if(CXSC_INDEX_CHECK) 4346 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4352 INLINE cimatrix
operator *(
const cmatrix &m1,
const cimatrix &m2)
4353 #if(CXSC_INDEX_CHECK) 4354 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4358 INLINE cimatrix
operator *(
const cimatrix &m1,
const cmatrix &m2)
4360 #if(CXSC_INDEX_CHECK) 4361 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4365 INLINE cimatrix
operator *(
const cmatrix &m1,
const cimatrix_slice &ms)
4367 #if(CXSC_INDEX_CHECK) 4368 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4372 INLINE cimatrix
operator *(
const cimatrix &m1,
const cmatrix_slice &ms)
4374 #if(CXSC_INDEX_CHECK) 4375 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4379 INLINE cimatrix
operator *(
const cmatrix_slice &ms,
const cimatrix &m1)
4381 #if(CXSC_INDEX_CHECK) 4382 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4386 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const cmatrix &m1)
4388 #if(CXSC_INDEX_CHECK) 4389 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4393 INLINE cimatrix
operator *(
const cmatrix_slice &ms1,
const cimatrix_slice &ms2)
4395 #if(CXSC_INDEX_CHECK) 4396 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4400 INLINE cimatrix
operator *(
const cimatrix_slice &ms1,
const cmatrix_slice &ms2)
4402 #if(CXSC_INDEX_CHECK) 4403 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4407 INLINE cimatrix &
operator *=(cimatrix &m1,
const cmatrix &m2)
4409 #if(CXSC_INDEX_CHECK) 4410 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4414 INLINE cimatrix &
operator *=(cimatrix &m1,
const cmatrix_slice &ms)
4416 #if(CXSC_INDEX_CHECK) 4417 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4423 INLINE cimatrix operator |(
const cmatrix &m1,
const cimatrix &m2)
4424 #if(CXSC_INDEX_CHECK) 4425 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4429 INLINE cimatrix operator |(
const cimatrix &m1,
const cmatrix &m2)
4431 #if(CXSC_INDEX_CHECK) 4432 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4436 INLINE cimatrix operator |(
const cmatrix &m,
const cimatrix_slice &ms)
4438 #if(CXSC_INDEX_CHECK) 4439 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4443 INLINE cimatrix operator |(
const cimatrix &m,
const cmatrix_slice &ms)
4445 #if(CXSC_INDEX_CHECK) 4446 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4450 INLINE cimatrix operator |(
const cmatrix_slice &ms,
const cimatrix &m)
4452 #if(CXSC_INDEX_CHECK) 4453 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4457 INLINE cimatrix operator |(
const cimatrix_slice &ms,
const cmatrix &m)
4459 #if(CXSC_INDEX_CHECK) 4460 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4464 INLINE cimatrix operator |(
const cmatrix_slice &m1,
const cimatrix_slice &m2)
4466 #if(CXSC_INDEX_CHECK) 4467 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4471 INLINE cimatrix operator |(
const cimatrix_slice &m1,
const cmatrix_slice &m2)
4473 #if(CXSC_INDEX_CHECK) 4474 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4478 INLINE cimatrix &operator |=(cimatrix &m1,
const cmatrix &m2)
4480 #if(CXSC_INDEX_CHECK) 4481 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4485 INLINE cimatrix &operator |=(cimatrix &m1,
const cmatrix_slice &ms)
4487 #if(CXSC_INDEX_CHECK) 4488 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4494 INLINE cimatrix operator &(
const cmatrix &m1,
const cimatrix &m2)
4495 #if(CXSC_INDEX_CHECK) 4496 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4500 INLINE cimatrix operator &(
const cimatrix &m1,
const cmatrix &m2)
4502 #if(CXSC_INDEX_CHECK) 4503 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4507 INLINE cimatrix operator &(
const cmatrix &m,
const cimatrix_slice &ms)
4509 #if(CXSC_INDEX_CHECK) 4510 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4514 INLINE cimatrix operator &(
const cimatrix &m,
const cmatrix_slice &ms)
4516 #if(CXSC_INDEX_CHECK) 4517 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4521 INLINE cimatrix operator &(
const cmatrix_slice &ms,
const cimatrix &m)
4523 #if(CXSC_INDEX_CHECK) 4524 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4528 INLINE cimatrix operator &(
const cimatrix_slice &ms,
const cmatrix &m)
4530 #if(CXSC_INDEX_CHECK) 4531 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4535 INLINE cimatrix operator &(
const cmatrix_slice &m1,
const cimatrix_slice &m2)
4537 #if(CXSC_INDEX_CHECK) 4538 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4542 INLINE cimatrix operator &(
const cimatrix_slice &m1,
const cmatrix_slice &m2)
4544 #if(CXSC_INDEX_CHECK) 4545 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4549 INLINE cimatrix &operator &=(cimatrix &m1,
const cmatrix &m2)
4551 #if(CXSC_INDEX_CHECK) 4552 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4556 INLINE cimatrix &operator &=(cimatrix &m1,
const cmatrix_slice &ms)
4558 #if(CXSC_INDEX_CHECK) 4559 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4566 INLINE cimatrix operator +(
const imatrix &m1,
const cimatrix &m2)
4567 #if(CXSC_INDEX_CHECK) 4568 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4572 INLINE cimatrix operator +(
const cimatrix &m1,
const imatrix &m2)
4574 #if(CXSC_INDEX_CHECK) 4575 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4579 INLINE cimatrix operator +(
const imatrix &m,
const cimatrix_slice &ms)
4581 #if(CXSC_INDEX_CHECK) 4582 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4586 INLINE cimatrix operator +(
const cimatrix &m,
const imatrix_slice &ms)
4588 #if(CXSC_INDEX_CHECK) 4589 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4593 INLINE cimatrix operator +(
const imatrix_slice &ms,
const cimatrix &m)
4595 #if(CXSC_INDEX_CHECK) 4596 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4600 INLINE cimatrix operator +(
const cimatrix_slice &ms,
const imatrix &m)
4602 #if(CXSC_INDEX_CHECK) 4603 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4607 INLINE cimatrix operator +(
const imatrix_slice &m1,
const cimatrix_slice &m2)
4609 #if(CXSC_INDEX_CHECK) 4610 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4614 INLINE cimatrix operator +(
const cimatrix_slice &m1,
const imatrix_slice &m2)
4616 #if(CXSC_INDEX_CHECK) 4617 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4621 INLINE cimatrix &
operator +=(cimatrix &m1,
const imatrix &m2)
4623 #if(CXSC_INDEX_CHECK) 4624 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4628 INLINE cimatrix &
operator +=(cimatrix &m1,
const imatrix_slice &ms)
4630 #if(CXSC_INDEX_CHECK) 4631 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4637 INLINE cimatrix operator -(
const imatrix &m1,
const cimatrix &m2)
4638 #if(CXSC_INDEX_CHECK) 4639 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4643 INLINE cimatrix operator -(
const cimatrix &m1,
const imatrix &m2)
4645 #if(CXSC_INDEX_CHECK) 4646 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4650 INLINE cimatrix operator -(
const imatrix &m,
const cimatrix_slice &ms)
4652 #if(CXSC_INDEX_CHECK) 4653 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4657 INLINE cimatrix operator -(
const cimatrix &m,
const imatrix_slice &ms)
4659 #if(CXSC_INDEX_CHECK) 4660 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4664 INLINE cimatrix operator -(
const imatrix_slice &ms,
const cimatrix &m)
4666 #if(CXSC_INDEX_CHECK) 4667 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4671 INLINE cimatrix operator -(
const cimatrix_slice &ms,
const imatrix &m)
4673 #if(CXSC_INDEX_CHECK) 4674 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4678 INLINE cimatrix operator -(
const imatrix_slice &ms1,
const cimatrix_slice &ms2)
4680 #if(CXSC_INDEX_CHECK) 4681 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4685 INLINE cimatrix operator -(
const cimatrix_slice &ms1,
const imatrix_slice &ms2)
4687 #if(CXSC_INDEX_CHECK) 4688 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4692 INLINE cimatrix &operator -=(cimatrix &m1,
const imatrix &m2)
4694 #if(CXSC_INDEX_CHECK) 4695 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4699 INLINE cimatrix &operator -=(cimatrix &m1,
const imatrix_slice &ms)
4701 #if(CXSC_INDEX_CHECK) 4702 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4708 INLINE cimatrix
operator *(
const imatrix &m1,
const cimatrix &m2)
4709 #if(CXSC_INDEX_CHECK) 4710 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4714 INLINE cimatrix
operator *(
const cimatrix &m1,
const imatrix &m2)
4716 #if(CXSC_INDEX_CHECK) 4717 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4721 INLINE cimatrix
operator *(
const imatrix &m1,
const cimatrix_slice &ms)
4723 #if(CXSC_INDEX_CHECK) 4724 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4728 INLINE cimatrix
operator *(
const cimatrix &m1,
const imatrix_slice &ms)
4730 #if(CXSC_INDEX_CHECK) 4731 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4735 INLINE cimatrix
operator *(
const imatrix_slice &ms,
const cimatrix &m1)
4737 #if(CXSC_INDEX_CHECK) 4738 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4742 INLINE cimatrix
operator *(
const cimatrix_slice &ms,
const imatrix &m1)
4744 #if(CXSC_INDEX_CHECK) 4745 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4749 INLINE cimatrix
operator *(
const imatrix_slice &ms1,
const cimatrix_slice &ms2)
4751 #if(CXSC_INDEX_CHECK) 4752 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4756 INLINE cimatrix
operator *(
const cimatrix_slice &ms1,
const imatrix_slice &ms2)
4758 #if(CXSC_INDEX_CHECK) 4759 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4763 INLINE cimatrix &
operator *=(cimatrix &m1,
const imatrix &m2)
4765 #if(CXSC_INDEX_CHECK) 4766 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4770 INLINE cimatrix &
operator *=(cimatrix &m1,
const imatrix_slice &ms)
4772 #if(CXSC_INDEX_CHECK) 4773 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4779 INLINE cimatrix operator |(
const imatrix &m1,
const cimatrix &m2)
4780 #if(CXSC_INDEX_CHECK) 4781 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4785 INLINE cimatrix operator |(
const cimatrix &m1,
const imatrix &m2)
4787 #if(CXSC_INDEX_CHECK) 4788 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4792 INLINE cimatrix operator |(
const imatrix &m,
const cimatrix_slice &ms)
4794 #if(CXSC_INDEX_CHECK) 4795 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4799 INLINE cimatrix operator |(
const cimatrix &m,
const imatrix_slice &ms)
4801 #if(CXSC_INDEX_CHECK) 4802 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4806 INLINE cimatrix operator |(
const imatrix_slice &ms,
const cimatrix &m)
4808 #if(CXSC_INDEX_CHECK) 4809 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4813 INLINE cimatrix operator |(
const cimatrix_slice &ms,
const imatrix &m)
4815 #if(CXSC_INDEX_CHECK) 4816 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4820 INLINE cimatrix operator |(
const imatrix_slice &m1,
const cimatrix_slice &m2)
4822 #if(CXSC_INDEX_CHECK) 4823 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4827 INLINE cimatrix operator |(
const cimatrix_slice &m1,
const imatrix_slice &m2)
4829 #if(CXSC_INDEX_CHECK) 4830 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4834 INLINE cimatrix &operator |=(cimatrix &m1,
const imatrix &m2)
4836 #if(CXSC_INDEX_CHECK) 4837 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4841 INLINE cimatrix &operator |=(cimatrix &m1,
const imatrix_slice &ms)
4843 #if(CXSC_INDEX_CHECK) 4844 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4850 INLINE cimatrix operator &(
const imatrix &m1,
const cimatrix &m2)
4851 #if(CXSC_INDEX_CHECK) 4852 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4856 INLINE cimatrix operator &(
const cimatrix &m1,
const imatrix &m2)
4858 #if(CXSC_INDEX_CHECK) 4859 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4863 INLINE cimatrix operator &(
const imatrix &m,
const cimatrix_slice &ms)
4865 #if(CXSC_INDEX_CHECK) 4866 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4870 INLINE cimatrix operator &(
const cimatrix &m,
const imatrix_slice &ms)
4872 #if(CXSC_INDEX_CHECK) 4873 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4877 INLINE cimatrix operator &(
const imatrix_slice &ms,
const cimatrix &m)
4879 #if(CXSC_INDEX_CHECK) 4880 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4884 INLINE cimatrix operator &(
const cimatrix_slice &ms,
const imatrix &m)
4886 #if(CXSC_INDEX_CHECK) 4887 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4891 INLINE cimatrix operator &(
const imatrix_slice &m1,
const cimatrix_slice &m2)
4893 #if(CXSC_INDEX_CHECK) 4894 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4898 INLINE cimatrix operator &(
const cimatrix_slice &m1,
const imatrix_slice &m2)
4900 #if(CXSC_INDEX_CHECK) 4901 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4905 INLINE cimatrix &operator &=(cimatrix &m1,
const imatrix &m2)
4907 #if(CXSC_INDEX_CHECK) 4908 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4912 INLINE cimatrix &operator &=(cimatrix &m1,
const imatrix_slice &ms)
4914 #if(CXSC_INDEX_CHECK) 4915 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4922 INLINE cimatrix operator +(
const cmatrix &m1,
const imatrix &m2)
4923 #if(CXSC_INDEX_CHECK) 4924 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4928 INLINE cimatrix operator +(
const imatrix &m1,
const cmatrix &m2)
4930 #if(CXSC_INDEX_CHECK) 4931 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4935 INLINE cimatrix operator +(
const cmatrix &m,
const imatrix_slice &ms)
4937 #if(CXSC_INDEX_CHECK) 4938 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4942 INLINE cimatrix operator +(
const imatrix &m,
const cmatrix_slice &ms)
4944 #if(CXSC_INDEX_CHECK) 4945 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4949 INLINE cimatrix operator +(
const cmatrix_slice &ms,
const imatrix &m)
4951 #if(CXSC_INDEX_CHECK) 4952 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4956 INLINE cimatrix operator +(
const imatrix_slice &ms,
const cmatrix &m)
4958 #if(CXSC_INDEX_CHECK) 4959 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4963 INLINE cimatrix operator +(
const cmatrix_slice &m1,
const imatrix_slice &m2)
4965 #if(CXSC_INDEX_CHECK) 4966 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4970 INLINE cimatrix operator +(
const imatrix_slice &m1,
const cmatrix_slice &m2)
4972 #if(CXSC_INDEX_CHECK) 4973 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4979 INLINE cimatrix operator -(
const cmatrix &m1,
const imatrix &m2)
4980 #if(CXSC_INDEX_CHECK) 4981 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4985 INLINE cimatrix operator -(
const imatrix &m1,
const cmatrix &m2)
4987 #if(CXSC_INDEX_CHECK) 4988 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4992 INLINE cimatrix operator -(
const cmatrix &m,
const imatrix_slice &ms)
4994 #if(CXSC_INDEX_CHECK) 4995 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
4999 INLINE cimatrix operator -(
const imatrix &m,
const cmatrix_slice &ms)
5001 #if(CXSC_INDEX_CHECK) 5002 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5006 INLINE cimatrix operator -(
const cmatrix_slice &ms,
const imatrix &m)
5008 #if(CXSC_INDEX_CHECK) 5009 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5013 INLINE cimatrix operator -(
const imatrix_slice &ms,
const cmatrix &m)
5015 #if(CXSC_INDEX_CHECK) 5016 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5020 INLINE cimatrix operator -(
const cmatrix_slice &ms1,
const imatrix_slice &ms2)
5022 #if(CXSC_INDEX_CHECK) 5023 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5027 INLINE cimatrix operator -(
const imatrix_slice &ms1,
const cmatrix_slice &ms2)
5029 #if(CXSC_INDEX_CHECK) 5030 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5036 INLINE cimatrix
operator *(
const cmatrix &m1,
const imatrix &m2)
5037 #if(CXSC_INDEX_CHECK) 5038 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5042 INLINE cimatrix
operator *(
const imatrix &m1,
const cmatrix &m2)
5044 #if(CXSC_INDEX_CHECK) 5045 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5049 INLINE cimatrix
operator *(
const cmatrix &m1,
const imatrix_slice &ms)
5051 #if(CXSC_INDEX_CHECK) 5052 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5056 INLINE cimatrix
operator *(
const imatrix &m1,
const cmatrix_slice &ms)
5058 #if(CXSC_INDEX_CHECK) 5059 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5063 INLINE cimatrix
operator *(
const cmatrix_slice &ms,
const imatrix &m1)
5065 #if(CXSC_INDEX_CHECK) 5066 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5070 INLINE cimatrix
operator *(
const imatrix_slice &ms,
const cmatrix &m1)
5072 #if(CXSC_INDEX_CHECK) 5073 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5077 INLINE cimatrix
operator *(
const cmatrix_slice &ms1,
const imatrix_slice &ms2)
5079 #if(CXSC_INDEX_CHECK) 5080 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5084 INLINE cimatrix
operator *(
const imatrix_slice &ms1,
const cmatrix_slice &ms2)
5086 #if(CXSC_INDEX_CHECK) 5087 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5093 INLINE cimatrix operator |(
const cmatrix &m1,
const imatrix &m2)
5094 #if(CXSC_INDEX_CHECK) 5095 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5099 INLINE cimatrix operator |(
const imatrix &m1,
const cmatrix &m2)
5101 #if(CXSC_INDEX_CHECK) 5102 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5106 INLINE cimatrix operator |(
const cmatrix &m,
const imatrix_slice &ms)
5108 #if(CXSC_INDEX_CHECK) 5109 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5113 INLINE cimatrix operator |(
const imatrix &m,
const cmatrix_slice &ms)
5115 #if(CXSC_INDEX_CHECK) 5116 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5120 INLINE cimatrix operator |(
const cmatrix_slice &ms,
const imatrix &m)
5122 #if(CXSC_INDEX_CHECK) 5123 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5127 INLINE cimatrix operator |(
const imatrix_slice &ms,
const cmatrix &m)
5129 #if(CXSC_INDEX_CHECK) 5130 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5134 INLINE cimatrix operator |(
const cmatrix_slice &m1,
const imatrix_slice &m2)
5136 #if(CXSC_INDEX_CHECK) 5137 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5141 INLINE cimatrix operator |(
const imatrix_slice &m1,
const cmatrix_slice &m2)
5143 #if(CXSC_INDEX_CHECK) 5144 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5150 INLINE cimatrix operator &(
const cmatrix &m1,
const imatrix &m2)
5151 #if(CXSC_INDEX_CHECK) 5152 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5156 INLINE cimatrix operator &(
const imatrix &m1,
const cmatrix &m2)
5158 #if(CXSC_INDEX_CHECK) 5159 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5163 INLINE cimatrix operator &(
const cmatrix &m,
const imatrix_slice &ms)
5165 #if(CXSC_INDEX_CHECK) 5166 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5170 INLINE cimatrix operator &(
const imatrix &m,
const cmatrix_slice &ms)
5172 #if(CXSC_INDEX_CHECK) 5173 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5177 INLINE cimatrix operator &(
const cmatrix_slice &ms,
const imatrix &m)
5179 #if(CXSC_INDEX_CHECK) 5180 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5184 INLINE cimatrix operator &(
const imatrix_slice &ms,
const cmatrix &m)
5186 #if(CXSC_INDEX_CHECK) 5187 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5191 INLINE cimatrix operator &(
const cmatrix_slice &m1,
const imatrix_slice &m2)
5193 #if(CXSC_INDEX_CHECK) 5194 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5198 INLINE cimatrix operator &(
const imatrix_slice &m1,
const cmatrix_slice &m2)
5200 #if(CXSC_INDEX_CHECK) 5201 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
5208 INLINE cimatrix operator |(
const rmatrix &rv1,
const cmatrix &rv2)
5209 #if(CXSC_INDEX_CHECK) 5210 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5214 INLINE cimatrix operator |(
const cmatrix &rv1,
const rmatrix &rv2)
5216 #if(CXSC_INDEX_CHECK) 5217 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5221 INLINE cimatrix operator |(
const cmatrix &rv,
const rmatrix_slice &sl)
5223 #if(CXSC_INDEX_CHECK) 5224 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5228 INLINE cimatrix operator |(
const rmatrix_slice &sl,
const cmatrix &rv)
5230 #if(CXSC_INDEX_CHECK) 5231 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5235 INLINE cimatrix operator |(
const cmatrix_slice &sl,
const rmatrix &rv)
5237 #if(CXSC_INDEX_CHECK) 5238 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5242 INLINE cimatrix operator |(
const rmatrix &rv,
const cmatrix_slice &sl)
5244 #if(CXSC_INDEX_CHECK) 5245 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5249 INLINE cimatrix operator |(
const cmatrix_slice &sl1,
const rmatrix_slice &sl2)
5251 #if(CXSC_INDEX_CHECK) 5252 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5256 INLINE cimatrix operator |(
const rmatrix_slice &sl1,
const cmatrix_slice &sl2)
5258 #if(CXSC_INDEX_CHECK) 5259 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5267 INLINE cimatrix operator |(
const cmatrix &rv1,
const cmatrix &rv2)
5268 #if(CXSC_INDEX_CHECK) 5269 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5273 INLINE cimatrix operator |(
const cmatrix &rv1,
const cmatrix &rv2)
5275 #if(CXSC_INDEX_CHECK) 5276 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5280 INLINE cimatrix operator |(
const cmatrix &rv,
const cmatrix_slice &sl)
5282 #if(CXSC_INDEX_CHECK) 5283 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5287 INLINE cimatrix operator |(
const cmatrix_slice &sl,
const cmatrix &rv)
5289 #if(CXSC_INDEX_CHECK) 5290 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5294 INLINE cimatrix operator |(
const cmatrix_slice &sl,
const cmatrix &rv)
5296 #if(CXSC_INDEX_CHECK) 5297 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5301 INLINE cimatrix operator |(
const cmatrix &rv,
const cmatrix_slice &sl)
5303 #if(CXSC_INDEX_CHECK) 5304 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5308 INLINE cimatrix operator |(
const cmatrix_slice &sl1,
const cmatrix_slice &sl2)
5310 #if(CXSC_INDEX_CHECK) 5311 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5315 INLINE cimatrix operator |(
const cmatrix_slice &sl1,
const cmatrix_slice &sl2)
5317 #if(CXSC_INDEX_CHECK) 5318 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
5329 INLINE
bool operator ==(
const cimatrix &m1,
const cimatrix &m2)
throw();
5331 INLINE
bool operator !=(
const cimatrix &m1,
const cimatrix &m2)
throw();
5333 INLINE
bool operator <(
const cimatrix &m1,
const cimatrix &m2)
throw();
5335 INLINE
bool operator <=(
const cimatrix &m1,
const cimatrix &m2)
throw();
5337 INLINE
bool operator >(
const cimatrix &m1,
const cimatrix &m2)
throw();
5339 INLINE
bool operator >=(
const cimatrix &m1,
const cimatrix &m2)
throw();
5341 INLINE
bool operator ==(
const cimatrix &m1,
const cimatrix_slice &ms)
throw();
5343 INLINE
bool operator !=(
const cimatrix &m1,
const cimatrix_slice &ms)
throw();
5345 INLINE
bool operator <(
const cimatrix &m1,
const cimatrix_slice &ms)
throw();
5347 INLINE
bool operator <=(
const cimatrix &m1,
const cimatrix_slice &ms)
throw();
5349 INLINE
bool operator >(
const cimatrix &m1,
const cimatrix_slice &ms)
throw();
5351 INLINE
bool operator >=(
const cimatrix &m1,
const cimatrix_slice &ms)
throw();
5356 INLINE
bool operator ==(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
throw();
5358 INLINE
bool operator !=(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
throw();
5360 INLINE
bool operator <(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
throw();
5362 INLINE
bool operator <=(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
throw();
5364 INLINE
bool operator >(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
throw();
5366 INLINE
bool operator >=(
const cimatrix_slice &m1,
const cimatrix_slice &m2)
throw();
5371 INLINE
bool operator !(
const cimatrix &ms)
throw();
5373 INLINE
bool operator !(
const cimatrix_slice &ms)
throw();
5378 INLINE std::ostream &operator <<(std::ostream &s,
const cimatrix &r)
throw();
5380 INLINE std::ostream &operator <<(std::ostream &s,
const cimatrix_slice &r)
throw();
5382 INLINE std::istream &operator >>(std::istream &s,cimatrix &r)
throw();
5384 INLINE std::istream &operator >>(std::istream &s,cimatrix_slice &r)
throw();
5387 rmatrix
CompMat (
const cimatrix& );
5389 cimatrix
Id (
const cimatrix& );
5391 cimatrix
transp (
const cimatrix& );
5393 INLINE
int RowLen (
const cimatrix& );
5395 INLINE
int ColLen (
const cimatrix& );
5397 INLINE
int RowLen (
const cimatrix_slice& );
5399 INLINE
int ColLen (
const cimatrix_slice& );
5406 #ifdef _CXSC_INCL_INL 5407 #include "matrix.inl" 5408 #include "cimatrix.inl" 5412 #ifdef CXSC_USE_BLAS 5413 #define _CXSC_BLAS_CIMATRIX 5414 #include "cxsc_blas.inl" cimatrix_subv & operator &=(const scivector &rv)
Implementation of intersection and allocation operation.
friend rmatrix InfIm(const cimatrix &v)
Returns the infimum of imaginary part of the matrix.
cimatrix_subv operator [](const int &i) const
Operator for accessing a single row of the matrix.
The Data Type rmatrix_slice.
cimatrix & operator=(const cinterval &r)
Implementation of standard assigning operator.
cimatrix_slice & operator/=(const cinterval &c)
Implementation of division and allocation operation.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
friend rmatrix InfRe(const cimatrix &v)
Returns the infimum of real part of the matrix.
friend int Ub(const cimatrix_subv &rv)
Returns the upper bound of the vector.
The Data Type imatrix_subv.
Helper class for slices of sparse vectors.
friend rmatrix SupIm(const cimatrix &v)
Returns the supremum of imaginary part of the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
cimatrix & operator -=(const scimatrix &m1)
Implementation of substraction and allocation operation.
The Data Type cimatrix_subv.
Represents a row or column vector of a sparse matrix.
The Data Type cimatrix_slice.
friend rmatrix InfRe(const cimatrix_slice &v)
Returns the infimum of real part of the matrix.
cimatrix & operator &=(const scimatrix &m1)
Implementation of intersection and allocation operation.
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
The namespace cxsc, providing all functionality of the class library C-XSC.
cimatrix & operator()()
Operator for accessing the whole matrix.
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
The Scalar Type interval.
cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
cimatrix_subv(const cimatrix_subv &v)
Constructor of class cimatrix_subv.
A sparse interval vector.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
cimatrix_slice & operator &=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix_slice(cimatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class cimatrix_slice.
A sparse complex interval matrix.
friend int VecLen(const cimatrix_subv &rv)
Returns the size of the vector.
cimatrix_slice & operator=(const cimatrix &m)
Implementation of standard assigning operator.
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix_slice & operator+=(const cinterval &c)
Implementation of addition and allocation operation.
A sparse complex interval vector.
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
The Data Type ivector_slice.
cimatrix_subv & operator+=(const cinterval &c)
Implementation of addition and allocation operation.
cimatrix_subv & operator/=(const cinterval &c)
Implementation of division and allocation operation.
cimatrix()
Constructor of class cimatrix.
cimatrix & operator *=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
The Data Type imatrix_slice.
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
The Data Type rvector_slice.
A slice of a sparse real interval matrix.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
The Data Type rmatrix_subv.
cimatrix_slice(const cimatrix_slice &ms)
Constructor of class cimatrix_slice.
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
civector operator *(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
cimatrix_slice & operator *=(const cinterval &c)
Implementation of multiplication and allocation operation.
A slice of a sparse real matrix.
The Scalar Type cinterval.
cimatrix_subv & operator()()
Operator for accessing the whole vector.
cimatrix_slice & operator()()
Operator for accessing the whole matrix.
A slice of a sparse complex matrix.
void Resize(cimatrix &A)
Resizes the matrix.
Helper class for slices of sparse vectors.
cinterval & operator [](const int &i) const
Operator for accessing the single elements of the vector (read-only)
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Represents a row or column vector of a sparse matrix.
The Data Type civector_slice.
int ColLen(const cimatrix &)
Returns the column dimension.
The Data Type cmatrix_subv.
cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
int RowLen(const cimatrix &)
Returns the row dimension.
friend cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
cimatrix_slice & operator -=(const cinterval &c)
Implementation of subtraction and allocation operation.
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
cimatrix_subv(cinterval *d, const int &l, const int &u, const int &s, const int &st, const int &o)
Constructor of class cimatrix_subv.
The Data Type cmatrix_slice.
friend int Lb(const cimatrix_subv &rv)
Returns the lower bound of the vector.
cimatrix _imatrix(const cimatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
cimatrix & operator *=(const scimatrix &m1)
Implementation of multiplication and allocation operation.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
friend rmatrix SupIm(const cimatrix_slice &v)
Returns the supremum of imaginary part of the matrix.
Helper class for slices of sparse vectors.
civector()
Constructor of class civector.
Represents a row or column vector of a sparse matrix.
cimatrix_slice(cimatrix &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class cimatrix_slice.
Helper class for slices of sparse vectors.
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
Represents a row or column vector of a sparse matrix.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
friend rmatrix SupRe(const cimatrix &v)
Returns the supremum of real part of the matrix.
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
friend cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
The Data Type cvector_slice.
A slice of a sparse complex interval matrix.
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
friend rmatrix SupRe(const cimatrix_slice &v)
Returns the supremum of real part of the matrix.
friend rmatrix InfIm(const cimatrix_slice &v)
Returns the infimum of imaginary part of the matrix.
A sparse interval matrix.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
cimatrix_subv & operator -=(const cinterval &c)
Implementation of subtraction and allocation operation.
cimatrix_subv & operator *=(const cinterval &c)
Implementation of multiplication and allocation operation.
cimatrix_subv operator [](const int &i)
Operator for accessing a single row of the matrix.