26#ifndef _CXSC_CIMATRIX_INL_INCLUDED
27#define _CXSC_CIMATRIX_INL_INCLUDED
59INLINE
cimatrix::cimatrix(
const rmatrix &rm)
noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
62 for(
int i=0;i<xsize*ysize;i++)
66INLINE
cimatrix::cimatrix(
const cmatrix &rm)
noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
69 for(
int i=0;i<xsize*ysize;i++)
73INLINE
cimatrix::cimatrix(
const imatrix &rm)
noexcept:lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
76 for(
int i=0;i<xsize*ysize;i++)
83 for(
int i=0;i<xsize*ysize;i++)
89:lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
91 noexcept:lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
95 if((n<0)||(m<0)) cxscthrow(ERROR_CIMATRIX_WRONG_BOUNDARIES(
"cimatrix::cimatrix(const int &m, const int &n)"));
102:lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
104 noexcept:lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
108 if((m2<m1)||(n2<n1)) cxscthrow(ERROR_CIMATRIX_WRONG_BOUNDARIES(
"cimatrix::cimatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
116 for (
int i=0, j=v.start;i<v.size;i++,j+=v.offset)
123 for(
int i=0;i<v.size;i++)
130 for(
int i=0;i<v.size;i++)
137 for(
int i=0;i<v.size;i++)
144 for(
int i=0;i<v.size;i++)
151 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
158 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
165 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
172 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
182 for (i=0;i<ysize;i++)
186 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
196 for (i=0;i<ysize;i++)
200 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
209 for (i=0;i<ysize;i++)
213 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
222 for (i=0;i<ysize;i++)
226 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
283 if((i<lb)||(i>ub)) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval &cimatrix_subv::operator [](const int &i) const"));
285 return dat[start+((i-lb)*offset)];
296 if((i<lb)||(i>ub)) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval &cimatrix_subv::operator [](const int &i)"));
298 return dat[start+((i-lb)*offset)];
309 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const int &i)"));
322 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const cxscmatrix_column &i)"));
324 return cimatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
335 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const int &i)"));
348 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const cxscmatrix_column &i)"));
350 return cimatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
362 if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix::operator ()(const int &m, const int &n)"));
375 if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
388 if((i<start1)||(i>end1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const int &i)"));
390 return cimatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
401 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const cxscmatrix_column &i)"));
403 return cimatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
414 if((i<start1)||(i>end1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const int &i)"));
416 return cimatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
427 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const cxscmatrix_column &i)"));
429 return cimatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
441 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix_slice::operator ()(const int &m, const int &n)"));
454 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
467 if(1<lb||i>ub) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"cimatrix_subv cimatrix_subv::operator ()(const int &i)"));
480 if(i1<lb||i2>ub) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"cimatrix_subv cimatrix_subv::operator ()(const int &i1,const int &i2)"));
482 return cimatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
495 {
return _mvvassign(*
this,v); }
502 {
return _mvvassign(*
this,
civector(v)); }
512 {
return _mvvassign(*
this,v); }
519 {
return _mvvassign(*
this,
civector(v)); }
529 {
return _mvvassign(*
this,v); }
536 {
return _mvvassign(*
this,
civector(v)); }
546 {
return _mvvassign(*
this,v); }
553 {
return _mvvassign(*
this,
civector(v)); }
579 INLINE cimatrix::operator
void*()
noexcept {
return _mvoid(*
this); }
587 {
return _msmassign(*
this,m); }
594 {
return _msmsassign(*
this,ms); }
602 {
return _msmassign(*
this,
cimatrix(v)); }
624 {
return _msmassign(*
this,m); }
631 {
return _msmsassign(*
this,ms); }
639 {
return _msmassign(*
this,
cimatrix(v)); }
661 {
return _msmassign(*
this,m); }
668 {
return _msmsassign(*
this,ms); }
676 {
return _msmassign(*
this,
cimatrix(v)); }
698 {
return _msmassign(*
this,m); }
705 {
return _msmsassign(*
this,ms); }
713 {
return _msmassign(*
this,
cimatrix(v)); }
729 INLINE cimatrix_slice::operator
void*()
noexcept {
return _msvoid(*
this); }
747 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
749 for(
int i=0;i<m.xsize*m.ysize;i++)
750 erg.dat[i]=InfRe(m.dat[i]);
757 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
759 for(
int i=0;i<sl.sysize;i++)
761 for(
int j=0;j<sl.sxsize;j++)
763 erg.dat[i*sl.sxsize+j]=InfRe(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
772 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
774 for(
int i=0;i<m.xsize*m.ysize;i++)
775 erg.dat[i]=SupRe(m.dat[i]);
782 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
784 for(
int i=0;i<sl.sysize;i++)
786 for(
int j=0;j<sl.sxsize;j++)
788 erg.dat[i*sl.sxsize+j]=SupRe(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
797 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
799 for(
int i=0;i<m.xsize*m.ysize;i++)
800 erg.dat[i]=InfIm(m.dat[i]);
807 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
809 for(
int i=0;i<sl.sysize;i++)
811 for(
int j=0;j<sl.sxsize;j++)
813 erg.dat[i*sl.sxsize+j]=InfIm(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
822 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
824 for(
int i=0;i<m.xsize*m.ysize;i++)
825 erg.dat[i]=SupIm(m.dat[i]);
832 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
834 for(
int i=0;i<sl.sysize;i++)
836 for(
int j=0;j<sl.sxsize;j++)
838 erg.dat[i*sl.sxsize+j]=SupIm(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
851 {
return _mvvsetinf(iv,rv); }
858 {
return _mvvsetsup(iv,rv); }
865 {
return _mvvusetinf(iv,rv); }
872 {
return _mvvusetsup(iv,rv); }
879 {
return _mvvsetim(iv,rv); }
886 {
return _mvvsetre(iv,rv); }
902 {
return _mvmvcimult<cimatrix_subv,cimatrix_subv,cinterval>(rv1,rv2); }
909 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(rv1,rv2); }
916 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(rv2,rv1); }
923 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(
civector(sl),sv); }
930 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(
civector(vs),mv); }
937 {
return _mvmvplus<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
944 {
return _mvvplus<cimatrix_subv,civector,civector>(rv1,rv2); }
951 {
return _mvvplus<cimatrix_subv,civector,civector>(rv2,rv1); }
958 {
return _mvvplus<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
965 {
return _mvvplus<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
972 {
return _mvvplusassign(*
this,rv); }
979 {
return _mvvplusassign(*
this,
civector(rv)); }
986 {
return _mvmvminus<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
993 {
return _vmvminus<civector,cimatrix_subv,civector>(rv1,rv2); }
1000 {
return _mvvminus<cimatrix_subv,civector,civector>(rv1,rv2); }
1002#if(CXSC_INDEX_CHECK)
1007 {
return _vmvminus<civector,cimatrix_subv,civector>(
civector(sl),mv); }
1009#if(CXSC_INDEX_CHECK)
1014 {
return _mvvminus<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
1016#if(CXSC_INDEX_CHECK)
1021 {
return _mvvminusassign(*
this,rv); }
1023#if(CXSC_INDEX_CHECK)
1028 {
return _mvvminusassign(*
this,
civector(rv)); }
1030#if(CXSC_INDEX_CHECK)
1035 {
return _mvmvconv<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
1036 INLINE civector operator |(
const cimatrix_subv &rv1,
const civector &rv2)
1037#if(CXSC_INDEX_CHECK)
1042 {
return _mvvconv<cimatrix_subv,civector,civector>(rv1,rv2); }
1043 INLINE civector operator |(
const civector & rv1,
const cimatrix_subv &rv2)
1044#if(CXSC_INDEX_CHECK)
1049 {
return _mvvconv<cimatrix_subv,civector,civector>(rv2,rv1); }
1050 INLINE civector operator |(
const civector_slice &sl,
const cimatrix_subv &mv)
1051#if(CXSC_INDEX_CHECK)
1056 {
return _mvvconv<cimatrix_subv,civector,civector>(mv,civector(sl)); }
1057 INLINE civector operator |(
const cimatrix_subv &mv,
const civector_slice &sl)
1058#if(CXSC_INDEX_CHECK)
1063 {
return _mvvconv<cimatrix_subv,civector,civector>(mv,civector(sl)); }
1065#if(CXSC_INDEX_CHECK)
1070 {
return _mvvconvassign(*
this,rv); }
1072#if(CXSC_INDEX_CHECK)
1077 {
return _mvvconvassign(*
this,
civector(rv)); }
1079#if(CXSC_INDEX_CHECK)
1084 {
return _mvmvsect<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
1085 INLINE civector operator &(
const cimatrix_subv &rv1,
const civector &rv2)
1086#if(CXSC_INDEX_CHECK)
1091 {
return _mvvsect<cimatrix_subv,civector,civector>(rv1,rv2); }
1092 INLINE civector operator &(
const civector & rv1,
const cimatrix_subv &rv2)
1093#if(CXSC_INDEX_CHECK)
1098 {
return _mvvsect<cimatrix_subv,civector,civector>(rv2,rv1); }
1099 INLINE civector operator &(
const civector_slice &sl,
const cimatrix_subv &mv)
1100#if(CXSC_INDEX_CHECK)
1105 {
return _mvvsect<cimatrix_subv,civector,civector>(mv,civector(sl)); }
1106 INLINE civector operator &(
const cimatrix_subv &mv,
const civector_slice &sl)
1107#if(CXSC_INDEX_CHECK)
1112 {
return _mvvsect<cimatrix_subv,civector,civector>(mv,civector(sl)); }
1114#if(CXSC_INDEX_CHECK)
1119 {
return _mvvsectassign(*
this,rv); }
1121#if(CXSC_INDEX_CHECK)
1126 {
return _mvvsectassign(*
this,
civector(rv)); }
1157#if(CXSC_INDEX_CHECK)
1162 {
return _mlb(rm,i); }
1164#if(CXSC_INDEX_CHECK)
1169 {
return _mub(rm,i); }
1171#if(CXSC_INDEX_CHECK)
1176 {
return _mslb(rm,i); }
1178#if(CXSC_INDEX_CHECK)
1183 {
return _msub(rm,i); }
1185#if(CXSC_INDEX_CHECK)
1190 {
return _msetlb(m,i,j); }
1192#if(CXSC_INDEX_CHECK)
1197 {
return _msetub(m,i,j); }
1200 {
return Ub(A,2)-
Lb(A,2)+1; }
1203 {
return Ub(A,1)-
Lb(A,1)+1; }
1206 {
return Ub(A,2)-
Lb(A,2)+1; }
1209 {
return Ub(A,1)-
Lb(A,1)+1; }
1213#if(CXSC_INDEX_CHECK)
1218 { _mresize<cimatrix,cinterval>(A,m,n); }
1219 INLINE
void Resize(
cimatrix &A,
const int &m1,
const int &m2,
const int &n1,
const int &n2)
1220#if(CXSC_INDEX_CHECK)
1225 { _mresize<cimatrix,cinterval>(A,m1,m2,n1,n2); }
1237#if(CXSC_INDEX_CHECK)
1242 {
return _mmsetinf<cimatrix,cmatrix>(cm,rm); }
1244#if(CXSC_INDEX_CHECK)
1249 {
return _msmsetinf<cimatrix_slice,cmatrix>(cm,rm); }
1251#if(CXSC_INDEX_CHECK)
1256 {
return _mmssetinf<cimatrix,cmatrix_slice>(cm,rm); }
1258#if(CXSC_INDEX_CHECK)
1263 {
return _msmssetinf<cimatrix_slice,cmatrix_slice>(cm,rm); }
1265#if(CXSC_INDEX_CHECK)
1270 {
return _mmsetsup<cimatrix,cmatrix>(cm,rm); }
1272#if(CXSC_INDEX_CHECK)
1277 {
return _msmsetsup<cimatrix_slice,cmatrix>(cm,rm); }
1279#if(CXSC_INDEX_CHECK)
1284 {
return _mmssetsup<cimatrix,cmatrix_slice>(cm,rm); }
1286#if(CXSC_INDEX_CHECK)
1291 {
return _msmssetsup<cimatrix_slice,cmatrix_slice>(cm,rm); }
1293#if(CXSC_INDEX_CHECK)
1298 {
return _mmusetinf<cimatrix,cmatrix>(cm,rm); }
1300#if(CXSC_INDEX_CHECK)
1305 {
return _msmusetinf<cimatrix_slice,cmatrix>(cm,rm); }
1307#if(CXSC_INDEX_CHECK)
1312 {
return _mmsusetinf<cimatrix,cmatrix_slice>(cm,rm); }
1314#if(CXSC_INDEX_CHECK)
1319 {
return _msmsusetinf<cimatrix_slice,cmatrix_slice>(cm,rm); }
1321#if(CXSC_INDEX_CHECK)
1326 {
return _mmusetsup<cimatrix,cmatrix>(cm,rm); }
1328#if(CXSC_INDEX_CHECK)
1333 {
return _msmusetsup<cimatrix_slice,cmatrix>(cm,rm); }
1335#if(CXSC_INDEX_CHECK)
1340 {
return _mmsusetsup<cimatrix,cmatrix_slice>(cm,rm); }
1342#if(CXSC_INDEX_CHECK)
1347 {
return _msmsusetsup<cimatrix_slice,cmatrix_slice>(cm,rm); }
1353#if(CXSC_INDEX_CHECK)
1358 {
return _mmsetim<cimatrix,imatrix>(cm,rm); }
1360#if(CXSC_INDEX_CHECK)
1365 {
return _msmsetim<cimatrix_slice,imatrix>(cm,rm); }
1367#if(CXSC_INDEX_CHECK)
1372 {
return _mmssetim<cimatrix,imatrix_slice>(cm,rm); }
1374#if(CXSC_INDEX_CHECK)
1379 {
return _msmssetim<cimatrix_slice,imatrix_slice>(cm,rm); }
1381#if(CXSC_INDEX_CHECK)
1386 {
return _mmsetre<cimatrix,imatrix>(cm,rm); }
1388#if(CXSC_INDEX_CHECK)
1393 {
return _msmsetre<cimatrix_slice,imatrix>(cm,rm); }
1395#if(CXSC_INDEX_CHECK)
1400 {
return _mmssetre<cimatrix,imatrix_slice>(cm,rm); }
1402#if(CXSC_INDEX_CHECK)
1407 {
return _msmssetre<cimatrix_slice,imatrix_slice>(cm,rm); }
1409#if(CXSC_INDEX_CHECK)
1414 { _smconstr(*
this,m); }
1422#if(CXSC_INDEX_CHECK)
1427 {
return _mvvplusassign(*
this,rv); }
1429#if(CXSC_INDEX_CHECK)
1434 {
return _mvvplusassign(*
this,
rvector(rv)); }
1436#if(CXSC_INDEX_CHECK)
1441 {
return _mvvminusassign(*
this,rv); }
1443#if(CXSC_INDEX_CHECK)
1448 {
return _mvvminusassign(*
this,
rvector(rv)); }
1450#if(CXSC_INDEX_CHECK)
1455 {
return _mvvconvassign(*
this,rv); }
1457#if(CXSC_INDEX_CHECK)
1462 {
return _mvvconvassign(*
this,
rvector(rv)); }
1464#if(CXSC_INDEX_CHECK)
1469 {
return _mvvsectassign(*
this,rv); }
1471#if(CXSC_INDEX_CHECK)
1476 {
return _mvvsectassign(*
this,
rvector(rv)); }
1483#if(CXSC_INDEX_CHECK)
1488 {
return _mvvplusassign(*
this,rv); }
1490#if(CXSC_INDEX_CHECK)
1495 {
return _mvvplusassign(*
this,
cvector(rv)); }
1497#if(CXSC_INDEX_CHECK)
1502 {
return _mvvminusassign(*
this,rv); }
1504#if(CXSC_INDEX_CHECK)
1509 {
return _mvvminusassign(*
this,
cvector(rv)); }
1511#if(CXSC_INDEX_CHECK)
1516 {
return _mvvconvassign(*
this,rv); }
1518#if(CXSC_INDEX_CHECK)
1523 {
return _mvvconvassign(*
this,
cvector(rv)); }
1525#if(CXSC_INDEX_CHECK)
1530 {
return _mvvsectassign(*
this,rv); }
1532#if(CXSC_INDEX_CHECK)
1537 {
return _mvvsectassign(*
this,
cvector(rv)); }
1544#if(CXSC_INDEX_CHECK)
1549 {
return _mvvplusassign(*
this,rv); }
1551#if(CXSC_INDEX_CHECK)
1556 {
return _mvvplusassign(*
this,
ivector(rv)); }
1558#if(CXSC_INDEX_CHECK)
1563 {
return _mvvminusassign(*
this,rv); }
1565#if(CXSC_INDEX_CHECK)
1570 {
return _mvvminusassign(*
this,
ivector(rv)); }
1572#if(CXSC_INDEX_CHECK)
1577 {
return _mvvconvassign(*
this,rv); }
1579#if(CXSC_INDEX_CHECK)
1584 {
return _mvvconvassign(*
this,
ivector(rv)); }
1586#if(CXSC_INDEX_CHECK)
1591 {
return _mvvsectassign(*
this,rv); }
1593#if(CXSC_INDEX_CHECK)
1598 {
return _mvvsectassign(*
this,
ivector(rv)); }
1607#if(CXSC_INDEX_CHECK)
1612 {
return (*
this=*
this*m); }
1614#if(CXSC_INDEX_CHECK)
1619 {
return (*
this=*
this*m); }
1632#if(CXSC_INDEX_CHECK)
1637 {
return (*
this=*
this*m); }
1639#if(CXSC_INDEX_CHECK)
1644 {
return (*
this=*
this*m); }
1657#if(CXSC_INDEX_CHECK)
1662 {
return (*
this=*
this*m); }
1664#if(CXSC_INDEX_CHECK)
1669 {
return (*
this=*
this*m); }
1682#if(CXSC_INDEX_CHECK)
1687 {
return (*
this=*
this*m); }
1689#if(CXSC_INDEX_CHECK)
1694 {
return (*
this=*
this*m); }
1726#if(CXSC_INDEX_CHECK)
1731 { _vmconstr<civector,cimatrix,cinterval>(*
this,sl); }
1733#if(CXSC_INDEX_CHECK)
1738 { _vmsconstr<civector,cimatrix_slice,cinterval>(*
this,sl); }
1740#if(CXSC_INDEX_CHECK)
1745 {
return _vmassign<civector,cimatrix,cinterval>(*
this,m); }
1747#if(CXSC_INDEX_CHECK)
1752 {
return _vmassign<civector,cimatrix,cinterval>(*
this,
cimatrix(m)); }
1754#if(CXSC_INDEX_CHECK)
1761#if(CXSC_INDEX_CHECK)
1766 {
return _mvvassign(*
this,
civector(m)); }
1768#if(CXSC_INDEX_CHECK)
1775#if(CXSC_INDEX_CHECK)
1780 {
return _mvcimult<cimatrix,civector,civector>(m,v); }
1782#if(CXSC_INDEX_CHECK)
1787 {
return _msvcimult<cimatrix_slice,civector,civector>(ms,v); }
1789#if(CXSC_INDEX_CHECK)
1794 {
return _vmcimult<civector,cimatrix,civector>(v,m); }
1796#if(CXSC_INDEX_CHECK)
1801 {
return _vmscimult<civector,cimatrix_slice,civector>(v,ms); }
1803#if(CXSC_INDEX_CHECK)
1808 {
return _vmcimultassign<civector,cimatrix,cinterval>(v,m); }
1810#if(CXSC_INDEX_CHECK)
1815 {
return _vmscimultassign<civector,cimatrix_slice,cinterval>(v,ms); }
1817#if(CXSC_INDEX_CHECK)
1822 {
return _vsmcimultassign<civector_slice,cimatrix,cinterval>(*
this,m); }
1824#if(CXSC_INDEX_CHECK)
1829 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1831#if(CXSC_INDEX_CHECK)
1836 {
return _vmscimult<civector,cimatrix_slice,civector>(
civector(v),m); }
1839#if(CXSC_INDEX_CHECK)
1844 {
return _mvvassign(*
this,
rvector(m)); }
1846#if(CXSC_INDEX_CHECK)
1853#if(CXSC_INDEX_CHECK)
1858 {
return _vmcimult<rvector,cimatrix,civector>(v,m); }
1860#if(CXSC_INDEX_CHECK)
1865 {
return _vmscimult<rvector,cimatrix_slice,civector>(v,ms); }
1867#if(CXSC_INDEX_CHECK)
1872 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1874#if(CXSC_INDEX_CHECK)
1879 {
return _mvcimult<cimatrix,rvector,civector>(m,v); }
1881#if(CXSC_INDEX_CHECK)
1886 {
return _msvcimult<cimatrix_slice,rvector,civector>(ms,v); }
1889#if(CXSC_INDEX_CHECK)
1894 {
return _mvvassign(*
this,
cvector(m)); }
1896#if(CXSC_INDEX_CHECK)
1903#if(CXSC_INDEX_CHECK)
1908 {
return _vmcimult<cvector,cimatrix,civector>(v,m); }
1910#if(CXSC_INDEX_CHECK)
1915 {
return _vmscimult<cvector,cimatrix_slice,civector>(v,ms); }
1917#if(CXSC_INDEX_CHECK)
1922 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1924#if(CXSC_INDEX_CHECK)
1929 {
return _mvcimult<cimatrix,cvector,civector>(m,v); }
1931#if(CXSC_INDEX_CHECK)
1936 {
return _msvcimult<cimatrix_slice,cvector,civector>(ms,v); }
1939#if(CXSC_INDEX_CHECK)
1944 {
return _mvvassign(*
this,
ivector(m)); }
1946#if(CXSC_INDEX_CHECK)
1953#if(CXSC_INDEX_CHECK)
1958 {
return _vmcimult<ivector,cimatrix,civector>(v,m); }
1960#if(CXSC_INDEX_CHECK)
1965 {
return _vmscimult<ivector,cimatrix_slice,civector>(v,ms); }
1967#if(CXSC_INDEX_CHECK)
1972 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1974#if(CXSC_INDEX_CHECK)
1979 {
return _mvcimult<cimatrix,ivector,civector>(m,v); }
1981#if(CXSC_INDEX_CHECK)
1986 {
return _msvcimult<cimatrix_slice,ivector,civector>(ms,v); }
1991#if(CXSC_INDEX_CHECK)
1996 {
return _mmplus<cimatrix,cimatrix,cimatrix>(m1,m2); }
1998#if(CXSC_INDEX_CHECK)
2003 {
return _mmsplus<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2005#if(CXSC_INDEX_CHECK)
2010 {
return _mmsplus<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2012#if(CXSC_INDEX_CHECK)
2017 {
return _msmsplus<cimatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2019#if(CXSC_INDEX_CHECK)
2024 {
return _mmplusassign(m1,m2); }
2026#if(CXSC_INDEX_CHECK)
2031 {
return _mmsplusassign(m1,ms); }
2033#if(CXSC_INDEX_CHECK)
2038 {
return _msmplusassign(*
this,m1); }
2040#if(CXSC_INDEX_CHECK)
2045 {
return _msmsplusassign(*
this,ms2); }
2049#if(CXSC_INDEX_CHECK)
2054 {
return _mmminus<cimatrix,cimatrix,cimatrix>(m1,m2); }
2056#if(CXSC_INDEX_CHECK)
2061 {
return _mmsminus<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2063#if(CXSC_INDEX_CHECK)
2068 {
return _msmminus<cimatrix_slice,cimatrix,cimatrix>(ms,m); }
2070#if(CXSC_INDEX_CHECK)
2075 {
return _msmsminus<cimatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2077#if(CXSC_INDEX_CHECK)
2082 {
return _mmminusassign(m1,m2); }
2084#if(CXSC_INDEX_CHECK)
2089 {
return _mmsminusassign(m1,ms); }
2091#if(CXSC_INDEX_CHECK)
2096 {
return _msmminusassign(*
this,m1); }
2098#if(CXSC_INDEX_CHECK)
2103 {
return _msmsminusassign(*
this,ms2); }
2105#if(CXSC_INDEX_CHECK)
2110 {
return _mmcimult<cimatrix,cimatrix,cimatrix>(m1,m2); }
2112#if(CXSC_INDEX_CHECK)
2117 {
return _mmscimult<cimatrix,cimatrix_slice,cimatrix>(m1,ms); }
2119#if(CXSC_INDEX_CHECK)
2124 {
return _msmcimult<cimatrix_slice,cimatrix,cimatrix>(ms,m1); }
2126#if(CXSC_INDEX_CHECK)
2131 {
return _msmscimult<cimatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2133#if(CXSC_INDEX_CHECK)
2138 {
return _mmcimultassign<cimatrix,cimatrix,cinterval>(m1,m2); }
2140#if(CXSC_INDEX_CHECK)
2145 {
return _mmscimultassign<cimatrix,cimatrix_slice,cinterval>(m1,ms); }
2147#if(CXSC_INDEX_CHECK)
2152 {
return _mmconv<cimatrix,cimatrix,cimatrix>(m1,m2); }
2154#if(CXSC_INDEX_CHECK)
2159 {
return _mmsconv<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2161#if(CXSC_INDEX_CHECK)
2166 {
return _mmsconv<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2168#if(CXSC_INDEX_CHECK)
2173 {
return _msmsconv<cimatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2175#if(CXSC_INDEX_CHECK)
2180 {
return _mmconvassign(m1,m2); }
2182#if(CXSC_INDEX_CHECK)
2187 {
return _mmsconvassign(m1,ms); }
2189#if(CXSC_INDEX_CHECK)
2194 {
return _msmconvassign(*
this,m1); }
2196#if(CXSC_INDEX_CHECK)
2201 {
return _msmsconvassign(*
this,ms2); }
2203#if(CXSC_INDEX_CHECK)
2208 {
return _mmsect<cimatrix,cimatrix,cimatrix>(m1,m2); }
2210#if(CXSC_INDEX_CHECK)
2215 {
return _mmssect<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2217#if(CXSC_INDEX_CHECK)
2222 {
return _mmssect<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2224#if(CXSC_INDEX_CHECK)
2229 {
return _msmssect<cimatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2231#if(CXSC_INDEX_CHECK)
2236 {
return _mmsectassign(m1,m2); }
2238#if(CXSC_INDEX_CHECK)
2243 {
return _mmssectassign(m1,ms); }
2245#if(CXSC_INDEX_CHECK)
2250 {
return _msmsectassign(*
this,m1); }
2252#if(CXSC_INDEX_CHECK)
2257 {
return _msmssectassign(*
this,ms2); }
2260#if(CXSC_INDEX_CHECK)
2265 {
return _mmplus<rmatrix,cimatrix,cimatrix>(m1,m2); }
2267#if(CXSC_INDEX_CHECK)
2272 {
return _mmplus<rmatrix,cimatrix,cimatrix>(m2,m1); }
2274#if(CXSC_INDEX_CHECK)
2279 {
return _mmsplus<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2281#if(CXSC_INDEX_CHECK)
2286 {
return _mmsplus<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2288#if(CXSC_INDEX_CHECK)
2293 {
return _mmsplus<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2295#if(CXSC_INDEX_CHECK)
2300 {
return _mmsplus<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2302#if(CXSC_INDEX_CHECK)
2307 {
return _msmsplus<rmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2309#if(CXSC_INDEX_CHECK)
2314 {
return _msmsplus<rmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2316#if(CXSC_INDEX_CHECK)
2321 {
return _mmplusassign(m1,m2); }
2323#if(CXSC_INDEX_CHECK)
2328 {
return _mmsplusassign(m1,ms); }
2330#if(CXSC_INDEX_CHECK)
2335 {
return _msmplusassign(*
this,m1); }
2337#if(CXSC_INDEX_CHECK)
2342 {
return _msmsplusassign(*
this,ms2); }
2344#if(CXSC_INDEX_CHECK)
2349 {
return _mmminus<rmatrix,cimatrix,cimatrix>(m1,m2); }
2351#if(CXSC_INDEX_CHECK)
2356 {
return _mmminus<cimatrix,rmatrix,cimatrix>(m1,m2); }
2358#if(CXSC_INDEX_CHECK)
2363 {
return _mmsminus<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2365#if(CXSC_INDEX_CHECK)
2370 {
return _mmsminus<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2372#if(CXSC_INDEX_CHECK)
2377 {
return _msmminus<rmatrix_slice,cimatrix,cimatrix>(ms,m); }
2379#if(CXSC_INDEX_CHECK)
2384 {
return _msmminus<cimatrix_slice,rmatrix,cimatrix>(ms,m); }
2386#if(CXSC_INDEX_CHECK)
2391 {
return _msmsminus<rmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2393#if(CXSC_INDEX_CHECK)
2398 {
return _msmsminus<cimatrix_slice,rmatrix_slice,cimatrix>(ms1,ms2); }
2400#if(CXSC_INDEX_CHECK)
2405 {
return _mmminusassign(m1,m2); }
2407#if(CXSC_INDEX_CHECK)
2412 {
return _mmsminusassign(m1,ms); }
2414#if(CXSC_INDEX_CHECK)
2419 {
return _msmminusassign(*
this,m1); }
2421#if(CXSC_INDEX_CHECK)
2426 {
return _msmsminusassign(*
this,ms2); }
2428#if(CXSC_INDEX_CHECK)
2433 {
return _mmcimult<rmatrix,cimatrix,cimatrix>(m1,m2); }
2435#if(CXSC_INDEX_CHECK)
2440 {
return _mmcimult<cimatrix,rmatrix,cimatrix>(m1,m2); }
2442#if(CXSC_INDEX_CHECK)
2447 {
return _mmscimult<rmatrix,cimatrix_slice,cimatrix>(m1,ms); }
2449#if(CXSC_INDEX_CHECK)
2454 {
return _mmscimult<cimatrix,rmatrix_slice,cimatrix>(m1,ms); }
2456#if(CXSC_INDEX_CHECK)
2461 {
return _msmcimult<rmatrix_slice,cimatrix,cimatrix>(ms,m1); }
2463#if(CXSC_INDEX_CHECK)
2468 {
return _msmcimult<cimatrix_slice,rmatrix,cimatrix>(ms,m1); }
2470#if(CXSC_INDEX_CHECK)
2475 {
return _msmscimult<rmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2477#if(CXSC_INDEX_CHECK)
2482 {
return _msmscimult<cimatrix_slice,rmatrix_slice,cimatrix>(ms1,ms2); }
2484#if(CXSC_INDEX_CHECK)
2489 {
return _mmcimultassign<cimatrix,rmatrix,cinterval>(m1,m2); }
2491#if(CXSC_INDEX_CHECK)
2496 {
return _mmscimultassign<cimatrix,rmatrix_slice,cinterval>(m1,ms); }
2498#if(CXSC_INDEX_CHECK)
2503 {
return _mmconv<rmatrix,cimatrix,cimatrix>(m1,m2); }
2505#if(CXSC_INDEX_CHECK)
2510 {
return _mmconv<rmatrix,cimatrix,cimatrix>(m2,m1); }
2512#if(CXSC_INDEX_CHECK)
2517 {
return _mmsconv<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2519#if(CXSC_INDEX_CHECK)
2524 {
return _mmsconv<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2526#if(CXSC_INDEX_CHECK)
2531 {
return _mmsconv<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2533#if(CXSC_INDEX_CHECK)
2538 {
return _mmsconv<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2540#if(CXSC_INDEX_CHECK)
2545 {
return _msmsconv<rmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2547#if(CXSC_INDEX_CHECK)
2552 {
return _msmsconv<rmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2554#if(CXSC_INDEX_CHECK)
2559 {
return _mmconvassign(m1,m2); }
2561#if(CXSC_INDEX_CHECK)
2566 {
return _mmsconvassign(m1,ms); }
2568#if(CXSC_INDEX_CHECK)
2573 {
return _msmconvassign(*
this,m1); }
2575#if(CXSC_INDEX_CHECK)
2580 {
return _msmsconvassign(*
this,ms2); }
2582#if(CXSC_INDEX_CHECK)
2587 {
return _mmsect<rmatrix,cimatrix,cimatrix>(m1,m2); }
2589#if(CXSC_INDEX_CHECK)
2594 {
return _mmsect<rmatrix,cimatrix,cimatrix>(m2,m1); }
2596#if(CXSC_INDEX_CHECK)
2601 {
return _mmssect<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2603#if(CXSC_INDEX_CHECK)
2608 {
return _mmssect<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2610#if(CXSC_INDEX_CHECK)
2615 {
return _mmssect<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2617#if(CXSC_INDEX_CHECK)
2622 {
return _mmssect<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2624#if(CXSC_INDEX_CHECK)
2629 {
return _msmssect<rmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2631#if(CXSC_INDEX_CHECK)
2636 {
return _msmssect<rmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2638#if(CXSC_INDEX_CHECK)
2643 {
return _mmsectassign(m1,m2); }
2645#if(CXSC_INDEX_CHECK)
2650 {
return _mmssectassign(m1,ms); }
2652#if(CXSC_INDEX_CHECK)
2657 {
return _msmsectassign(*
this,m1); }
2659#if(CXSC_INDEX_CHECK)
2664 {
return _msmssectassign(*
this,ms2); }
2667#if(CXSC_INDEX_CHECK)
2672 {
return _mmplus<cmatrix,cimatrix,cimatrix>(m1,m2); }
2674#if(CXSC_INDEX_CHECK)
2679 {
return _mmplus<cmatrix,cimatrix,cimatrix>(m2,m1); }
2681#if(CXSC_INDEX_CHECK)
2686 {
return _mmsplus<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2688#if(CXSC_INDEX_CHECK)
2693 {
return _mmsplus<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2695#if(CXSC_INDEX_CHECK)
2700 {
return _mmsplus<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2702#if(CXSC_INDEX_CHECK)
2707 {
return _mmsplus<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2709#if(CXSC_INDEX_CHECK)
2714 {
return _msmsplus<cmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2716#if(CXSC_INDEX_CHECK)
2721 {
return _msmsplus<cmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2723#if(CXSC_INDEX_CHECK)
2728 {
return _mmplusassign(m1,m2); }
2730#if(CXSC_INDEX_CHECK)
2735 {
return _mmsplusassign(m1,ms); }
2737#if(CXSC_INDEX_CHECK)
2742 {
return _msmplusassign(*
this,m1); }
2744#if(CXSC_INDEX_CHECK)
2749 {
return _msmsplusassign(*
this,ms2); }
2751#if(CXSC_INDEX_CHECK)
2756 {
return _mmminus<cmatrix,cimatrix,cimatrix>(m1,m2); }
2758#if(CXSC_INDEX_CHECK)
2763 {
return _mmminus<cimatrix,cmatrix,cimatrix>(m1,m2); }
2765#if(CXSC_INDEX_CHECK)
2770 {
return _mmsminus<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2772#if(CXSC_INDEX_CHECK)
2777 {
return _mmsminus<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2779#if(CXSC_INDEX_CHECK)
2784 {
return _msmminus<cmatrix_slice,cimatrix,cimatrix>(ms,m); }
2786#if(CXSC_INDEX_CHECK)
2791 {
return _msmminus<cimatrix_slice,cmatrix,cimatrix>(ms,m); }
2793#if(CXSC_INDEX_CHECK)
2798 {
return _msmsminus<cmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2800#if(CXSC_INDEX_CHECK)
2805 {
return _msmsminus<cimatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
2807#if(CXSC_INDEX_CHECK)
2812 {
return _mmminusassign(m1,m2); }
2814#if(CXSC_INDEX_CHECK)
2819 {
return _mmsminusassign(m1,ms); }
2821#if(CXSC_INDEX_CHECK)
2826 {
return _msmminusassign(*
this,m1); }
2828#if(CXSC_INDEX_CHECK)
2833 {
return _msmsminusassign(*
this,ms2); }
2835#if(CXSC_INDEX_CHECK)
2840 {
return _mmcimult<cmatrix,cimatrix,cimatrix>(m1,m2); }
2842#if(CXSC_INDEX_CHECK)
2847 {
return _mmcimult<cimatrix,cmatrix,cimatrix>(m1,m2); }
2849#if(CXSC_INDEX_CHECK)
2854 {
return _mmscimult<cmatrix,cimatrix_slice,cimatrix>(m1,ms); }
2856#if(CXSC_INDEX_CHECK)
2861 {
return _mmscimult<cimatrix,cmatrix_slice,cimatrix>(m1,ms); }
2863#if(CXSC_INDEX_CHECK)
2868 {
return _msmcimult<cmatrix_slice,cimatrix,cimatrix>(ms,m1); }
2870#if(CXSC_INDEX_CHECK)
2875 {
return _msmcimult<cimatrix_slice,cmatrix,cimatrix>(ms,m1); }
2877#if(CXSC_INDEX_CHECK)
2882 {
return _msmscimult<cmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2884#if(CXSC_INDEX_CHECK)
2889 {
return _msmscimult<cimatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
2891#if(CXSC_INDEX_CHECK)
2896 {
return _mmcimultassign<cimatrix,cmatrix,cinterval>(m1,m2); }
2898#if(CXSC_INDEX_CHECK)
2903 {
return _mmscimultassign<cimatrix,cmatrix_slice,cinterval>(m1,ms); }
2905#if(CXSC_INDEX_CHECK)
2910 {
return _mmconv<cmatrix,cimatrix,cimatrix>(m1,m2); }
2912#if(CXSC_INDEX_CHECK)
2917 {
return _mmconv<cmatrix,cimatrix,cimatrix>(m2,m1); }
2919#if(CXSC_INDEX_CHECK)
2924 {
return _mmsconv<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2926#if(CXSC_INDEX_CHECK)
2931 {
return _mmsconv<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2933#if(CXSC_INDEX_CHECK)
2938 {
return _mmsconv<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2940#if(CXSC_INDEX_CHECK)
2945 {
return _mmsconv<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2947#if(CXSC_INDEX_CHECK)
2952 {
return _msmsconv<cmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2954#if(CXSC_INDEX_CHECK)
2959 {
return _msmsconv<cmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2961#if(CXSC_INDEX_CHECK)
2966 {
return _mmconvassign(m1,m2); }
2968#if(CXSC_INDEX_CHECK)
2973 {
return _mmsconvassign(m1,ms); }
2975#if(CXSC_INDEX_CHECK)
2980 {
return _msmconvassign(*
this,m1); }
2982#if(CXSC_INDEX_CHECK)
2987 {
return _msmsconvassign(*
this,ms2); }
2989#if(CXSC_INDEX_CHECK)
2994 {
return _mmsect<cmatrix,cimatrix,cimatrix>(m1,m2); }
2996#if(CXSC_INDEX_CHECK)
3001 {
return _mmsect<cmatrix,cimatrix,cimatrix>(m2,m1); }
3003#if(CXSC_INDEX_CHECK)
3008 {
return _mmssect<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
3010#if(CXSC_INDEX_CHECK)
3015 {
return _mmssect<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
3017#if(CXSC_INDEX_CHECK)
3022 {
return _mmssect<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
3024#if(CXSC_INDEX_CHECK)
3029 {
return _mmssect<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
3031#if(CXSC_INDEX_CHECK)
3036 {
return _msmssect<cmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3038#if(CXSC_INDEX_CHECK)
3043 {
return _msmssect<cmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3045#if(CXSC_INDEX_CHECK)
3050 {
return _mmsectassign(m1,m2); }
3052#if(CXSC_INDEX_CHECK)
3057 {
return _mmssectassign(m1,ms); }
3059#if(CXSC_INDEX_CHECK)
3064 {
return _msmsectassign(*
this,m1); }
3066#if(CXSC_INDEX_CHECK)
3071 {
return _msmssectassign(*
this,ms2); }
3074#if(CXSC_INDEX_CHECK)
3079 {
return _mmplus<imatrix,cimatrix,cimatrix>(m1,m2); }
3081#if(CXSC_INDEX_CHECK)
3086 {
return _mmplus<imatrix,cimatrix,cimatrix>(m2,m1); }
3088#if(CXSC_INDEX_CHECK)
3093 {
return _mmsplus<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3095#if(CXSC_INDEX_CHECK)
3100 {
return _mmsplus<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3102#if(CXSC_INDEX_CHECK)
3107 {
return _mmsplus<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3109#if(CXSC_INDEX_CHECK)
3114 {
return _mmsplus<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3116#if(CXSC_INDEX_CHECK)
3121 {
return _msmsplus<imatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3123#if(CXSC_INDEX_CHECK)
3128 {
return _msmsplus<imatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3130#if(CXSC_INDEX_CHECK)
3135 {
return _mmplusassign(m1,m2); }
3137#if(CXSC_INDEX_CHECK)
3142 {
return _mmsplusassign(m1,ms); }
3144#if(CXSC_INDEX_CHECK)
3149 {
return _msmplusassign(*
this,m1); }
3151#if(CXSC_INDEX_CHECK)
3156 {
return _msmsplusassign(*
this,ms2); }
3158#if(CXSC_INDEX_CHECK)
3163 {
return _mmminus<imatrix,cimatrix,cimatrix>(m1,m2); }
3165#if(CXSC_INDEX_CHECK)
3170 {
return _mmminus<cimatrix,imatrix,cimatrix>(m1,m2); }
3172#if(CXSC_INDEX_CHECK)
3177 {
return _mmsminus<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3179#if(CXSC_INDEX_CHECK)
3184 {
return _mmsminus<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3186#if(CXSC_INDEX_CHECK)
3191 {
return _msmminus<imatrix_slice,cimatrix,cimatrix>(ms,m); }
3193#if(CXSC_INDEX_CHECK)
3198 {
return _msmminus<cimatrix_slice,imatrix,cimatrix>(ms,m); }
3200#if(CXSC_INDEX_CHECK)
3205 {
return _msmsminus<imatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
3207#if(CXSC_INDEX_CHECK)
3212 {
return _msmsminus<cimatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3214#if(CXSC_INDEX_CHECK)
3219 {
return _mmminusassign(m1,m2); }
3221#if(CXSC_INDEX_CHECK)
3226 {
return _mmsminusassign(m1,ms); }
3228#if(CXSC_INDEX_CHECK)
3233 {
return _msmminusassign(*
this,m1); }
3235#if(CXSC_INDEX_CHECK)
3240 {
return _msmsminusassign(*
this,ms2); }
3242#if(CXSC_INDEX_CHECK)
3247 {
return _mmcimult<imatrix,cimatrix,cimatrix>(m1,m2); }
3249#if(CXSC_INDEX_CHECK)
3254 {
return _mmcimult<cimatrix,imatrix,cimatrix>(m1,m2); }
3256#if(CXSC_INDEX_CHECK)
3261 {
return _mmscimult<imatrix,cimatrix_slice,cimatrix>(m1,ms); }
3263#if(CXSC_INDEX_CHECK)
3268 {
return _mmscimult<cimatrix,imatrix_slice,cimatrix>(m1,ms); }
3270#if(CXSC_INDEX_CHECK)
3275 {
return _msmcimult<imatrix_slice,cimatrix,cimatrix>(ms,m1); }
3277#if(CXSC_INDEX_CHECK)
3282 {
return _msmcimult<cimatrix_slice,imatrix,cimatrix>(ms,m1); }
3284#if(CXSC_INDEX_CHECK)
3289 {
return _msmscimult<imatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
3291#if(CXSC_INDEX_CHECK)
3296 {
return _msmscimult<cimatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3298#if(CXSC_INDEX_CHECK)
3303 {
return _mmcimultassign<cimatrix,imatrix,cinterval>(m1,m2); }
3305#if(CXSC_INDEX_CHECK)
3310 {
return _mmscimultassign<cimatrix,imatrix_slice,cinterval>(m1,ms); }
3312#if(CXSC_INDEX_CHECK)
3317 {
return _mmconv<imatrix,cimatrix,cimatrix>(m1,m2); }
3319#if(CXSC_INDEX_CHECK)
3324 {
return _mmconv<imatrix,cimatrix,cimatrix>(m2,m1); }
3326#if(CXSC_INDEX_CHECK)
3331 {
return _mmsconv<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3333#if(CXSC_INDEX_CHECK)
3338 {
return _mmsconv<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3340#if(CXSC_INDEX_CHECK)
3345 {
return _mmsconv<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3347#if(CXSC_INDEX_CHECK)
3352 {
return _mmsconv<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3354#if(CXSC_INDEX_CHECK)
3359 {
return _msmsconv<imatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3361#if(CXSC_INDEX_CHECK)
3366 {
return _msmsconv<imatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3368#if(CXSC_INDEX_CHECK)
3373 {
return _mmconvassign(m1,m2); }
3375#if(CXSC_INDEX_CHECK)
3380 {
return _mmsconvassign(m1,ms); }
3382#if(CXSC_INDEX_CHECK)
3387 {
return _msmconvassign(*
this,m1); }
3389#if(CXSC_INDEX_CHECK)
3394 {
return _msmsconvassign(*
this,ms2); }
3396#if(CXSC_INDEX_CHECK)
3401 {
return _mmsect<imatrix,cimatrix,cimatrix>(m1,m2); }
3403#if(CXSC_INDEX_CHECK)
3408 {
return _mmsect<imatrix,cimatrix,cimatrix>(m2,m1); }
3410#if(CXSC_INDEX_CHECK)
3415 {
return _mmssect<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3417#if(CXSC_INDEX_CHECK)
3422 {
return _mmssect<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3424#if(CXSC_INDEX_CHECK)
3429 {
return _mmssect<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3431#if(CXSC_INDEX_CHECK)
3436 {
return _mmssect<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3438#if(CXSC_INDEX_CHECK)
3443 {
return _msmssect<imatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3445#if(CXSC_INDEX_CHECK)
3450 {
return _msmssect<imatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3452#if(CXSC_INDEX_CHECK)
3457 {
return _mmsectassign(m1,m2); }
3459#if(CXSC_INDEX_CHECK)
3464 {
return _mmssectassign(m1,ms); }
3466#if(CXSC_INDEX_CHECK)
3471 {
return _msmsectassign(*
this,m1); }
3473#if(CXSC_INDEX_CHECK)
3478 {
return _msmssectassign(*
this,ms2); }
3481#if(CXSC_INDEX_CHECK)
3486 {
return _mmplus<cmatrix,imatrix,cimatrix>(m1,m2); }
3488#if(CXSC_INDEX_CHECK)
3493 {
return _mmplus<cmatrix,imatrix,cimatrix>(m2,m1); }
3495#if(CXSC_INDEX_CHECK)
3500 {
return _mmsplus<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3502#if(CXSC_INDEX_CHECK)
3507 {
return _mmsplus<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3509#if(CXSC_INDEX_CHECK)
3514 {
return _mmsplus<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3516#if(CXSC_INDEX_CHECK)
3521 {
return _mmsplus<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3523#if(CXSC_INDEX_CHECK)
3528 {
return _msmsplus<cmatrix_slice,imatrix_slice,cimatrix>(m1,m2); }
3530#if(CXSC_INDEX_CHECK)
3535 {
return _msmsplus<cmatrix_slice,imatrix_slice,cimatrix>(m2,m1); }
3537#if(CXSC_INDEX_CHECK)
3542 {
return _mmminus<cmatrix,imatrix,cimatrix>(m1,m2); }
3544#if(CXSC_INDEX_CHECK)
3549 {
return _mmminus<imatrix,cmatrix,cimatrix>(m1,m2); }
3551#if(CXSC_INDEX_CHECK)
3556 {
return _mmsminus<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3558#if(CXSC_INDEX_CHECK)
3563 {
return _mmsminus<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3565#if(CXSC_INDEX_CHECK)
3570 {
return _msmminus<cmatrix_slice,imatrix,cimatrix>(ms,m); }
3572#if(CXSC_INDEX_CHECK)
3577 {
return _msmminus<imatrix_slice,cmatrix,cimatrix>(ms,m); }
3579#if(CXSC_INDEX_CHECK)
3584 {
return _msmsminus<cmatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3586#if(CXSC_INDEX_CHECK)
3591 {
return _msmsminus<imatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
3593#if(CXSC_INDEX_CHECK)
3598 {
return _mmcimult<cmatrix,imatrix,cimatrix>(m1,m2); }
3600#if(CXSC_INDEX_CHECK)
3605 {
return _mmcimult<imatrix,cmatrix,cimatrix>(m1,m2); }
3607#if(CXSC_INDEX_CHECK)
3612 {
return _mmscimult<cmatrix,imatrix_slice,cimatrix>(m1,ms); }
3614#if(CXSC_INDEX_CHECK)
3619 {
return _mmscimult<imatrix,cmatrix_slice,cimatrix>(m1,ms); }
3621#if(CXSC_INDEX_CHECK)
3626 {
return _msmcimult<cmatrix_slice,imatrix,cimatrix>(ms,m1); }
3628#if(CXSC_INDEX_CHECK)
3633 {
return _msmcimult<imatrix_slice,cmatrix,cimatrix>(ms,m1); }
3635#if(CXSC_INDEX_CHECK)
3640 {
return _msmscimult<cmatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3642#if(CXSC_INDEX_CHECK)
3647 {
return _msmscimult<imatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
3649#if(CXSC_INDEX_CHECK)
3654 {
return _mmconv<cmatrix,imatrix,cimatrix>(m1,m2); }
3656#if(CXSC_INDEX_CHECK)
3661 {
return _mmconv<cmatrix,imatrix,cimatrix>(m2,m1); }
3663#if(CXSC_INDEX_CHECK)
3668 {
return _mmsconv<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3670#if(CXSC_INDEX_CHECK)
3675 {
return _mmsconv<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3677#if(CXSC_INDEX_CHECK)
3682 {
return _mmsconv<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3684#if(CXSC_INDEX_CHECK)
3689 {
return _mmsconv<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3691#if(CXSC_INDEX_CHECK)
3696 {
return _msmsconv<cmatrix_slice,imatrix_slice,cimatrix>(m1,m2); }
3698#if(CXSC_INDEX_CHECK)
3703 {
return _msmsconv<cmatrix_slice,imatrix_slice,cimatrix>(m2,m1); }
3705#if(CXSC_INDEX_CHECK)
3710 {
return _mmsect<cmatrix,imatrix,cimatrix>(m1,m2); }
3712#if(CXSC_INDEX_CHECK)
3717 {
return _mmsect<cmatrix,imatrix,cimatrix>(m2,m1); }
3719#if(CXSC_INDEX_CHECK)
3724 {
return _mmssect<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3726#if(CXSC_INDEX_CHECK)
3731 {
return _mmssect<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3733#if(CXSC_INDEX_CHECK)
3738 {
return _mmssect<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3740#if(CXSC_INDEX_CHECK)
3745 {
return _mmssect<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3747#if(CXSC_INDEX_CHECK)
3752 {
return _msmssect<cmatrix_slice,imatrix_slice,cimatrix>(m1,m2); }
3754#if(CXSC_INDEX_CHECK)
3759 {
return _msmssect<cmatrix_slice,imatrix_slice,cimatrix>(m2,m1); }
3763#if(CXSC_INDEX_CHECK)
3768 {
return _mmconv<rmatrix,cmatrix,cimatrix>(rv1,rv2); }
3770#if(CXSC_INDEX_CHECK)
3775 {
return _mmconv<rmatrix,cmatrix,cimatrix>(rv2,rv1); }
3777#if(CXSC_INDEX_CHECK)
3782 {
return _mmsconv<cmatrix,rmatrix_slice,cimatrix>(rv,sl); }
3784#if(CXSC_INDEX_CHECK)
3789 {
return _mmsconv<cmatrix,rmatrix_slice,cimatrix>(rv,sl); }
3791#if(CXSC_INDEX_CHECK)
3796 {
return _mmsconv<rmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3798#if(CXSC_INDEX_CHECK)
3803 {
return _mmsconv<rmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3805#if(CXSC_INDEX_CHECK)
3810 {
return _msmsconv<rmatrix_slice,cmatrix_slice,cimatrix>(sl2,sl1); }
3812#if(CXSC_INDEX_CHECK)
3817 {
return _msmsconv<rmatrix_slice,cmatrix_slice,cimatrix>(sl1,sl2); }
3821#if(CXSC_INDEX_CHECK)
3826 {
return _mmconv<cmatrix,cmatrix,cimatrix>(rv1,rv2); }
3828#if(CXSC_INDEX_CHECK)
3833 {
return _mmsconv<cmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3835#if(CXSC_INDEX_CHECK)
3840 {
return _mmsconv<cmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3842#if(CXSC_INDEX_CHECK)
3847 {
return _msmsconv<cmatrix_slice,cmatrix_slice,cimatrix>(sl1,sl2); }
3849 INLINE
bool operator ==(
const cimatrix &m1,
const cimatrix &m2)
noexcept {
return _mmeq(m1,m2); }
3850 INLINE
bool operator !=(
const cimatrix &m1,
const cimatrix &m2)
noexcept {
return _mmneq(m1,m2); }
3851 INLINE
bool operator <(
const cimatrix &m1,
const cimatrix &m2)
noexcept {
return _mmless(m1,m2); }
3852 INLINE
bool operator <=(
const cimatrix &m1,
const cimatrix &m2)
noexcept {
return _mmleq(m1,m2); }
3853 INLINE
bool operator >(
const cimatrix &m1,
const cimatrix &m2)
noexcept {
return _mmless(m2,m1); }
3854 INLINE
bool operator >=(
const cimatrix &m1,
const cimatrix &m2)
noexcept {
return _mmleq(m2,m1); }
3867 INLINE
bool operator !(
const cimatrix &ms)
noexcept {
return _mnot(ms); }
3869 INLINE std::ostream &operator <<(std::ostream &s,
const cimatrix &r)
noexcept {
return _mout(s,r); }
3870 INLINE std::ostream &operator <<(std::ostream &s,
const cimatrix_slice &r)
noexcept {
return _msout(s,r); }
3871 INLINE std::istream &operator >>(std::istream &s,
cimatrix &r)
noexcept {
return _min(s,r); }
3872 INLINE std::istream &operator >>(std::istream &s,
cimatrix_slice &r)
noexcept {
return _msin(s,r); }
3877 for(
int i=0 ; i<
ColLen(A) ; i++)
3878 for(
int j=0 ; j<
RowLen(A) ; j++)
3879 A[i+
Lb(A,1)][j+
Lb(A,2)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)][q[j+
Lb(q)]+
Lb(A,2)];
3886 for(
int i=0 ; i<
ColLen(A) ; i++)
3887 A[i+
Lb(A,1)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)];
3901 return (*
this)(p,q);
The Data Type cimatrix_slice.
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
cimatrix_slice & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
cimatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
cimatrix_slice & operator=(const cimatrix &m) noexcept
Implementation of standard assigning operator.
cimatrix_slice & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
cimatrix_slice & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
cimatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
The Data Type cimatrix_subv.
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
cimatrix_subv & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
cimatrix_subv & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
cimatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
cimatrix_subv & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
cimatrix_subv & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
cimatrix & operator()() noexcept
Operator for accessing the whole matrix.
cimatrix & operator=(const cinterval &r) noexcept
Implementation of standard assigning operator.
cimatrix() noexcept
Constructor of class cimatrix.
cimatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
The Scalar Type cinterval.
cinterval(void) noexcept
Constructor of class cinterval.
The Data Type civector_slice.
civector_slice & operator*=(const cinterval &r) noexcept
Implementation of multiplication and allocation operation.
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
civector & operator()() noexcept
Operator for accessing the whole vector.
civector() noexcept
Constructor of class civector.
The Data Type cmatrix_slice.
The Data Type cmatrix_subv.
The Data Type cvector_slice.
The Data Type imatrix_slice.
The Data Type imatrix_subv.
The Scalar Type interval.
The Data Type ivector_slice.
The Data Type rmatrix_slice.
The Data Type rmatrix_subv.
The Data Type rvector_slice.
The namespace cxsc, providing all functionality of the class library C-XSC.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
int ColLen(const cimatrix &)
Returns the column dimension.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
cimatrix _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.