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 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
91 throw():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)"));
101 #if(CXSC_INDEX_CHECK) 102 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
104 throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
107 #if(CXSC_INDEX_CHECK) 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)
121 #if(CXSC_INDEX_CHECK) 122 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
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++)
186 #if(CXSC_INDEX_CHECK) 187 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
192 #if(CXSC_INDEX_CHECK) 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];
253 #if(CXSC_INDEX_CHECK) 254 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
264 #if(CXSC_INDEX_CHECK) 265 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
275 #if(CXSC_INDEX_CHECK) 276 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
286 #if(CXSC_INDEX_CHECK) 287 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
297 #if(CXSC_INDEX_CHECK) 298 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
303 #if(CXSC_INDEX_CHECK) 304 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"l_imatrix_subv l_imatrix::operator [](const int &i)"));
310 #if(CXSC_INDEX_CHECK) 311 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
316 #if(CXSC_INDEX_CHECK) 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)"));
323 #if(CXSC_INDEX_CHECK) 324 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
329 #if(CXSC_INDEX_CHECK) 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)"));
336 #if(CXSC_INDEX_CHECK) 337 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
342 #if(CXSC_INDEX_CHECK) 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)"));
349 #if(CXSC_INDEX_CHECK) 350 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
355 #if(CXSC_INDEX_CHECK) 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);
362 #if(CXSC_INDEX_CHECK) 363 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
368 #if(CXSC_INDEX_CHECK) 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);
375 #if(CXSC_INDEX_CHECK) 376 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
381 #if(CXSC_INDEX_CHECK) 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)"));
388 #if(CXSC_INDEX_CHECK) 389 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
394 #if(CXSC_INDEX_CHECK) 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)"));
401 #if(CXSC_INDEX_CHECK) 402 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
407 #if(CXSC_INDEX_CHECK) 408 if(1<lb||i>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_imatrix_subv l_imatrix_subv::operator ()(const int &i)"));
414 #if(CXSC_INDEX_CHECK) 415 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
420 #if(CXSC_INDEX_CHECK) 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);
431 #if(CXSC_INDEX_CHECK) 432 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
436 {
return _mvvassign(*
this,v); }
438 #if(CXSC_INDEX_CHECK) 439 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
443 {
return _mvvassign(*
this,
l_ivector(v)); }
448 #if(CXSC_INDEX_CHECK) 449 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
453 {
return _mvvassign(*
this,v); }
455 #if(CXSC_INDEX_CHECK) 456 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
460 {
return _mvvassign(*
this,
l_ivector(v)); }
465 #if(CXSC_INDEX_CHECK) 466 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
470 {
return _mvvassign(*
this,v); }
472 #if(CXSC_INDEX_CHECK) 473 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
477 {
return _mvvassign(*
this,
l_ivector(v)); }
482 #if(CXSC_INDEX_CHECK) 483 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
487 {
return _mvvassign(*
this,v); }
489 #if(CXSC_INDEX_CHECK) 490 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
494 {
return _mvvassign(*
this,
l_ivector(v)); }
520 INLINE l_imatrix::operator
void*()
throw() {
return _mvoid(*
this); }
523 #if(CXSC_INDEX_CHECK) 524 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
528 {
return _msmassign(*
this,m); }
530 #if(CXSC_INDEX_CHECK) 531 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
535 {
return _msmsassign(*
this,ms); }
538 #if(CXSC_INDEX_CHECK) 539 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
543 {
return _msmassign(*
this,
l_imatrix(v)); }
545 #if(CXSC_INDEX_CHECK) 546 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
552 #if(CXSC_INDEX_CHECK) 553 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
560 #if(CXSC_INDEX_CHECK) 561 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
565 {
return _msmassign(*
this,m); }
567 #if(CXSC_INDEX_CHECK) 568 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
572 {
return _msmsassign(*
this,ms); }
575 #if(CXSC_INDEX_CHECK) 576 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
580 {
return _msmassign(*
this,
l_imatrix(v)); }
582 #if(CXSC_INDEX_CHECK) 583 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
589 #if(CXSC_INDEX_CHECK) 590 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
597 #if(CXSC_INDEX_CHECK) 598 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
602 {
return _msmassign(*
this,m); }
604 #if(CXSC_INDEX_CHECK) 605 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
609 {
return _msmsassign(*
this,ms); }
612 #if(CXSC_INDEX_CHECK) 613 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
617 {
return _msmassign(*
this,
l_imatrix(v)); }
619 #if(CXSC_INDEX_CHECK) 620 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
626 #if(CXSC_INDEX_CHECK) 627 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
634 #if(CXSC_INDEX_CHECK) 635 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
639 {
return _msmassign(*
this,m); }
641 #if(CXSC_INDEX_CHECK) 642 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
646 {
return _msmsassign(*
this,ms); }
649 #if(CXSC_INDEX_CHECK) 650 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
654 {
return _msmassign(*
this,
l_imatrix(v)); }
656 #if(CXSC_INDEX_CHECK) 657 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
663 #if(CXSC_INDEX_CHECK) 664 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
670 INLINE l_imatrix_slice::operator
void*()
throw() {
return _msvoid(*
this); }
685 #if(CXSC_INDEX_CHECK) 686 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
690 {
return _mvvsetinf(iv,rv); }
692 #if(CXSC_INDEX_CHECK) 693 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
697 {
return _mvvsetsup(iv,rv); }
699 #if(CXSC_INDEX_CHECK) 700 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
704 {
return _mvvusetinf(iv,rv); }
706 #if(CXSC_INDEX_CHECK) 707 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
711 {
return _mvvusetsup(iv,rv); }
720 #if(CXSC_INDEX_CHECK) 721 throw(OP_WITH_WRONG_DIM)
725 { _mvmvaccu(dp,rv1,rv2); }
727 #if(CXSC_INDEX_CHECK) 728 throw(OP_WITH_WRONG_DIM)
732 { _vmvaccu(dp,rv1,rv2); }
734 #if(CXSC_INDEX_CHECK) 735 throw(OP_WITH_WRONG_DIM)
739 { _vmvaccu(dp,rv2,rv1); }
741 #if(CXSC_INDEX_CHECK) 742 throw(OP_WITH_WRONG_DIM)
748 #if(CXSC_INDEX_CHECK) 749 throw(OP_WITH_WRONG_DIM)
756 #if(CXSC_INDEX_CHECK) 757 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
761 {
return _mvmvlimult<l_imatrix_subv,l_imatrix_subv,l_interval>(rv1,rv2); }
763 #if(CXSC_INDEX_CHECK) 764 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
768 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv1,rv2); }
770 #if(CXSC_INDEX_CHECK) 771 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
775 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv2,rv1); }
777 #if(CXSC_INDEX_CHECK) 778 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
782 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(
l_ivector(sl),sv); }
784 #if(CXSC_INDEX_CHECK) 785 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
789 {
return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(
l_ivector(vs),mv); }
791 #if(CXSC_INDEX_CHECK) 792 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
796 {
return _mvmvplus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
798 #if(CXSC_INDEX_CHECK) 799 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
803 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
805 #if(CXSC_INDEX_CHECK) 806 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
810 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
812 #if(CXSC_INDEX_CHECK) 813 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
817 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,
l_ivector(sl)); }
819 #if(CXSC_INDEX_CHECK) 820 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
824 {
return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,
l_ivector(sl)); }
826 #if(CXSC_INDEX_CHECK) 827 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
831 {
return _mvvplusassign(*
this,rv); }
833 #if(CXSC_INDEX_CHECK) 834 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
838 {
return _mvvplusassign(*
this,
l_ivector(rv)); }
840 #if(CXSC_INDEX_CHECK) 841 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
845 {
return _mvmvminus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
847 #if(CXSC_INDEX_CHECK) 848 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
852 {
return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(rv1,rv2); }
854 #if(CXSC_INDEX_CHECK) 855 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
859 {
return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
861 #if(CXSC_INDEX_CHECK) 862 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
866 {
return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(
l_ivector(sl),mv); }
868 #if(CXSC_INDEX_CHECK) 869 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
873 {
return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(mv,
l_ivector(sl)); }
875 #if(CXSC_INDEX_CHECK) 876 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
880 {
return _mvvminusassign(*
this,rv); }
882 #if(CXSC_INDEX_CHECK) 883 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
887 {
return _mvvminusassign(*
this,
l_ivector(rv)); }
889 #if(CXSC_INDEX_CHECK) 890 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
896 #if(CXSC_INDEX_CHECK) 897 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
903 #if(CXSC_INDEX_CHECK) 904 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
910 #if(CXSC_INDEX_CHECK) 911 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
917 #if(CXSC_INDEX_CHECK) 918 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
922 {
return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
924 #if(CXSC_INDEX_CHECK) 925 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
929 {
return _mvvconvassign(*
this,rv); }
931 #if(CXSC_INDEX_CHECK) 932 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
936 {
return _mvvconvassign(*
this,
l_ivector(rv)); }
938 #if(CXSC_INDEX_CHECK) 939 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
945 #if(CXSC_INDEX_CHECK) 946 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
952 #if(CXSC_INDEX_CHECK) 953 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
959 #if(CXSC_INDEX_CHECK) 960 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
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)
966 #if(CXSC_INDEX_CHECK) 967 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
971 {
return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
973 #if(CXSC_INDEX_CHECK) 974 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
978 {
return _mvvsectassign(*
this,rv); }
980 #if(CXSC_INDEX_CHECK) 981 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
985 {
return _mvvsectassign(*
this,l_ivector(rv)); }
989 #if(CXSC_INDEX_CHECK) 990 throw(OP_WITH_WRONG_DIM)
994 { _mvmvaccu(dp,rv2,rv1); }
996 #if(CXSC_INDEX_CHECK) 997 throw(OP_WITH_WRONG_DIM)
1001 { _vmvaccu(dp,
rvector(sl2),rv1); }
1003 #if(CXSC_INDEX_CHECK) 1004 throw(OP_WITH_WRONG_DIM)
1008 { _vmvaccu(dp,rv2,rv1); }
1010 #if(CXSC_INDEX_CHECK) 1011 throw(OP_WITH_WRONG_DIM)
1015 { _mvmvaccu(dp,rv1,rv2); }
1017 #if(CXSC_INDEX_CHECK) 1018 throw(OP_WITH_WRONG_DIM)
1022 { _vmvaccu(dp,
rvector(sl1),rv2); }
1024 #if(CXSC_INDEX_CHECK) 1025 throw(OP_WITH_WRONG_DIM)
1029 { _vmvaccu(dp,rv1,rv2); }
1032 #if(CXSC_INDEX_CHECK) 1033 throw(OP_WITH_WRONG_DIM)
1037 { _mvmvaccu(dp,rv2,rv1); }
1039 #if(CXSC_INDEX_CHECK) 1040 throw(OP_WITH_WRONG_DIM)
1046 #if(CXSC_INDEX_CHECK) 1047 throw(OP_WITH_WRONG_DIM)
1051 { _vmvaccu(dp,rv2,rv1); }
1053 #if(CXSC_INDEX_CHECK) 1054 throw(OP_WITH_WRONG_DIM)
1058 { _mvmvaccu(dp,rv1,rv2); }
1060 #if(CXSC_INDEX_CHECK) 1061 throw(OP_WITH_WRONG_DIM)
1067 #if(CXSC_INDEX_CHECK) 1068 throw(OP_WITH_WRONG_DIM)
1072 { _vmvaccu(dp,rv1,rv2); }
1075 #if(CXSC_INDEX_CHECK) 1076 throw(OP_WITH_WRONG_DIM)
1080 { _mvmvaccu(dp,rv2,rv1); }
1082 #if(CXSC_INDEX_CHECK) 1083 throw(OP_WITH_WRONG_DIM)
1087 { _vmvaccu(dp,
ivector(sl2),rv1); }
1089 #if(CXSC_INDEX_CHECK) 1090 throw(OP_WITH_WRONG_DIM)
1094 { _vmvaccu(dp,rv2,rv1); }
1096 #if(CXSC_INDEX_CHECK) 1097 throw(OP_WITH_WRONG_DIM)
1101 { _mvmvaccu(dp,rv1,rv2); }
1103 #if(CXSC_INDEX_CHECK) 1104 throw(OP_WITH_WRONG_DIM)
1108 { _vmvaccu(dp,
ivector(sl1),rv2); }
1110 #if(CXSC_INDEX_CHECK) 1111 throw(OP_WITH_WRONG_DIM)
1115 { _vmvaccu(dp,rv1,rv2); }
1145 #if(CXSC_INDEX_CHECK) 1146 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1150 {
return _mlb(rm,i); }
1152 #if(CXSC_INDEX_CHECK) 1153 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1157 {
return _mub(rm,i); }
1159 #if(CXSC_INDEX_CHECK) 1160 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1164 {
return _mslb(rm,i); }
1166 #if(CXSC_INDEX_CHECK) 1167 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1171 {
return _msub(rm,i); }
1173 #if(CXSC_INDEX_CHECK) 1174 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
1178 {
return _msetlb(m,i,j); }
1180 #if(CXSC_INDEX_CHECK) 1181 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
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) 1203 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES)
1207 { _mresize<l_imatrix,l_interval>(A,m,n); }
1209 #if(CXSC_INDEX_CHECK) 1210 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES)
1214 { _mresize<l_imatrix,l_interval>(A,m1,m2,n1,n2); }
1226 #if(CXSC_INDEX_CHECK) 1227 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1231 {
return _mmsetinf<l_imatrix,l_rmatrix>(cm,rm); }
1233 #if(CXSC_INDEX_CHECK) 1234 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1238 {
return _msmsetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
1240 #if(CXSC_INDEX_CHECK) 1241 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1245 {
return _mmssetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
1247 #if(CXSC_INDEX_CHECK) 1248 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1252 {
return _msmssetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1254 #if(CXSC_INDEX_CHECK) 1255 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1259 {
return _mmsetsup<l_imatrix,l_rmatrix>(cm,rm); }
1261 #if(CXSC_INDEX_CHECK) 1262 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1266 {
return _msmsetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
1268 #if(CXSC_INDEX_CHECK) 1269 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1273 {
return _mmssetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
1275 #if(CXSC_INDEX_CHECK) 1276 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1280 {
return _msmssetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1282 #if(CXSC_INDEX_CHECK) 1283 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1287 {
return _mmusetinf<l_imatrix,l_rmatrix>(cm,rm); }
1289 #if(CXSC_INDEX_CHECK) 1290 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1294 {
return _msmusetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
1296 #if(CXSC_INDEX_CHECK) 1297 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1301 {
return _mmsusetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
1303 #if(CXSC_INDEX_CHECK) 1304 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1308 {
return _msmsusetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1310 #if(CXSC_INDEX_CHECK) 1311 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1315 {
return _mmusetsup<l_imatrix,l_rmatrix>(cm,rm); }
1317 #if(CXSC_INDEX_CHECK) 1318 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1322 {
return _msmusetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
1324 #if(CXSC_INDEX_CHECK) 1325 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1329 {
return _mmsusetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
1331 #if(CXSC_INDEX_CHECK) 1332 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1336 {
return _msmsusetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
1338 #if(CXSC_INDEX_CHECK) 1339 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ)
1343 { _smconstr(*
this,m); }
1351 #if(CXSC_INDEX_CHECK) 1352 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1356 {
return _mvvplusassign(*
this,rv); }
1358 #if(CXSC_INDEX_CHECK) 1359 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1363 {
return _mvvplusassign(*
this,
rvector(rv)); }
1365 #if(CXSC_INDEX_CHECK) 1366 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1370 {
return _mvvminusassign(*
this,rv); }
1372 #if(CXSC_INDEX_CHECK) 1373 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1377 {
return _mvvminusassign(*
this,
rvector(rv)); }
1379 #if(CXSC_INDEX_CHECK) 1380 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1384 {
return _mvvconvassign(*
this,rv); }
1386 #if(CXSC_INDEX_CHECK) 1387 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1391 {
return _mvvconvassign(*
this,
rvector(rv)); }
1393 #if(CXSC_INDEX_CHECK) 1394 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1398 {
return _mvvsectassign(*
this,rv); }
1400 #if(CXSC_INDEX_CHECK) 1401 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1405 {
return _mvvsectassign(*
this,rvector(rv)); }
1412 #if(CXSC_INDEX_CHECK) 1413 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1417 {
return _mvvplusassign(*
this,rv); }
1419 #if(CXSC_INDEX_CHECK) 1420 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1424 {
return _mvvplusassign(*
this,
l_rvector(rv)); }
1426 #if(CXSC_INDEX_CHECK) 1427 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1431 {
return _mvvminusassign(*
this,rv); }
1433 #if(CXSC_INDEX_CHECK) 1434 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1438 {
return _mvvminusassign(*
this,
l_rvector(rv)); }
1440 #if(CXSC_INDEX_CHECK) 1441 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1445 {
return _mvvconvassign(*
this,rv); }
1447 #if(CXSC_INDEX_CHECK) 1448 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1452 {
return _mvvconvassign(*
this,
l_rvector(rv)); }
1454 #if(CXSC_INDEX_CHECK) 1455 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1459 {
return _mvvsectassign(*
this,rv); }
1461 #if(CXSC_INDEX_CHECK) 1462 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1466 {
return _mvvsectassign(*
this,l_rvector(rv)); }
1473 #if(CXSC_INDEX_CHECK) 1474 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1478 {
return _mvvplusassign(*
this,rv); }
1480 #if(CXSC_INDEX_CHECK) 1481 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1485 {
return _mvvplusassign(*
this,
ivector(rv)); }
1487 #if(CXSC_INDEX_CHECK) 1488 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1492 {
return _mvvminusassign(*
this,rv); }
1494 #if(CXSC_INDEX_CHECK) 1495 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1499 {
return _mvvminusassign(*
this,
ivector(rv)); }
1501 #if(CXSC_INDEX_CHECK) 1502 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1506 {
return _mvvconvassign(*
this,rv); }
1508 #if(CXSC_INDEX_CHECK) 1509 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1513 {
return _mvvconvassign(*
this,
ivector(rv)); }
1515 #if(CXSC_INDEX_CHECK) 1516 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1520 {
return _mvvsectassign(*
this,rv); }
1522 #if(CXSC_INDEX_CHECK) 1523 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
1527 {
return _mvvsectassign(*
this,ivector(rv)); }
1536 #if(CXSC_INDEX_CHECK) 1537 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1541 {
return (*
this=*
this*m); }
1543 #if(CXSC_INDEX_CHECK) 1544 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1548 {
return (*
this=*
this*m); }
1561 #if(CXSC_INDEX_CHECK) 1562 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1566 {
return (*
this=*
this*m); }
1568 #if(CXSC_INDEX_CHECK) 1569 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1573 {
return (*
this=*
this*m); }
1586 #if(CXSC_INDEX_CHECK) 1587 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1591 {
return (*
this=*
this*m); }
1593 #if(CXSC_INDEX_CHECK) 1594 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1598 {
return (*
this=*
this*m); }
1611 #if(CXSC_INDEX_CHECK) 1612 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1616 {
return (*
this=*
this*m); }
1618 #if(CXSC_INDEX_CHECK) 1619 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1623 {
return (*
this=*
this*m); }
1655 #if(CXSC_INDEX_CHECK) 1656 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1660 { _vmconstr<l_ivector,l_imatrix,l_interval>(*
this,sl); }
1662 #if(CXSC_INDEX_CHECK) 1663 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1667 { _vmsconstr<l_ivector,l_imatrix_slice,l_interval>(*
this,sl); }
1669 #if(CXSC_INDEX_CHECK) 1670 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1674 {
return _vmassign<l_ivector,l_imatrix,l_interval>(*
this,m); }
1676 #if(CXSC_INDEX_CHECK) 1677 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1681 {
return _vmassign<l_ivector,l_imatrix,l_interval>(*
this,
l_imatrix(m)); }
1683 #if(CXSC_INDEX_CHECK) 1684 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1690 #if(CXSC_INDEX_CHECK) 1691 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1695 {
return _mvvassign(*
this,
l_ivector(m)); }
1697 #if(CXSC_INDEX_CHECK) 1698 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1704 #if(CXSC_INDEX_CHECK) 1705 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1709 {
return _mvlimult<l_imatrix,l_ivector,l_ivector>(m,v); }
1711 #if(CXSC_INDEX_CHECK) 1712 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1716 {
return _msvlimult<l_imatrix_slice,l_ivector,l_ivector>(ms,v); }
1718 #if(CXSC_INDEX_CHECK) 1719 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1723 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(v,m); }
1725 #if(CXSC_INDEX_CHECK) 1726 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1730 {
return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(v,ms); }
1732 #if(CXSC_INDEX_CHECK) 1733 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1737 {
return _vmlimultassign<l_ivector,l_imatrix,l_interval>(v,m); }
1739 #if(CXSC_INDEX_CHECK) 1740 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1744 {
return _vmslimultassign<l_ivector,l_imatrix_slice,l_interval>(v,ms); }
1746 #if(CXSC_INDEX_CHECK) 1747 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1751 {
return _vsmlimultassign<l_ivector_slice,l_imatrix,l_interval>(*
this,m); }
1753 #if(CXSC_INDEX_CHECK) 1754 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1758 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1760 #if(CXSC_INDEX_CHECK) 1761 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1765 {
return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(
l_ivector(v),m); }
1768 #if(CXSC_INDEX_CHECK) 1769 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1773 {
return _mvvassign(*
this,
rvector(m)); }
1775 #if(CXSC_INDEX_CHECK) 1776 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1782 #if(CXSC_INDEX_CHECK) 1783 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1787 {
return _vmlimult<rvector,l_imatrix,l_ivector>(v,m); }
1789 #if(CXSC_INDEX_CHECK) 1790 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1794 {
return _vmslimult<rvector,l_imatrix_slice,l_ivector>(v,ms); }
1796 #if(CXSC_INDEX_CHECK) 1797 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1801 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1803 #if(CXSC_INDEX_CHECK) 1804 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1808 {
return _mvlimult<l_imatrix,rvector,l_ivector>(m,v); }
1810 #if(CXSC_INDEX_CHECK) 1811 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1815 {
return _msvlimult<l_imatrix_slice,rvector,l_ivector>(ms,v); }
1818 #if(CXSC_INDEX_CHECK) 1819 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1823 {
return _mvvassign(*
this,
l_rvector(m)); }
1825 #if(CXSC_INDEX_CHECK) 1826 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1832 #if(CXSC_INDEX_CHECK) 1833 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1837 {
return _vmlimult<l_rvector,l_imatrix,l_ivector>(v,m); }
1839 #if(CXSC_INDEX_CHECK) 1840 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1844 {
return _vmslimult<l_rvector,l_imatrix_slice,l_ivector>(v,ms); }
1846 #if(CXSC_INDEX_CHECK) 1847 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1851 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1853 #if(CXSC_INDEX_CHECK) 1854 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1858 {
return _mvlimult<l_imatrix,l_rvector,l_ivector>(m,v); }
1860 #if(CXSC_INDEX_CHECK) 1861 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1865 {
return _msvlimult<l_imatrix_slice,l_rvector,l_ivector>(ms,v); }
1868 #if(CXSC_INDEX_CHECK) 1869 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1873 {
return _mvvassign(*
this,
ivector(m)); }
1875 #if(CXSC_INDEX_CHECK) 1876 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1882 #if(CXSC_INDEX_CHECK) 1883 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1887 {
return _vmlimult<ivector,l_imatrix,l_ivector>(v,m); }
1889 #if(CXSC_INDEX_CHECK) 1890 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1894 {
return _vmslimult<ivector,l_imatrix_slice,l_ivector>(v,ms); }
1896 #if(CXSC_INDEX_CHECK) 1897 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1901 {
return _vmlimult<l_ivector,l_imatrix,l_ivector>(
l_ivector(v),m); }
1903 #if(CXSC_INDEX_CHECK) 1904 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1908 {
return _mvlimult<l_imatrix,ivector,l_ivector>(m,v); }
1910 #if(CXSC_INDEX_CHECK) 1911 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1915 {
return _msvlimult<l_imatrix_slice,ivector,l_ivector>(ms,v); }
1920 #if(CXSC_INDEX_CHECK) 1921 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1925 {
return _mmplus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
1927 #if(CXSC_INDEX_CHECK) 1928 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1932 {
return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1934 #if(CXSC_INDEX_CHECK) 1935 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1939 {
return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1941 #if(CXSC_INDEX_CHECK) 1942 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1946 {
return _msmsplus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
1948 #if(CXSC_INDEX_CHECK) 1949 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1953 {
return _mmplusassign(m1,m2); }
1955 #if(CXSC_INDEX_CHECK) 1956 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1960 {
return _mmsplusassign(m1,ms); }
1962 #if(CXSC_INDEX_CHECK) 1963 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1967 {
return _msmplusassign(*
this,m1); }
1969 #if(CXSC_INDEX_CHECK) 1970 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1974 {
return _msmsplusassign(*
this,ms2); }
1978 #if(CXSC_INDEX_CHECK) 1979 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1983 {
return _mmminus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
1985 #if(CXSC_INDEX_CHECK) 1986 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1990 {
return _mmsminus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
1992 #if(CXSC_INDEX_CHECK) 1993 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
1997 {
return _msmminus<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
1999 #if(CXSC_INDEX_CHECK) 2000 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2004 {
return _msmsminus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2006 #if(CXSC_INDEX_CHECK) 2007 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2011 {
return _mmminusassign(m1,m2); }
2013 #if(CXSC_INDEX_CHECK) 2014 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2018 {
return _mmsminusassign(m1,ms); }
2020 #if(CXSC_INDEX_CHECK) 2021 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2025 {
return _msmminusassign(*
this,m1); }
2027 #if(CXSC_INDEX_CHECK) 2028 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2032 {
return _msmsminusassign(*
this,ms2); }
2034 #if(CXSC_INDEX_CHECK) 2035 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2039 {
return _mmlimult<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2041 #if(CXSC_INDEX_CHECK) 2042 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2046 {
return _mmslimult<l_imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2048 #if(CXSC_INDEX_CHECK) 2049 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2053 {
return _msmlimult<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2055 #if(CXSC_INDEX_CHECK) 2056 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2060 {
return _msmslimult<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2062 #if(CXSC_INDEX_CHECK) 2063 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2067 {
return _mmlimultassign<l_imatrix,l_imatrix,l_interval>(m1,m2); }
2069 #if(CXSC_INDEX_CHECK) 2070 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2074 {
return _mmslimultassign<l_imatrix,l_imatrix_slice,l_interval>(m1,ms); }
2076 #if(CXSC_INDEX_CHECK) 2077 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2081 {
return _mmconv<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2083 #if(CXSC_INDEX_CHECK) 2084 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2088 {
return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2090 #if(CXSC_INDEX_CHECK) 2091 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2095 {
return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2097 #if(CXSC_INDEX_CHECK) 2098 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2102 {
return _msmsconv<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2104 #if(CXSC_INDEX_CHECK) 2105 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2109 {
return _mmconvassign(m1,m2); }
2111 #if(CXSC_INDEX_CHECK) 2112 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2116 {
return _mmsconvassign(m1,ms); }
2118 #if(CXSC_INDEX_CHECK) 2119 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2123 {
return _msmconvassign(*
this,m1); }
2125 #if(CXSC_INDEX_CHECK) 2126 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2130 {
return _msmsconvassign(*
this,ms2); }
2132 #if(CXSC_INDEX_CHECK) 2133 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2137 {
return _mmsect<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
2139 #if(CXSC_INDEX_CHECK) 2140 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2144 {
return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2146 #if(CXSC_INDEX_CHECK) 2147 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2151 {
return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2153 #if(CXSC_INDEX_CHECK) 2154 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2158 {
return _msmssect<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2160 #if(CXSC_INDEX_CHECK) 2161 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2165 {
return _mmsectassign(m1,m2); }
2167 #if(CXSC_INDEX_CHECK) 2168 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2172 {
return _mmssectassign(m1,ms); }
2174 #if(CXSC_INDEX_CHECK) 2175 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2179 {
return _msmsectassign(*
this,m1); }
2181 #if(CXSC_INDEX_CHECK) 2182 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2186 {
return _msmssectassign(*
this,ms2); }
2189 #if(CXSC_INDEX_CHECK) 2190 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2194 {
return _mmplus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2196 #if(CXSC_INDEX_CHECK) 2197 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2201 {
return _mmplus<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2203 #if(CXSC_INDEX_CHECK) 2204 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2208 {
return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2210 #if(CXSC_INDEX_CHECK) 2211 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2215 {
return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2217 #if(CXSC_INDEX_CHECK) 2218 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2222 {
return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2224 #if(CXSC_INDEX_CHECK) 2225 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2229 {
return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2231 #if(CXSC_INDEX_CHECK) 2232 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2236 {
return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2238 #if(CXSC_INDEX_CHECK) 2239 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2243 {
return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2245 #if(CXSC_INDEX_CHECK) 2246 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2250 {
return _mmplusassign(m1,m2); }
2252 #if(CXSC_INDEX_CHECK) 2253 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2257 {
return _mmsplusassign(m1,ms); }
2259 #if(CXSC_INDEX_CHECK) 2260 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2264 {
return _msmplusassign(*
this,m1); }
2266 #if(CXSC_INDEX_CHECK) 2267 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2271 {
return _msmsplusassign(*
this,ms2); }
2273 #if(CXSC_INDEX_CHECK) 2274 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2278 {
return _mmminus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2280 #if(CXSC_INDEX_CHECK) 2281 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2285 {
return _mmminus<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
2287 #if(CXSC_INDEX_CHECK) 2288 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2292 {
return _mmsminus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2294 #if(CXSC_INDEX_CHECK) 2295 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2299 {
return _mmsminus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2301 #if(CXSC_INDEX_CHECK) 2302 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2306 {
return _msmminus<rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
2308 #if(CXSC_INDEX_CHECK) 2309 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2313 {
return _msmminus<l_imatrix_slice,rmatrix,l_imatrix>(ms,m); }
2315 #if(CXSC_INDEX_CHECK) 2316 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2320 {
return _msmsminus<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2322 #if(CXSC_INDEX_CHECK) 2323 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2327 {
return _msmsminus<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
2329 #if(CXSC_INDEX_CHECK) 2330 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2334 {
return _mmminusassign(m1,m2); }
2336 #if(CXSC_INDEX_CHECK) 2337 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2341 {
return _mmsminusassign(m1,ms); }
2343 #if(CXSC_INDEX_CHECK) 2344 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2348 {
return _msmminusassign(*
this,m1); }
2350 #if(CXSC_INDEX_CHECK) 2351 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2355 {
return _msmsminusassign(*
this,ms2); }
2357 #if(CXSC_INDEX_CHECK) 2358 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2362 {
return _mmlimult<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2364 #if(CXSC_INDEX_CHECK) 2365 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2369 {
return _mmlimult<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
2371 #if(CXSC_INDEX_CHECK) 2372 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2376 {
return _mmslimult<rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2378 #if(CXSC_INDEX_CHECK) 2379 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2383 {
return _mmslimult<l_imatrix,rmatrix_slice,l_imatrix>(m1,ms); }
2385 #if(CXSC_INDEX_CHECK) 2386 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2390 {
return _msmlimult<rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2392 #if(CXSC_INDEX_CHECK) 2393 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2397 {
return _msmlimult<l_imatrix_slice,rmatrix,l_imatrix>(ms,m1); }
2399 #if(CXSC_INDEX_CHECK) 2400 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2404 {
return _msmslimult<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2406 #if(CXSC_INDEX_CHECK) 2407 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2411 {
return _msmslimult<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
2413 #if(CXSC_INDEX_CHECK) 2414 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2418 {
return _mmlimultassign<l_imatrix,rmatrix,l_interval>(m1,m2); }
2420 #if(CXSC_INDEX_CHECK) 2421 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2425 {
return _mmslimultassign<l_imatrix,rmatrix_slice,l_interval>(m1,ms); }
2427 #if(CXSC_INDEX_CHECK) 2428 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2432 {
return _mmconv<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2434 #if(CXSC_INDEX_CHECK) 2435 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2439 {
return _mmconv<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2441 #if(CXSC_INDEX_CHECK) 2442 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2446 {
return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2448 #if(CXSC_INDEX_CHECK) 2449 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2453 {
return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2455 #if(CXSC_INDEX_CHECK) 2456 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2460 {
return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2462 #if(CXSC_INDEX_CHECK) 2463 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2467 {
return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2469 #if(CXSC_INDEX_CHECK) 2470 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2474 {
return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2476 #if(CXSC_INDEX_CHECK) 2477 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2481 {
return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2483 #if(CXSC_INDEX_CHECK) 2484 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2488 {
return _mmconvassign(m1,m2); }
2490 #if(CXSC_INDEX_CHECK) 2491 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2495 {
return _mmsconvassign(m1,ms); }
2497 #if(CXSC_INDEX_CHECK) 2498 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2502 {
return _msmconvassign(*
this,m1); }
2504 #if(CXSC_INDEX_CHECK) 2505 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2509 {
return _msmsconvassign(*
this,ms2); }
2511 #if(CXSC_INDEX_CHECK) 2512 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2516 {
return _mmsect<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2518 #if(CXSC_INDEX_CHECK) 2519 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2523 {
return _mmsect<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2525 #if(CXSC_INDEX_CHECK) 2526 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2530 {
return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2532 #if(CXSC_INDEX_CHECK) 2533 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2537 {
return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2539 #if(CXSC_INDEX_CHECK) 2540 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2544 {
return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
2546 #if(CXSC_INDEX_CHECK) 2547 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2551 {
return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2553 #if(CXSC_INDEX_CHECK) 2554 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2558 {
return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2560 #if(CXSC_INDEX_CHECK) 2561 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2565 {
return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2567 #if(CXSC_INDEX_CHECK) 2568 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2572 {
return _mmsectassign(m1,m2); }
2574 #if(CXSC_INDEX_CHECK) 2575 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2579 {
return _mmssectassign(m1,ms); }
2581 #if(CXSC_INDEX_CHECK) 2582 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2586 {
return _msmsectassign(*
this,m1); }
2588 #if(CXSC_INDEX_CHECK) 2589 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2593 {
return _msmssectassign(*
this,ms2); }
2596 #if(CXSC_INDEX_CHECK) 2597 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2601 {
return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2603 #if(CXSC_INDEX_CHECK) 2604 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2608 {
return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2610 #if(CXSC_INDEX_CHECK) 2611 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2615 {
return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2617 #if(CXSC_INDEX_CHECK) 2618 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2622 {
return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2624 #if(CXSC_INDEX_CHECK) 2625 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2629 {
return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2631 #if(CXSC_INDEX_CHECK) 2632 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2636 {
return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2638 #if(CXSC_INDEX_CHECK) 2639 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2643 {
return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2645 #if(CXSC_INDEX_CHECK) 2646 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2650 {
return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2652 #if(CXSC_INDEX_CHECK) 2653 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2657 {
return _mmplusassign(m1,m2); }
2659 #if(CXSC_INDEX_CHECK) 2660 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2664 {
return _mmsplusassign(m1,ms); }
2666 #if(CXSC_INDEX_CHECK) 2667 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2671 {
return _msmplusassign(*
this,m1); }
2673 #if(CXSC_INDEX_CHECK) 2674 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2678 {
return _msmsplusassign(*
this,ms2); }
2680 #if(CXSC_INDEX_CHECK) 2681 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2685 {
return _mmminus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2687 #if(CXSC_INDEX_CHECK) 2688 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2692 {
return _mmminus<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
2694 #if(CXSC_INDEX_CHECK) 2695 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2699 {
return _mmsminus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2701 #if(CXSC_INDEX_CHECK) 2702 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2706 {
return _mmsminus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2708 #if(CXSC_INDEX_CHECK) 2709 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2713 {
return _msmminus<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
2715 #if(CXSC_INDEX_CHECK) 2716 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2720 {
return _msmminus<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
2722 #if(CXSC_INDEX_CHECK) 2723 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2727 {
return _msmsminus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2729 #if(CXSC_INDEX_CHECK) 2730 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2734 {
return _msmsminus<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
2736 #if(CXSC_INDEX_CHECK) 2737 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2741 {
return _mmminusassign(m1,m2); }
2743 #if(CXSC_INDEX_CHECK) 2744 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2748 {
return _mmsminusassign(m1,ms); }
2750 #if(CXSC_INDEX_CHECK) 2751 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2755 {
return _msmminusassign(*
this,m1); }
2757 #if(CXSC_INDEX_CHECK) 2758 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2762 {
return _msmsminusassign(*
this,ms2); }
2764 #if(CXSC_INDEX_CHECK) 2765 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2769 {
return _mmlimult<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2771 #if(CXSC_INDEX_CHECK) 2772 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2776 {
return _mmlimult<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
2778 #if(CXSC_INDEX_CHECK) 2779 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2783 {
return _mmslimult<l_rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
2785 #if(CXSC_INDEX_CHECK) 2786 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2790 {
return _mmslimult<l_imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
2792 #if(CXSC_INDEX_CHECK) 2793 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2797 {
return _msmlimult<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
2799 #if(CXSC_INDEX_CHECK) 2800 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2804 {
return _msmlimult<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
2806 #if(CXSC_INDEX_CHECK) 2807 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2811 {
return _msmslimult<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
2813 #if(CXSC_INDEX_CHECK) 2814 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2818 {
return _msmslimult<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
2820 #if(CXSC_INDEX_CHECK) 2821 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2825 {
return _mmlimultassign<l_imatrix,l_rmatrix,l_interval>(m1,m2); }
2827 #if(CXSC_INDEX_CHECK) 2828 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2832 {
return _mmslimultassign<l_imatrix,l_rmatrix_slice,l_interval>(m1,ms); }
2834 #if(CXSC_INDEX_CHECK) 2835 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2839 {
return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2841 #if(CXSC_INDEX_CHECK) 2842 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2846 {
return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2848 #if(CXSC_INDEX_CHECK) 2849 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2853 {
return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2855 #if(CXSC_INDEX_CHECK) 2856 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2860 {
return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2862 #if(CXSC_INDEX_CHECK) 2863 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2867 {
return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2869 #if(CXSC_INDEX_CHECK) 2870 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2874 {
return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2876 #if(CXSC_INDEX_CHECK) 2877 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2881 {
return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2883 #if(CXSC_INDEX_CHECK) 2884 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2888 {
return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2890 #if(CXSC_INDEX_CHECK) 2891 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2895 {
return _mmconvassign(m1,m2); }
2897 #if(CXSC_INDEX_CHECK) 2898 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2902 {
return _mmsconvassign(m1,ms); }
2904 #if(CXSC_INDEX_CHECK) 2905 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2909 {
return _msmconvassign(*
this,m1); }
2911 #if(CXSC_INDEX_CHECK) 2912 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2916 {
return _msmsconvassign(*
this,ms2); }
2918 #if(CXSC_INDEX_CHECK) 2919 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2923 {
return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
2925 #if(CXSC_INDEX_CHECK) 2926 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2930 {
return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
2932 #if(CXSC_INDEX_CHECK) 2933 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2937 {
return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2939 #if(CXSC_INDEX_CHECK) 2940 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2944 {
return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2946 #if(CXSC_INDEX_CHECK) 2947 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2951 {
return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
2953 #if(CXSC_INDEX_CHECK) 2954 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2958 {
return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
2960 #if(CXSC_INDEX_CHECK) 2961 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2965 {
return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
2967 #if(CXSC_INDEX_CHECK) 2968 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2972 {
return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
2974 #if(CXSC_INDEX_CHECK) 2975 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2979 {
return _mmsectassign(m1,m2); }
2981 #if(CXSC_INDEX_CHECK) 2982 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2986 {
return _mmssectassign(m1,ms); }
2988 #if(CXSC_INDEX_CHECK) 2989 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
2993 {
return _msmsectassign(*
this,m1); }
2995 #if(CXSC_INDEX_CHECK) 2996 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3000 {
return _msmssectassign(*
this,ms2); }
3003 #if(CXSC_INDEX_CHECK) 3004 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3008 {
return _mmplus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3010 #if(CXSC_INDEX_CHECK) 3011 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3015 {
return _mmplus<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3017 #if(CXSC_INDEX_CHECK) 3018 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3022 {
return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3024 #if(CXSC_INDEX_CHECK) 3025 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3029 {
return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3031 #if(CXSC_INDEX_CHECK) 3032 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3036 {
return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3038 #if(CXSC_INDEX_CHECK) 3039 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3043 {
return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3045 #if(CXSC_INDEX_CHECK) 3046 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3050 {
return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3052 #if(CXSC_INDEX_CHECK) 3053 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3057 {
return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3059 #if(CXSC_INDEX_CHECK) 3060 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3064 {
return _mmplusassign(m1,m2); }
3066 #if(CXSC_INDEX_CHECK) 3067 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3071 {
return _mmsplusassign(m1,ms); }
3073 #if(CXSC_INDEX_CHECK) 3074 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3078 {
return _msmplusassign(*
this,m1); }
3080 #if(CXSC_INDEX_CHECK) 3081 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3085 {
return _msmsplusassign(*
this,ms2); }
3087 #if(CXSC_INDEX_CHECK) 3088 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3092 {
return _mmminus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3094 #if(CXSC_INDEX_CHECK) 3095 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3099 {
return _mmminus<l_imatrix,imatrix,l_imatrix>(m1,m2); }
3101 #if(CXSC_INDEX_CHECK) 3102 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3106 {
return _mmsminus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3108 #if(CXSC_INDEX_CHECK) 3109 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3113 {
return _mmsminus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3115 #if(CXSC_INDEX_CHECK) 3116 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3120 {
return _msmminus<imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
3122 #if(CXSC_INDEX_CHECK) 3123 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3127 {
return _msmminus<l_imatrix_slice,imatrix,l_imatrix>(ms,m); }
3129 #if(CXSC_INDEX_CHECK) 3130 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3134 {
return _msmsminus<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
3136 #if(CXSC_INDEX_CHECK) 3137 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3141 {
return _msmsminus<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3143 #if(CXSC_INDEX_CHECK) 3144 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3148 {
return _mmminusassign(m1,m2); }
3150 #if(CXSC_INDEX_CHECK) 3151 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3155 {
return _mmsminusassign(m1,ms); }
3157 #if(CXSC_INDEX_CHECK) 3158 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3162 {
return _msmminusassign(*
this,m1); }
3164 #if(CXSC_INDEX_CHECK) 3165 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3169 {
return _msmsminusassign(*
this,ms2); }
3171 #if(CXSC_INDEX_CHECK) 3172 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3176 {
return _mmlimult<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3178 #if(CXSC_INDEX_CHECK) 3179 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3183 {
return _mmlimult<l_imatrix,imatrix,l_imatrix>(m1,m2); }
3185 #if(CXSC_INDEX_CHECK) 3186 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3190 {
return _mmslimult<imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
3192 #if(CXSC_INDEX_CHECK) 3193 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3197 {
return _mmslimult<l_imatrix,imatrix_slice,l_imatrix>(m1,ms); }
3199 #if(CXSC_INDEX_CHECK) 3200 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3204 {
return _msmlimult<imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
3206 #if(CXSC_INDEX_CHECK) 3207 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3211 {
return _msmlimult<l_imatrix_slice,imatrix,l_imatrix>(ms,m1); }
3213 #if(CXSC_INDEX_CHECK) 3214 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3218 {
return _msmslimult<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
3220 #if(CXSC_INDEX_CHECK) 3221 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3225 {
return _msmslimult<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3227 #if(CXSC_INDEX_CHECK) 3228 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3232 {
return _mmlimultassign<l_imatrix,imatrix,l_interval>(m1,m2); }
3234 #if(CXSC_INDEX_CHECK) 3235 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3239 {
return _mmslimultassign<l_imatrix,imatrix_slice,l_interval>(m1,ms); }
3241 #if(CXSC_INDEX_CHECK) 3242 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3246 {
return _mmconv<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3248 #if(CXSC_INDEX_CHECK) 3249 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3253 {
return _mmconv<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3255 #if(CXSC_INDEX_CHECK) 3256 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3260 {
return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3262 #if(CXSC_INDEX_CHECK) 3263 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3267 {
return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3269 #if(CXSC_INDEX_CHECK) 3270 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3274 {
return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3276 #if(CXSC_INDEX_CHECK) 3277 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3281 {
return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3283 #if(CXSC_INDEX_CHECK) 3284 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3288 {
return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3290 #if(CXSC_INDEX_CHECK) 3291 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3295 {
return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3297 #if(CXSC_INDEX_CHECK) 3298 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3302 {
return _mmconvassign(m1,m2); }
3304 #if(CXSC_INDEX_CHECK) 3305 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3309 {
return _mmsconvassign(m1,ms); }
3311 #if(CXSC_INDEX_CHECK) 3312 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3316 {
return _msmconvassign(*
this,m1); }
3318 #if(CXSC_INDEX_CHECK) 3319 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3323 {
return _msmsconvassign(*
this,ms2); }
3325 #if(CXSC_INDEX_CHECK) 3326 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3330 {
return _mmsect<imatrix,l_imatrix,l_imatrix>(m1,m2); }
3332 #if(CXSC_INDEX_CHECK) 3333 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3337 {
return _mmsect<imatrix,l_imatrix,l_imatrix>(m2,m1); }
3339 #if(CXSC_INDEX_CHECK) 3340 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3344 {
return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3346 #if(CXSC_INDEX_CHECK) 3347 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3351 {
return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3353 #if(CXSC_INDEX_CHECK) 3354 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3358 {
return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
3360 #if(CXSC_INDEX_CHECK) 3361 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3365 {
return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
3367 #if(CXSC_INDEX_CHECK) 3368 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3372 {
return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
3374 #if(CXSC_INDEX_CHECK) 3375 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3379 {
return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
3381 #if(CXSC_INDEX_CHECK) 3382 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3386 {
return _mmsectassign(m1,m2); }
3388 #if(CXSC_INDEX_CHECK) 3389 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3393 {
return _mmssectassign(m1,ms); }
3395 #if(CXSC_INDEX_CHECK) 3396 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3400 {
return _msmsectassign(*
this,m1); }
3402 #if(CXSC_INDEX_CHECK) 3403 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3407 {
return _msmssectassign(*
this,ms2); }
3410 #if(CXSC_INDEX_CHECK) 3411 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3415 {
return _mmplus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3417 #if(CXSC_INDEX_CHECK) 3418 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3422 {
return _mmplus<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3424 #if(CXSC_INDEX_CHECK) 3425 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3429 {
return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3431 #if(CXSC_INDEX_CHECK) 3432 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3436 {
return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3438 #if(CXSC_INDEX_CHECK) 3439 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3443 {
return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3445 #if(CXSC_INDEX_CHECK) 3446 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3450 {
return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3452 #if(CXSC_INDEX_CHECK) 3453 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3457 {
return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3459 #if(CXSC_INDEX_CHECK) 3460 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3464 {
return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3466 #if(CXSC_INDEX_CHECK) 3467 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3471 {
return _mmminus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3473 #if(CXSC_INDEX_CHECK) 3474 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3478 {
return _mmminus<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
3480 #if(CXSC_INDEX_CHECK) 3481 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3485 {
return _mmsminus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3487 #if(CXSC_INDEX_CHECK) 3488 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3492 {
return _mmsminus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3494 #if(CXSC_INDEX_CHECK) 3495 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3499 {
return _msmminus<l_rmatrix_slice,imatrix,l_imatrix>(ms,m); }
3501 #if(CXSC_INDEX_CHECK) 3502 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3506 {
return _msmminus<imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
3508 #if(CXSC_INDEX_CHECK) 3509 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3513 {
return _msmsminus<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3515 #if(CXSC_INDEX_CHECK) 3516 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3520 {
return _msmsminus<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
3522 #if(CXSC_INDEX_CHECK) 3523 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3527 {
return _mmlimult<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3529 #if(CXSC_INDEX_CHECK) 3530 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3534 {
return _mmlimult<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
3536 #if(CXSC_INDEX_CHECK) 3537 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3541 {
return _mmslimult<l_rmatrix,imatrix_slice,l_imatrix>(m1,ms); }
3543 #if(CXSC_INDEX_CHECK) 3544 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3548 {
return _mmslimult<imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
3550 #if(CXSC_INDEX_CHECK) 3551 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3555 {
return _msmlimult<l_rmatrix_slice,imatrix,l_imatrix>(ms,m1); }
3557 #if(CXSC_INDEX_CHECK) 3558 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3562 {
return _msmlimult<imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
3564 #if(CXSC_INDEX_CHECK) 3565 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3569 {
return _msmslimult<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
3571 #if(CXSC_INDEX_CHECK) 3572 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3576 {
return _msmslimult<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
3578 #if(CXSC_INDEX_CHECK) 3579 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3583 {
return _mmconv<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3585 #if(CXSC_INDEX_CHECK) 3586 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3590 {
return _mmconv<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3592 #if(CXSC_INDEX_CHECK) 3593 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3597 {
return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3599 #if(CXSC_INDEX_CHECK) 3600 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3604 {
return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3606 #if(CXSC_INDEX_CHECK) 3607 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3611 {
return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3613 #if(CXSC_INDEX_CHECK) 3614 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3618 {
return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3620 #if(CXSC_INDEX_CHECK) 3621 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3625 {
return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3627 #if(CXSC_INDEX_CHECK) 3628 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3632 {
return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3634 #if(CXSC_INDEX_CHECK) 3635 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3639 {
return _mmsect<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
3641 #if(CXSC_INDEX_CHECK) 3642 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3646 {
return _mmsect<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
3648 #if(CXSC_INDEX_CHECK) 3649 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3653 {
return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3655 #if(CXSC_INDEX_CHECK) 3656 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3660 {
return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3662 #if(CXSC_INDEX_CHECK) 3663 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3667 {
return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
3669 #if(CXSC_INDEX_CHECK) 3670 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3674 {
return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
3676 #if(CXSC_INDEX_CHECK) 3677 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3681 {
return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
3683 #if(CXSC_INDEX_CHECK) 3684 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
3688 {
return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
3692 #if(CXSC_INDEX_CHECK) 3693 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3697 {
return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
3699 #if(CXSC_INDEX_CHECK) 3700 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3704 {
return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv2,rv1); }
3706 #if(CXSC_INDEX_CHECK) 3707 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3711 {
return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
3713 #if(CXSC_INDEX_CHECK) 3714 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3718 {
return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
3720 #if(CXSC_INDEX_CHECK) 3721 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3725 {
return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3727 #if(CXSC_INDEX_CHECK) 3728 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3732 {
return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3734 #if(CXSC_INDEX_CHECK) 3735 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3739 {
return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl2,sl1); }
3741 #if(CXSC_INDEX_CHECK) 3742 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3746 {
return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
3750 #if(CXSC_INDEX_CHECK) 3751 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3755 {
return _mmconv<l_rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
3757 #if(CXSC_INDEX_CHECK) 3758 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3762 {
return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3764 #if(CXSC_INDEX_CHECK) 3765 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3769 {
return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
3771 #if(CXSC_INDEX_CHECK) 3772 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
3776 {
return _msmsconv<l_rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
3796 INLINE
bool operator !(
const l_imatrix &ms)
throw() {
return _mnot(ms); }
3798 INLINE std::ostream &operator <<(std::ostream &s,
const l_imatrix &r)
throw() {
return _mout(s,r); }
3799 INLINE std::ostream &operator <<(std::ostream &s,
const l_imatrix_slice &r)
throw() {
return _msout(s,r); }
3800 INLINE std::istream &operator >>(std::istream &s,
l_imatrix &r)
throw() {
return _min(s,r); }
3801 INLINE std::istream &operator >>(std::istream &s,
l_imatrix_slice &r)
throw() {
return _msin(s,r); }
The Multiple-Precision Data Type l_rmatrix_slice.
The Multiple-Precision Data Type l_interval.
The Data Type rmatrix_slice.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
The Data Type imatrix_subv.
The Data Type idotprecision.
The Multiple-Precision Data Type l_real.
l_imatrix_subv & operator+=(const l_interval &c)
Implementation of addition and allocation operation.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
The Multiple-Precision Data Type l_rmatrix_subv.
l_ivector & operator=(const l_ivector &rv)
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_ivector_slice.
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
The namespace cxsc, providing all functionality of the class library C-XSC.
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
l_imatrix_subv operator[](const int &i)
Operator for accessing a single row of the matrix.
l_imatrix_subv & operator&=(const l_ivector &rv)
Allocates the intersection of the arguments to the first argument.
l_ivector_slice & operator*=(const l_interval &r)
Implementation of multiplication and allocation operation.
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
The Scalar Type interval.
l_ivector()
Constructor of class l_ivector.
l_imatrix_slice & operator*=(const l_interval &c)
Implementation of multiplication and allocation operation.
cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
The Multiple-Precision Data Type l_imatrix_slice.
l_imatrix_subv & operator()()
Operator for accessing the whole vector.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
The Multiple-Precision Data Type l_ivector.
l_imatrix_slice & operator()()
Operator for accessing the whole matrix.
l_imatrix & operator=(const l_interval &r)
Implementation of standard assigning operator.
l_imatrix()
Constructor of class l_imatrix.
The Data Type ivector_slice.
l_imatrix & operator()()
Operator for accessing the whole matrix.
The Data Type imatrix_slice.
The Data Type rvector_slice.
The Multiple-Precision Data Type l_imatrix.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
The Data Type rmatrix_subv.
The Multiple-Precision Data Type l_rmatrix.
l_interval()
Constructor of class l_interval.
l_imatrix_slice & operator-=(const l_interval &c)
Implementation of subtraction and allocation operation.
void Resize(cimatrix &A)
Resizes the matrix.
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
l_imatrix_subv & operator/=(const l_interval &c)
Implementation of division and allocation operation.
l_imatrix_slice & operator&=(const l_imatrix &m1)
Allocates the intersection of the arguments to the first argument.
int ColLen(const cimatrix &)
Returns the column dimension.
l_imatrix_subv & operator=(const l_imatrix_subv &rv)
Implementation of standard assigning operator.
l_imatrix_subv & operator*=(const l_interval &c)
Implementation of multiplication and allocation operation.
cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
int RowLen(const cimatrix &)
Returns the row dimension.
l_imatrix_slice & operator|=(const l_imatrix &m1)
Allocates the convex hull of the arguments to the first argument.
l_imatrix_slice & operator=(const l_imatrix &m)
Implementation of standard assigning operator.
l_ivector_slice & operator=(const l_ivector_slice &sl)
Implementation of standard assigning operator.
cimatrix _imatrix(const cimatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
The Multiple-Precision Data Type l_rvector.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
l_imatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
l_imatrix_slice & operator+=(const l_interval &c)
Implementation of addition and allocation operation.
l_imatrix_subv & operator|=(const l_ivector &rv)
Allocates the convex hull of the arguments to the first argument.
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
The Multiple-Precision Data Type l_rvector_slice.
l_imatrix_slice & operator/=(const l_interval &c)
Implementation of division and allocation operation.
l_imatrix_subv & operator-=(const l_interval &c)
Implementation of subtraction and allocation operation.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
The Multiple-Precision Data Type l_imatrix_subv.