26#ifndef _CXSC_LIMATRIX_INL_INCLUDED
27#define _CXSC_LIMATRIX_INL_INCLUDED
62 for(
int i=0;i<xsize*ysize;i++)
69 for(
int i=0;i<xsize*ysize;i++)
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_LIMATRIX_WRONG_BOUNDARIES(
"l_imatrix::l_imatrix(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_LIMATRIX_WRONG_BOUNDARIES(
"l_imatrix::l_imatrix(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)
126{
return _vsvassign(*
this,
l_ivector(m)); }
132 for(
int i=0;i<v.size;i++)
139 for(
int i=0;i<v.size;i++)
146 for(
int i=0;i<v.size;i++)
153 for(
int i=0;i<v.size;i++)
160 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
167 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
174 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
181 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
193 if((i<lb)||(i>ub)) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC(
"l_interval &l_imatrix_subv::operator [](const int &i)"));
195 return dat[start+((i-lb)*offset)];
203 for (i=0;i<ysize;i++)
207 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
217 for (i=0;i<ysize;i++)
221 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
230 for (i=0;i<ysize;i++)
234 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
243 for (i=0;i<ysize;i++)
247 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
304 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"l_imatrix_subv l_imatrix::operator [](const int &i)"));
317 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"l_imatrix_subv l_imatrix::operator [](const cxscmatrix_column &i)"));
330 if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG(
"l_imatrix_slice l_imatrix::operator ()(const int &m, const int &n)"));
343 if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG(
"l_imatrix_slice l_imatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
356 if((i<start1)||(i>end1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"l_imatrix_subv l_imatrix_slice::operator [](const int &i)"));
358 return l_imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
369 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"l_imatrix_subv l_imatrix_slice::operator [](const cxscmatrix_column &i)"));
371 return l_imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
382 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG(
"l_imatrix_slice l_imatrix_slice::operator ()(const int &m, const int &n)"));
395 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG(
"l_imatrix_slice l_imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
408 if(1<lb||i>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_imatrix_subv l_imatrix_subv::operator ()(const int &i)"));
421 if(i1<lb||i2>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_imatrix_subv l_imatrix_subv::operator ()(const int &i1,const int &i2)"));
423 return l_imatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
436 {
return _mvvassign(*
this,v); }
443 {
return _mvvassign(*
this,
l_ivector(v)); }
453 {
return _mvvassign(*
this,v); }
460 {
return _mvvassign(*
this,
l_ivector(v)); }
470 {
return _mvvassign(*
this,v); }
477 {
return _mvvassign(*
this,
l_ivector(v)); }
487 {
return _mvvassign(*
this,v); }
494 {
return _mvvassign(*
this,
l_ivector(v)); }
520 INLINE l_imatrix::operator
void*()
noexcept {
return _mvoid(*
this); }
528 {
return _msmassign(*
this,m); }
535 {
return _msmsassign(*
this,ms); }
543 {
return _msmassign(*
this,
l_imatrix(v)); }
565 {
return _msmassign(*
this,m); }
572 {
return _msmsassign(*
this,ms); }
580 {
return _msmassign(*
this,
l_imatrix(v)); }
602 {
return _msmassign(*
this,m); }
609 {
return _msmsassign(*
this,ms); }
617 {
return _msmassign(*
this,
l_imatrix(v)); }
639 {
return _msmassign(*
this,m); }
646 {
return _msmsassign(*
this,ms); }
654 {
return _msmassign(*
this,
l_imatrix(v)); }
670 INLINE l_imatrix_slice::operator
void*()
noexcept {
return _msvoid(*
this); }
690 {
return _mvvsetinf(iv,rv); }
697 {
return _mvvsetsup(iv,rv); }
704 {
return _mvvusetinf(iv,rv); }
711 {
return _mvvusetsup(iv,rv); }
725 { _mvmvaccu(dp,rv1,rv2); }
732 { _vmvaccu(dp,rv1,rv2); }
739 { _vmvaccu(dp,rv2,rv1); }
761 {
return _mvmvlimult<l_imatrix_subv,l_imatrix_subv,l_interval>(rv1,rv2); }
768 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv1,rv2); }
775 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv2,rv1); }
782 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(
l_ivector(sl),sv); }
789 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(
l_ivector(vs),mv); }
796 {
return _mvmvplus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
803 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
810 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
817 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,
l_ivector(sl)); }
824 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,
l_ivector(sl)); }
831 {
return _mvvplusassign(*
this,rv); }
838 {
return _mvvplusassign(*
this,
l_ivector(rv)); }
845 {
return _mvmvminus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
852 {
return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(rv1,rv2); }
859 {
return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
866 {
return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(
l_ivector(sl),mv); }
873 {
return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(mv,
l_ivector(sl)); }
880 {
return _mvvminusassign(*
this,rv); }
887 {
return _mvvminusassign(*
this,
l_ivector(rv)); }
894 {
return _mvmvconv<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
895 INLINE l_ivector operator |(
const l_imatrix_subv &rv1,
const l_ivector &rv2)
901 {
return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
902 INLINE l_ivector operator |(
const l_ivector & rv1,
const l_imatrix_subv &rv2)
908 {
return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
909 INLINE l_ivector operator |(
const l_ivector_slice &sl,
const l_imatrix_subv &mv)
915 {
return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
916 INLINE l_ivector operator |(
const l_imatrix_subv &mv,
const l_ivector_slice &sl)
922 {
return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
929 {
return _mvvconvassign(*
this,rv); }
936 {
return _mvvconvassign(*
this,
l_ivector(rv)); }
943 {
return _mvmvsect<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
944 INLINE l_ivector operator &(
const l_imatrix_subv &rv1,
const l_ivector &rv2)
950 {
return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
951 INLINE l_ivector operator &(
const l_ivector & rv1,
const l_imatrix_subv &rv2)
957 {
return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
958 INLINE l_ivector operator &(
const l_ivector_slice &sl,
const l_imatrix_subv &mv)
964 {
return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
965 INLINE l_ivector operator &(
const l_imatrix_subv &mv,
const l_ivector_slice &sl)
971 {
return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
978 {
return _mvvsectassign(*
this,rv); }
985 {
return _mvvsectassign(*
this,
l_ivector(rv)); }
994 { _mvmvaccu(dp,rv2,rv1); }
1001 { _vmvaccu(dp,
rvector(sl2),rv1); }
1003#if(CXSC_INDEX_CHECK)
1008 { _vmvaccu(dp,rv2,rv1); }
1010#if(CXSC_INDEX_CHECK)
1015 { _mvmvaccu(dp,rv1,rv2); }
1017#if(CXSC_INDEX_CHECK)
1022 { _vmvaccu(dp,
rvector(sl1),rv2); }
1024#if(CXSC_INDEX_CHECK)
1029 { _vmvaccu(dp,rv1,rv2); }
1032#if(CXSC_INDEX_CHECK)
1037 { _mvmvaccu(dp,rv2,rv1); }
1039#if(CXSC_INDEX_CHECK)
1046#if(CXSC_INDEX_CHECK)
1051 { _vmvaccu(dp,rv2,rv1); }
1053#if(CXSC_INDEX_CHECK)
1058 { _mvmvaccu(dp,rv1,rv2); }
1060#if(CXSC_INDEX_CHECK)
1067#if(CXSC_INDEX_CHECK)
1072 { _vmvaccu(dp,rv1,rv2); }
1075#if(CXSC_INDEX_CHECK)
1080 { _mvmvaccu(dp,rv2,rv1); }
1082#if(CXSC_INDEX_CHECK)
1087 { _vmvaccu(dp,
ivector(sl2),rv1); }
1089#if(CXSC_INDEX_CHECK)
1094 { _vmvaccu(dp,rv2,rv1); }
1096#if(CXSC_INDEX_CHECK)
1101 { _mvmvaccu(dp,rv1,rv2); }
1103#if(CXSC_INDEX_CHECK)
1108 { _vmvaccu(dp,
ivector(sl1),rv2); }
1110#if(CXSC_INDEX_CHECK)
1115 { _vmvaccu(dp,rv1,rv2); }
1145#if(CXSC_INDEX_CHECK)
1150 {
return _mlb(rm,i); }
1152#if(CXSC_INDEX_CHECK)
1157 {
return _mub(rm,i); }
1159#if(CXSC_INDEX_CHECK)
1164 {
return _mslb(rm,i); }
1166#if(CXSC_INDEX_CHECK)
1171 {
return _msub(rm,i); }
1173#if(CXSC_INDEX_CHECK)
1178 {
return _msetlb(m,i,j); }
1180#if(CXSC_INDEX_CHECK)
1185 {
return _msetub(m,i,j); }
1189 {
return Ub(A,2)-
Lb(A,2)+1; }
1192 {
return Ub(A,1)-
Lb(A,1)+1; }
1195 {
return Ub(A,2)-
Lb(A,2)+1; }
1198 {
return Ub(A,1)-
Lb(A,1)+1; }
1202#if(CXSC_INDEX_CHECK)
1207 { _mresize<l_imatrix,l_interval>(A,m,n); }
1209#if(CXSC_INDEX_CHECK)
1214 { _mresize<l_imatrix,l_interval>(A,m1,m2,n1,n2); }
1226#if(CXSC_INDEX_CHECK)
1231 {
return _mmsetinf<l_imatrix,l_rmatrix>(cm,rm); }
1233#if(CXSC_INDEX_CHECK)
1238 {
return _msmsetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
1240#if(CXSC_INDEX_CHECK)
1245 {
return _mmssetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
1247#if(CXSC_INDEX_CHECK)
1252 {
return _msmssetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1254#if(CXSC_INDEX_CHECK)
1259 {
return _mmsetsup<l_imatrix,l_rmatrix>(cm,rm); }
1261#if(CXSC_INDEX_CHECK)
1266 {
return _msmsetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
1268#if(CXSC_INDEX_CHECK)
1273 {
return _mmssetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
1275#if(CXSC_INDEX_CHECK)
1280 {
return _msmssetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1282#if(CXSC_INDEX_CHECK)
1287 {
return _mmusetinf<l_imatrix,l_rmatrix>(cm,rm); }
1289#if(CXSC_INDEX_CHECK)
1294 {
return _msmusetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
1296#if(CXSC_INDEX_CHECK)
1301 {
return _mmsusetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
1303#if(CXSC_INDEX_CHECK)
1308 {
return _msmsusetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1310#if(CXSC_INDEX_CHECK)
1315 {
return _mmusetsup<l_imatrix,l_rmatrix>(cm,rm); }
1317#if(CXSC_INDEX_CHECK)
1322 {
return _msmusetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
1324#if(CXSC_INDEX_CHECK)
1329 {
return _mmsusetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
1331#if(CXSC_INDEX_CHECK)
1336 {
return _msmsusetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1338#if(CXSC_INDEX_CHECK)
1343 { _smconstr(*
this,m); }
1351#if(CXSC_INDEX_CHECK)
1356 {
return _mvvplusassign(*
this,rv); }
1358#if(CXSC_INDEX_CHECK)
1363 {
return _mvvplusassign(*
this,
rvector(rv)); }
1365#if(CXSC_INDEX_CHECK)
1370 {
return _mvvminusassign(*
this,rv); }
1372#if(CXSC_INDEX_CHECK)
1377 {
return _mvvminusassign(*
this,
rvector(rv)); }
1379#if(CXSC_INDEX_CHECK)
1384 {
return _mvvconvassign(*
this,rv); }
1386#if(CXSC_INDEX_CHECK)
1391 {
return _mvvconvassign(*
this,
rvector(rv)); }
1393#if(CXSC_INDEX_CHECK)
1398 {
return _mvvsectassign(*
this,rv); }
1400#if(CXSC_INDEX_CHECK)
1405 {
return _mvvsectassign(*
this,
rvector(rv)); }
1412#if(CXSC_INDEX_CHECK)
1417 {
return _mvvplusassign(*
this,rv); }
1419#if(CXSC_INDEX_CHECK)
1424 {
return _mvvplusassign(*
this,
l_rvector(rv)); }
1426#if(CXSC_INDEX_CHECK)
1431 {
return _mvvminusassign(*
this,rv); }
1433#if(CXSC_INDEX_CHECK)
1438 {
return _mvvminusassign(*
this,
l_rvector(rv)); }
1440#if(CXSC_INDEX_CHECK)
1445 {
return _mvvconvassign(*
this,rv); }
1447#if(CXSC_INDEX_CHECK)
1452 {
return _mvvconvassign(*
this,
l_rvector(rv)); }
1454#if(CXSC_INDEX_CHECK)
1459 {
return _mvvsectassign(*
this,rv); }
1461#if(CXSC_INDEX_CHECK)
1466 {
return _mvvsectassign(*
this,
l_rvector(rv)); }
1473#if(CXSC_INDEX_CHECK)
1478 {
return _mvvplusassign(*
this,rv); }
1480#if(CXSC_INDEX_CHECK)
1485 {
return _mvvplusassign(*
this,
ivector(rv)); }
1487#if(CXSC_INDEX_CHECK)
1492 {
return _mvvminusassign(*
this,rv); }
1494#if(CXSC_INDEX_CHECK)
1499 {
return _mvvminusassign(*
this,
ivector(rv)); }
1501#if(CXSC_INDEX_CHECK)
1506 {
return _mvvconvassign(*
this,rv); }
1508#if(CXSC_INDEX_CHECK)
1513 {
return _mvvconvassign(*
this,
ivector(rv)); }
1515#if(CXSC_INDEX_CHECK)
1520 {
return _mvvsectassign(*
this,rv); }
1522#if(CXSC_INDEX_CHECK)
1527 {
return _mvvsectassign(*
this,
ivector(rv)); }
1536#if(CXSC_INDEX_CHECK)
1541 {
return (*
this=*
this*m); }
1543#if(CXSC_INDEX_CHECK)
1548 {
return (*
this=*
this*m); }
1561#if(CXSC_INDEX_CHECK)
1566 {
return (*
this=*
this*m); }
1568#if(CXSC_INDEX_CHECK)
1573 {
return (*
this=*
this*m); }
1586#if(CXSC_INDEX_CHECK)
1591 {
return (*
this=*
this*m); }
1593#if(CXSC_INDEX_CHECK)
1598 {
return (*
this=*
this*m); }
1611#if(CXSC_INDEX_CHECK)
1616 {
return (*
this=*
this*m); }
1618#if(CXSC_INDEX_CHECK)
1623 {
return (*
this=*
this*m); }
1655#if(CXSC_INDEX_CHECK)
1660 { _vmconstr<l_ivector,l_imatrix,l_interval>(*
this,sl); }
1662#if(CXSC_INDEX_CHECK)
1667 { _vmsconstr<l_ivector,l_imatrix_slice,l_interval>(*
this,sl); }
1669#if(CXSC_INDEX_CHECK)
1674 {
return _vmassign<l_ivector,l_imatrix,l_interval>(*
this,m); }
1676#if(CXSC_INDEX_CHECK)
1681 {
return _vmassign<l_ivector,l_imatrix,l_interval>(*
this,
l_imatrix(m)); }
1683#if(CXSC_INDEX_CHECK)
1690#if(CXSC_INDEX_CHECK)
1695 {
return _mvvassign(*
this,
l_ivector(m)); }
1697#if(CXSC_INDEX_CHECK)
1704#if(CXSC_INDEX_CHECK)
1709 {
return _mvlimult<l_imatrix,l_ivector,l_ivector>(m,v); }
1711#if(CXSC_INDEX_CHECK)
1716 {
return _msvlimult<l_imatrix_slice,l_ivector,l_ivector>(ms,v); }
1718#if(CXSC_INDEX_CHECK)
1723 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(v,m); }
1725#if(CXSC_INDEX_CHECK)
1730 {
return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(v,ms); }
1732#if(CXSC_INDEX_CHECK)
1737 {
return _vmlimultassign<l_ivector,l_imatrix,l_interval>(v,m); }
1739#if(CXSC_INDEX_CHECK)
1744 {
return _vmslimultassign<l_ivector,l_imatrix_slice,l_interval>(v,ms); }
1746#if(CXSC_INDEX_CHECK)
1751 {
return _vsmlimultassign<l_ivector_slice,l_imatrix,l_interval>(*
this,m); }
1753#if(CXSC_INDEX_CHECK)
1758 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1760#if(CXSC_INDEX_CHECK)
1765 {
return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(
l_ivector(v),m); }
1768#if(CXSC_INDEX_CHECK)
1773 {
return _mvvassign(*
this,
rvector(m)); }
1775#if(CXSC_INDEX_CHECK)
1782#if(CXSC_INDEX_CHECK)
1787 {
return _vmlimult<rvector,l_imatrix,l_ivector>(v,m); }
1789#if(CXSC_INDEX_CHECK)
1794 {
return _vmslimult<rvector,l_imatrix_slice,l_ivector>(v,ms); }
1796#if(CXSC_INDEX_CHECK)
1801 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1803#if(CXSC_INDEX_CHECK)
1808 {
return _mvlimult<l_imatrix,rvector,l_ivector>(m,v); }
1810#if(CXSC_INDEX_CHECK)
1815 {
return _msvlimult<l_imatrix_slice,rvector,l_ivector>(ms,v); }
1818#if(CXSC_INDEX_CHECK)
1823 {
return _mvvassign(*
this,
l_rvector(m)); }
1825#if(CXSC_INDEX_CHECK)
1832#if(CXSC_INDEX_CHECK)
1837 {
return _vmlimult<l_rvector,l_imatrix,l_ivector>(v,m); }
1839#if(CXSC_INDEX_CHECK)
1844 {
return _vmslimult<l_rvector,l_imatrix_slice,l_ivector>(v,ms); }
1846#if(CXSC_INDEX_CHECK)
1851 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1853#if(CXSC_INDEX_CHECK)
1858 {
return _mvlimult<l_imatrix,l_rvector,l_ivector>(m,v); }
1860#if(CXSC_INDEX_CHECK)
1865 {
return _msvlimult<l_imatrix_slice,l_rvector,l_ivector>(ms,v); }
1868#if(CXSC_INDEX_CHECK)
1873 {
return _mvvassign(*
this,
ivector(m)); }
1875#if(CXSC_INDEX_CHECK)
1882#if(CXSC_INDEX_CHECK)
1887 {
return _vmlimult<ivector,l_imatrix,l_ivector>(v,m); }
1889#if(CXSC_INDEX_CHECK)
1894 {
return _vmslimult<ivector,l_imatrix_slice,l_ivector>(v,ms); }
1896#if(CXSC_INDEX_CHECK)
1901 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1903#if(CXSC_INDEX_CHECK)
1908 {
return _mvlimult<l_imatrix,ivector,l_ivector>(m,v); }
1910#if(CXSC_INDEX_CHECK)
1915 {
return _msvlimult<l_imatrix_slice,ivector,l_ivector>(ms,v); }
1920#if(CXSC_INDEX_CHECK)
1925 {
return _mmplus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
1927#if(CXSC_INDEX_CHECK)
1932 {
return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1934#if(CXSC_INDEX_CHECK)
1939 {
return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1941#if(CXSC_INDEX_CHECK)
1946 {
return _msmsplus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
1948#if(CXSC_INDEX_CHECK)
1953 {
return _mmplusassign(m1,m2); }
1955#if(CXSC_INDEX_CHECK)
1960 {
return _mmsplusassign(m1,ms); }
1962#if(CXSC_INDEX_CHECK)
1967 {
return _msmplusassign(*
this,m1); }
1969#if(CXSC_INDEX_CHECK)
1974 {
return _msmsplusassign(*
this,ms2); }
1978#if(CXSC_INDEX_CHECK)
1983 {
return _mmminus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
1985#if(CXSC_INDEX_CHECK)
1990 {
return _mmsminus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1992#if(CXSC_INDEX_CHECK)
1997 {
return _msmminus<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
1999#if(CXSC_INDEX_CHECK)
2004 {
return _msmsminus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2006#if(CXSC_INDEX_CHECK)
2011 {
return _mmminusassign(m1,m2); }
2013#if(CXSC_INDEX_CHECK)
2018 {
return _mmsminusassign(m1,ms); }
2020#if(CXSC_INDEX_CHECK)
2025 {
return _msmminusassign(*
this,m1); }
2027#if(CXSC_INDEX_CHECK)
2032 {
return _msmsminusassign(*
this,ms2); }
2034#if(CXSC_INDEX_CHECK)
2039 {
return _mmlimult<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2041#if(CXSC_INDEX_CHECK)
2046 {
return _mmslimult<l_imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2048#if(CXSC_INDEX_CHECK)
2053 {
return _msmlimult<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2055#if(CXSC_INDEX_CHECK)
2060 {
return _msmslimult<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2062#if(CXSC_INDEX_CHECK)
2067 {
return _mmlimultassign<l_imatrix,l_imatrix,l_interval>(m1,m2); }
2069#if(CXSC_INDEX_CHECK)
2074 {
return _mmslimultassign<l_imatrix,l_imatrix_slice,l_interval>(m1,ms); }
2076#if(CXSC_INDEX_CHECK)
2081 {
return _mmconv<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2083#if(CXSC_INDEX_CHECK)
2088 {
return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2090#if(CXSC_INDEX_CHECK)
2095 {
return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2097#if(CXSC_INDEX_CHECK)
2102 {
return _msmsconv<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2104#if(CXSC_INDEX_CHECK)
2109 {
return _mmconvassign(m1,m2); }
2111#if(CXSC_INDEX_CHECK)
2116 {
return _mmsconvassign(m1,ms); }
2118#if(CXSC_INDEX_CHECK)
2123 {
return _msmconvassign(*
this,m1); }
2125#if(CXSC_INDEX_CHECK)
2130 {
return _msmsconvassign(*
this,ms2); }
2132#if(CXSC_INDEX_CHECK)
2137 {
return _mmsect<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2139#if(CXSC_INDEX_CHECK)
2144 {
return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2146#if(CXSC_INDEX_CHECK)
2151 {
return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2153#if(CXSC_INDEX_CHECK)
2158 {
return _msmssect<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2160#if(CXSC_INDEX_CHECK)
2165 {
return _mmsectassign(m1,m2); }
2167#if(CXSC_INDEX_CHECK)
2172 {
return _mmssectassign(m1,ms); }
2174#if(CXSC_INDEX_CHECK)
2179 {
return _msmsectassign(*
this,m1); }
2181#if(CXSC_INDEX_CHECK)
2186 {
return _msmssectassign(*
this,ms2); }
2189#if(CXSC_INDEX_CHECK)
2194 {
return _mmplus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2196#if(CXSC_INDEX_CHECK)
2201 {
return _mmplus<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2203#if(CXSC_INDEX_CHECK)
2208 {
return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2210#if(CXSC_INDEX_CHECK)
2215 {
return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2217#if(CXSC_INDEX_CHECK)
2222 {
return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2224#if(CXSC_INDEX_CHECK)
2229 {
return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2231#if(CXSC_INDEX_CHECK)
2236 {
return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2238#if(CXSC_INDEX_CHECK)
2243 {
return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2245#if(CXSC_INDEX_CHECK)
2250 {
return _mmplusassign(m1,m2); }
2252#if(CXSC_INDEX_CHECK)
2257 {
return _mmsplusassign(m1,ms); }
2259#if(CXSC_INDEX_CHECK)
2264 {
return _msmplusassign(*
this,m1); }
2266#if(CXSC_INDEX_CHECK)
2271 {
return _msmsplusassign(*
this,ms2); }
2273#if(CXSC_INDEX_CHECK)
2278 {
return _mmminus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2280#if(CXSC_INDEX_CHECK)
2285 {
return _mmminus<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
2287#if(CXSC_INDEX_CHECK)
2292 {
return _mmsminus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2294#if(CXSC_INDEX_CHECK)
2299 {
return _mmsminus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2301#if(CXSC_INDEX_CHECK)
2306 {
return _msmminus<rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
2308#if(CXSC_INDEX_CHECK)
2313 {
return _msmminus<l_imatrix_slice,rmatrix,l_imatrix>(ms,m); }
2315#if(CXSC_INDEX_CHECK)
2320 {
return _msmsminus<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2322#if(CXSC_INDEX_CHECK)
2327 {
return _msmsminus<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
2329#if(CXSC_INDEX_CHECK)
2334 {
return _mmminusassign(m1,m2); }
2336#if(CXSC_INDEX_CHECK)
2341 {
return _mmsminusassign(m1,ms); }
2343#if(CXSC_INDEX_CHECK)
2348 {
return _msmminusassign(*
this,m1); }
2350#if(CXSC_INDEX_CHECK)
2355 {
return _msmsminusassign(*
this,ms2); }
2357#if(CXSC_INDEX_CHECK)
2362 {
return _mmlimult<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2364#if(CXSC_INDEX_CHECK)
2369 {
return _mmlimult<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
2371#if(CXSC_INDEX_CHECK)
2376 {
return _mmslimult<rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2378#if(CXSC_INDEX_CHECK)
2383 {
return _mmslimult<l_imatrix,rmatrix_slice,l_imatrix>(m1,ms); }
2385#if(CXSC_INDEX_CHECK)
2390 {
return _msmlimult<rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2392#if(CXSC_INDEX_CHECK)
2397 {
return _msmlimult<l_imatrix_slice,rmatrix,l_imatrix>(ms,m1); }
2399#if(CXSC_INDEX_CHECK)
2404 {
return _msmslimult<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2406#if(CXSC_INDEX_CHECK)
2411 {
return _msmslimult<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
2413#if(CXSC_INDEX_CHECK)
2418 {
return _mmlimultassign<l_imatrix,rmatrix,l_interval>(m1,m2); }
2420#if(CXSC_INDEX_CHECK)
2425 {
return _mmslimultassign<l_imatrix,rmatrix_slice,l_interval>(m1,ms); }
2427#if(CXSC_INDEX_CHECK)
2432 {
return _mmconv<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2434#if(CXSC_INDEX_CHECK)
2439 {
return _mmconv<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2441#if(CXSC_INDEX_CHECK)
2446 {
return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2448#if(CXSC_INDEX_CHECK)
2453 {
return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2455#if(CXSC_INDEX_CHECK)
2460 {
return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2462#if(CXSC_INDEX_CHECK)
2467 {
return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2469#if(CXSC_INDEX_CHECK)
2474 {
return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2476#if(CXSC_INDEX_CHECK)
2481 {
return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2483#if(CXSC_INDEX_CHECK)
2488 {
return _mmconvassign(m1,m2); }
2490#if(CXSC_INDEX_CHECK)
2495 {
return _mmsconvassign(m1,ms); }
2497#if(CXSC_INDEX_CHECK)
2502 {
return _msmconvassign(*
this,m1); }
2504#if(CXSC_INDEX_CHECK)
2509 {
return _msmsconvassign(*
this,ms2); }
2511#if(CXSC_INDEX_CHECK)
2516 {
return _mmsect<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2518#if(CXSC_INDEX_CHECK)
2523 {
return _mmsect<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2525#if(CXSC_INDEX_CHECK)
2530 {
return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2532#if(CXSC_INDEX_CHECK)
2537 {
return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2539#if(CXSC_INDEX_CHECK)
2544 {
return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2546#if(CXSC_INDEX_CHECK)
2551 {
return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2553#if(CXSC_INDEX_CHECK)
2558 {
return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2560#if(CXSC_INDEX_CHECK)
2565 {
return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2567#if(CXSC_INDEX_CHECK)
2572 {
return _mmsectassign(m1,m2); }
2574#if(CXSC_INDEX_CHECK)
2579 {
return _mmssectassign(m1,ms); }
2581#if(CXSC_INDEX_CHECK)
2586 {
return _msmsectassign(*
this,m1); }
2588#if(CXSC_INDEX_CHECK)
2593 {
return _msmssectassign(*
this,ms2); }
2596#if(CXSC_INDEX_CHECK)
2601 {
return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2603#if(CXSC_INDEX_CHECK)
2608 {
return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2610#if(CXSC_INDEX_CHECK)
2615 {
return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2617#if(CXSC_INDEX_CHECK)
2622 {
return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2624#if(CXSC_INDEX_CHECK)
2629 {
return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2631#if(CXSC_INDEX_CHECK)
2636 {
return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2638#if(CXSC_INDEX_CHECK)
2643 {
return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2645#if(CXSC_INDEX_CHECK)
2650 {
return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2652#if(CXSC_INDEX_CHECK)
2657 {
return _mmplusassign(m1,m2); }
2659#if(CXSC_INDEX_CHECK)
2664 {
return _mmsplusassign(m1,ms); }
2666#if(CXSC_INDEX_CHECK)
2671 {
return _msmplusassign(*
this,m1); }
2673#if(CXSC_INDEX_CHECK)
2678 {
return _msmsplusassign(*
this,ms2); }
2680#if(CXSC_INDEX_CHECK)
2685 {
return _mmminus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2687#if(CXSC_INDEX_CHECK)
2692 {
return _mmminus<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
2694#if(CXSC_INDEX_CHECK)
2699 {
return _mmsminus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2701#if(CXSC_INDEX_CHECK)
2706 {
return _mmsminus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2708#if(CXSC_INDEX_CHECK)
2713 {
return _msmminus<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
2715#if(CXSC_INDEX_CHECK)
2720 {
return _msmminus<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
2722#if(CXSC_INDEX_CHECK)
2727 {
return _msmsminus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2729#if(CXSC_INDEX_CHECK)
2734 {
return _msmsminus<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
2736#if(CXSC_INDEX_CHECK)
2741 {
return _mmminusassign(m1,m2); }
2743#if(CXSC_INDEX_CHECK)
2748 {
return _mmsminusassign(m1,ms); }
2750#if(CXSC_INDEX_CHECK)
2755 {
return _msmminusassign(*
this,m1); }
2757#if(CXSC_INDEX_CHECK)
2762 {
return _msmsminusassign(*
this,ms2); }
2764#if(CXSC_INDEX_CHECK)
2769 {
return _mmlimult<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2771#if(CXSC_INDEX_CHECK)
2776 {
return _mmlimult<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
2778#if(CXSC_INDEX_CHECK)
2783 {
return _mmslimult<l_rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2785#if(CXSC_INDEX_CHECK)
2790 {
return _mmslimult<l_imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
2792#if(CXSC_INDEX_CHECK)
2797 {
return _msmlimult<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2799#if(CXSC_INDEX_CHECK)
2804 {
return _msmlimult<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
2806#if(CXSC_INDEX_CHECK)
2811 {
return _msmslimult<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2813#if(CXSC_INDEX_CHECK)
2818 {
return _msmslimult<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
2820#if(CXSC_INDEX_CHECK)
2825 {
return _mmlimultassign<l_imatrix,l_rmatrix,l_interval>(m1,m2); }
2827#if(CXSC_INDEX_CHECK)
2832 {
return _mmslimultassign<l_imatrix,l_rmatrix_slice,l_interval>(m1,ms); }
2834#if(CXSC_INDEX_CHECK)
2839 {
return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2841#if(CXSC_INDEX_CHECK)
2846 {
return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2848#if(CXSC_INDEX_CHECK)
2853 {
return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2855#if(CXSC_INDEX_CHECK)
2860 {
return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2862#if(CXSC_INDEX_CHECK)
2867 {
return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2869#if(CXSC_INDEX_CHECK)
2874 {
return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2876#if(CXSC_INDEX_CHECK)
2881 {
return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2883#if(CXSC_INDEX_CHECK)
2888 {
return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2890#if(CXSC_INDEX_CHECK)
2895 {
return _mmconvassign(m1,m2); }
2897#if(CXSC_INDEX_CHECK)
2902 {
return _mmsconvassign(m1,ms); }
2904#if(CXSC_INDEX_CHECK)
2909 {
return _msmconvassign(*
this,m1); }
2911#if(CXSC_INDEX_CHECK)
2916 {
return _msmsconvassign(*
this,ms2); }
2918#if(CXSC_INDEX_CHECK)
2923 {
return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2925#if(CXSC_INDEX_CHECK)
2930 {
return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2932#if(CXSC_INDEX_CHECK)
2937 {
return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2939#if(CXSC_INDEX_CHECK)
2944 {
return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2946#if(CXSC_INDEX_CHECK)
2951 {
return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2953#if(CXSC_INDEX_CHECK)
2958 {
return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2960#if(CXSC_INDEX_CHECK)
2965 {
return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2967#if(CXSC_INDEX_CHECK)
2972 {
return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2974#if(CXSC_INDEX_CHECK)
2979 {
return _mmsectassign(m1,m2); }
2981#if(CXSC_INDEX_CHECK)
2986 {
return _mmssectassign(m1,ms); }
2988#if(CXSC_INDEX_CHECK)
2993 {
return _msmsectassign(*
this,m1); }
2995#if(CXSC_INDEX_CHECK)
3000 {
return _msmssectassign(*
this,ms2); }
3003#if(CXSC_INDEX_CHECK)
3008 {
return _mmplus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3010#if(CXSC_INDEX_CHECK)
3015 {
return _mmplus<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3017#if(CXSC_INDEX_CHECK)
3022 {
return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3024#if(CXSC_INDEX_CHECK)
3029 {
return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3031#if(CXSC_INDEX_CHECK)
3036 {
return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3038#if(CXSC_INDEX_CHECK)
3043 {
return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3045#if(CXSC_INDEX_CHECK)
3050 {
return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3052#if(CXSC_INDEX_CHECK)
3057 {
return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3059#if(CXSC_INDEX_CHECK)
3064 {
return _mmplusassign(m1,m2); }
3066#if(CXSC_INDEX_CHECK)
3071 {
return _mmsplusassign(m1,ms); }
3073#if(CXSC_INDEX_CHECK)
3078 {
return _msmplusassign(*
this,m1); }
3080#if(CXSC_INDEX_CHECK)
3085 {
return _msmsplusassign(*
this,ms2); }
3087#if(CXSC_INDEX_CHECK)
3092 {
return _mmminus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3094#if(CXSC_INDEX_CHECK)
3099 {
return _mmminus<l_imatrix,imatrix,l_imatrix>(m1,m2); }
3101#if(CXSC_INDEX_CHECK)
3106 {
return _mmsminus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3108#if(CXSC_INDEX_CHECK)
3113 {
return _mmsminus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3115#if(CXSC_INDEX_CHECK)
3120 {
return _msmminus<imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
3122#if(CXSC_INDEX_CHECK)
3127 {
return _msmminus<l_imatrix_slice,imatrix,l_imatrix>(ms,m); }
3129#if(CXSC_INDEX_CHECK)
3134 {
return _msmsminus<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
3136#if(CXSC_INDEX_CHECK)
3141 {
return _msmsminus<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3143#if(CXSC_INDEX_CHECK)
3148 {
return _mmminusassign(m1,m2); }
3150#if(CXSC_INDEX_CHECK)
3155 {
return _mmsminusassign(m1,ms); }
3157#if(CXSC_INDEX_CHECK)
3162 {
return _msmminusassign(*
this,m1); }
3164#if(CXSC_INDEX_CHECK)
3169 {
return _msmsminusassign(*
this,ms2); }
3171#if(CXSC_INDEX_CHECK)
3176 {
return _mmlimult<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3178#if(CXSC_INDEX_CHECK)
3183 {
return _mmlimult<l_imatrix,imatrix,l_imatrix>(m1,m2); }
3185#if(CXSC_INDEX_CHECK)
3190 {
return _mmslimult<imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
3192#if(CXSC_INDEX_CHECK)
3197 {
return _mmslimult<l_imatrix,imatrix_slice,l_imatrix>(m1,ms); }
3199#if(CXSC_INDEX_CHECK)
3204 {
return _msmlimult<imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
3206#if(CXSC_INDEX_CHECK)
3211 {
return _msmlimult<l_imatrix_slice,imatrix,l_imatrix>(ms,m1); }
3213#if(CXSC_INDEX_CHECK)
3218 {
return _msmslimult<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
3220#if(CXSC_INDEX_CHECK)
3225 {
return _msmslimult<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3227#if(CXSC_INDEX_CHECK)
3232 {
return _mmlimultassign<l_imatrix,imatrix,l_interval>(m1,m2); }
3234#if(CXSC_INDEX_CHECK)
3239 {
return _mmslimultassign<l_imatrix,imatrix_slice,l_interval>(m1,ms); }
3241#if(CXSC_INDEX_CHECK)
3246 {
return _mmconv<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3248#if(CXSC_INDEX_CHECK)
3253 {
return _mmconv<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3255#if(CXSC_INDEX_CHECK)
3260 {
return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3262#if(CXSC_INDEX_CHECK)
3267 {
return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3269#if(CXSC_INDEX_CHECK)
3274 {
return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3276#if(CXSC_INDEX_CHECK)
3281 {
return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3283#if(CXSC_INDEX_CHECK)
3288 {
return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3290#if(CXSC_INDEX_CHECK)
3295 {
return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3297#if(CXSC_INDEX_CHECK)
3302 {
return _mmconvassign(m1,m2); }
3304#if(CXSC_INDEX_CHECK)
3309 {
return _mmsconvassign(m1,ms); }
3311#if(CXSC_INDEX_CHECK)
3316 {
return _msmconvassign(*
this,m1); }
3318#if(CXSC_INDEX_CHECK)
3323 {
return _msmsconvassign(*
this,ms2); }
3325#if(CXSC_INDEX_CHECK)
3330 {
return _mmsect<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3332#if(CXSC_INDEX_CHECK)
3337 {
return _mmsect<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3339#if(CXSC_INDEX_CHECK)
3344 {
return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3346#if(CXSC_INDEX_CHECK)
3351 {
return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3353#if(CXSC_INDEX_CHECK)
3358 {
return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3360#if(CXSC_INDEX_CHECK)
3365 {
return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3367#if(CXSC_INDEX_CHECK)
3372 {
return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3374#if(CXSC_INDEX_CHECK)
3379 {
return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3381#if(CXSC_INDEX_CHECK)
3386 {
return _mmsectassign(m1,m2); }
3388#if(CXSC_INDEX_CHECK)
3393 {
return _mmssectassign(m1,ms); }
3395#if(CXSC_INDEX_CHECK)
3400 {
return _msmsectassign(*
this,m1); }
3402#if(CXSC_INDEX_CHECK)
3407 {
return _msmssectassign(*
this,ms2); }
3410#if(CXSC_INDEX_CHECK)
3415 {
return _mmplus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3417#if(CXSC_INDEX_CHECK)
3422 {
return _mmplus<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3424#if(CXSC_INDEX_CHECK)
3429 {
return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3431#if(CXSC_INDEX_CHECK)
3436 {
return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3438#if(CXSC_INDEX_CHECK)
3443 {
return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3445#if(CXSC_INDEX_CHECK)
3450 {
return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3452#if(CXSC_INDEX_CHECK)
3457 {
return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3459#if(CXSC_INDEX_CHECK)
3464 {
return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3466#if(CXSC_INDEX_CHECK)
3471 {
return _mmminus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3473#if(CXSC_INDEX_CHECK)
3478 {
return _mmminus<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
3480#if(CXSC_INDEX_CHECK)
3485 {
return _mmsminus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3487#if(CXSC_INDEX_CHECK)
3492 {
return _mmsminus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3494#if(CXSC_INDEX_CHECK)
3499 {
return _msmminus<l_rmatrix_slice,imatrix,l_imatrix>(ms,m); }
3501#if(CXSC_INDEX_CHECK)
3506 {
return _msmminus<imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
3508#if(CXSC_INDEX_CHECK)
3513 {
return _msmsminus<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3515#if(CXSC_INDEX_CHECK)
3520 {
return _msmsminus<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
3522#if(CXSC_INDEX_CHECK)
3527 {
return _mmlimult<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3529#if(CXSC_INDEX_CHECK)
3534 {
return _mmlimult<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
3536#if(CXSC_INDEX_CHECK)
3541 {
return _mmslimult<l_rmatrix,imatrix_slice,l_imatrix>(m1,ms); }
3543#if(CXSC_INDEX_CHECK)
3548 {
return _mmslimult<imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
3550#if(CXSC_INDEX_CHECK)
3555 {
return _msmlimult<l_rmatrix_slice,imatrix,l_imatrix>(ms,m1); }
3557#if(CXSC_INDEX_CHECK)
3562 {
return _msmlimult<imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
3564#if(CXSC_INDEX_CHECK)
3569 {
return _msmslimult<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3571#if(CXSC_INDEX_CHECK)
3576 {
return _msmslimult<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
3578#if(CXSC_INDEX_CHECK)
3583 {
return _mmconv<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3585#if(CXSC_INDEX_CHECK)
3590 {
return _mmconv<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3592#if(CXSC_INDEX_CHECK)
3597 {
return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3599#if(CXSC_INDEX_CHECK)
3604 {
return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3606#if(CXSC_INDEX_CHECK)
3611 {
return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3613#if(CXSC_INDEX_CHECK)
3618 {
return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3620#if(CXSC_INDEX_CHECK)
3625 {
return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3627#if(CXSC_INDEX_CHECK)
3632 {
return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3634#if(CXSC_INDEX_CHECK)
3639 {
return _mmsect<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3641#if(CXSC_INDEX_CHECK)
3646 {
return _mmsect<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3648#if(CXSC_INDEX_CHECK)
3653 {
return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3655#if(CXSC_INDEX_CHECK)
3660 {
return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3662#if(CXSC_INDEX_CHECK)
3667 {
return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3669#if(CXSC_INDEX_CHECK)
3674 {
return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3676#if(CXSC_INDEX_CHECK)
3681 {
return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3683#if(CXSC_INDEX_CHECK)
3688 {
return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3692#if(CXSC_INDEX_CHECK)
3697 {
return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
3699#if(CXSC_INDEX_CHECK)
3704 {
return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv2,rv1); }
3706#if(CXSC_INDEX_CHECK)
3711 {
return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
3713#if(CXSC_INDEX_CHECK)
3718 {
return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
3720#if(CXSC_INDEX_CHECK)
3725 {
return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3727#if(CXSC_INDEX_CHECK)
3732 {
return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3734#if(CXSC_INDEX_CHECK)
3739 {
return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl2,sl1); }
3741#if(CXSC_INDEX_CHECK)
3746 {
return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
3750#if(CXSC_INDEX_CHECK)
3755 {
return _mmconv<l_rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
3757#if(CXSC_INDEX_CHECK)
3762 {
return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3764#if(CXSC_INDEX_CHECK)
3769 {
return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3771#if(CXSC_INDEX_CHECK)
3776 {
return _msmsconv<l_rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
3796 INLINE
bool operator !(
const l_imatrix &ms)
noexcept {
return _mnot(ms); }
3798 INLINE std::ostream &operator <<(std::ostream &s,
const l_imatrix &r)
noexcept {
return _mout(s,r); }
3799 INLINE std::ostream &operator <<(std::ostream &s,
const l_imatrix_slice &r)
noexcept {
return _msout(s,r); }
3800 INLINE std::istream &operator >>(std::istream &s,
l_imatrix &r)
noexcept {
return _min(s,r); }
3801 INLINE std::istream &operator >>(std::istream &s,
l_imatrix_slice &r)
noexcept {
return _msin(s,r); }
The Data Type idotprecision.
The Data Type imatrix_slice.
The Data Type imatrix_subv.
The Scalar Type interval.
The Data Type ivector_slice.
The Multiple-Precision Data Type l_imatrix_slice.
l_imatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
l_imatrix_slice & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
l_imatrix_slice & operator=(const l_imatrix &m) noexcept
Implementation of standard assigning operator.
l_imatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
l_imatrix_slice & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
l_imatrix_slice & operator&=(const l_imatrix &m1) noexcept
Allocates the intersection of the arguments to the first argument.
l_imatrix_slice & operator|=(const l_imatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
l_imatrix_slice & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
l_imatrix_slice & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
The Multiple-Precision Data Type l_imatrix_subv.
l_imatrix_subv & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
l_imatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
l_imatrix_subv & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
l_imatrix_subv & operator=(const l_imatrix_subv &rv) noexcept
Implementation of standard assigning operator.
l_imatrix_subv & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
l_imatrix_subv & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
l_imatrix_subv & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
l_imatrix_subv & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
The Multiple-Precision Data Type l_imatrix.
l_imatrix & operator=(const l_interval &r) noexcept
Implementation of standard assigning operator.
l_imatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
l_imatrix() noexcept
Constructor of class l_imatrix.
l_imatrix & operator()() noexcept
Operator for accessing the whole matrix.
The Multiple-Precision Data Type l_interval.
l_interval() noexcept
Constructor of class l_interval.
The Multiple-Precision Data Type l_ivector_slice.
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
The Multiple-Precision Data Type l_ivector.
l_ivector() noexcept
Constructor of class l_ivector.
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_real.
The Multiple-Precision Data Type l_rmatrix_slice.
The Multiple-Precision Data Type l_rmatrix_subv.
The Multiple-Precision Data Type l_rmatrix.
The Multiple-Precision Data Type l_rvector_slice.
The Multiple-Precision Data Type l_rvector.
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.