26 #ifndef _CXSC_CIMATRIX_INL_INCLUDED 27 #define _CXSC_CIMATRIX_INL_INCLUDED 59 INLINE
cimatrix::cimatrix(
const rmatrix &rm)
throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
62 for(
int i=0;i<xsize*ysize;i++)
66 INLINE
cimatrix::cimatrix(
const cmatrix &rm)
throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
69 for(
int i=0;i<xsize*ysize;i++)
73 INLINE
cimatrix::cimatrix(
const imatrix &rm)
throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
76 for(
int i=0;i<xsize*ysize;i++)
83 for(
int i=0;i<xsize*ysize;i++)
89 throw(ERROR_CIMATRIX_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_CIMATRIX_WRONG_BOUNDARIES(
"cimatrix::cimatrix(const int &m, const int &n)"));
101 #if(CXSC_INDEX_CHECK) 102 throw(ERROR_CIMATRIX_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_CIMATRIX_WRONG_BOUNDARIES(
"cimatrix::cimatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
116 for (
int i=0, j=v.start;i<v.size;i++,j+=v.offset)
123 for(
int i=0;i<v.size;i++)
130 for(
int i=0;i<v.size;i++)
137 for(
int i=0;i<v.size;i++)
144 for(
int i=0;i<v.size;i++)
151 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
158 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
165 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
172 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
182 for (i=0;i<ysize;i++)
186 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
196 for (i=0;i<ysize;i++)
200 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
209 for (i=0;i<ysize;i++)
213 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
222 for (i=0;i<ysize;i++)
226 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
232 #if(CXSC_INDEX_CHECK) 233 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
243 #if(CXSC_INDEX_CHECK) 244 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
254 #if(CXSC_INDEX_CHECK) 255 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
265 #if(CXSC_INDEX_CHECK) 266 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
276 #if(CXSC_INDEX_CHECK) 277 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC)
282 #if(CXSC_INDEX_CHECK) 283 if((i<lb)||(i>ub)) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval &cimatrix_subv::operator [](const int &i) const"));
285 return dat[start+((i-lb)*offset)];
289 #if(CXSC_INDEX_CHECK) 290 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC)
295 #if(CXSC_INDEX_CHECK) 296 if((i<lb)||(i>ub)) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval &cimatrix_subv::operator [](const int &i)"));
298 return dat[start+((i-lb)*offset)];
302 #if(CXSC_INDEX_CHECK) 303 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
308 #if(CXSC_INDEX_CHECK) 309 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const int &i)"));
315 #if(CXSC_INDEX_CHECK) 316 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
321 #if(CXSC_INDEX_CHECK) 322 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const cxscmatrix_column &i)"));
324 return cimatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
328 #if(CXSC_INDEX_CHECK) 329 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
334 #if(CXSC_INDEX_CHECK) 335 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const int &i)"));
341 #if(CXSC_INDEX_CHECK) 342 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
347 #if(CXSC_INDEX_CHECK) 348 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix::operator [](const cxscmatrix_column &i)"));
350 return cimatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
355 #if(CXSC_INDEX_CHECK) 356 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG)
361 #if(CXSC_INDEX_CHECK) 362 if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix::operator ()(const int &m, const int &n)"));
368 #if(CXSC_INDEX_CHECK) 369 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG)
374 #if(CXSC_INDEX_CHECK) 375 if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
381 #if(CXSC_INDEX_CHECK) 382 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
387 #if(CXSC_INDEX_CHECK) 388 if((i<start1)||(i>end1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const int &i)"));
390 return cimatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
394 #if(CXSC_INDEX_CHECK) 395 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
400 #if(CXSC_INDEX_CHECK) 401 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const cxscmatrix_column &i)"));
403 return cimatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
407 #if(CXSC_INDEX_CHECK) 408 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
413 #if(CXSC_INDEX_CHECK) 414 if((i<start1)||(i>end1)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const int &i)"));
416 return cimatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
420 #if(CXSC_INDEX_CHECK) 421 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT)
426 #if(CXSC_INDEX_CHECK) 427 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT(
"cimatrix_subv cimatrix_slice::operator [](const cxscmatrix_column &i)"));
429 return cimatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
434 #if(CXSC_INDEX_CHECK) 435 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG)
440 #if(CXSC_INDEX_CHECK) 441 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix_slice::operator ()(const int &m, const int &n)"));
447 #if(CXSC_INDEX_CHECK) 448 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG)
453 #if(CXSC_INDEX_CHECK) 454 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG(
"cimatrix_slice cimatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
460 #if(CXSC_INDEX_CHECK) 461 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG)
466 #if(CXSC_INDEX_CHECK) 467 if(1<lb||i>ub) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"cimatrix_subv cimatrix_subv::operator ()(const int &i)"));
473 #if(CXSC_INDEX_CHECK) 474 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG)
479 #if(CXSC_INDEX_CHECK) 480 if(i1<lb||i2>ub) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"cimatrix_subv cimatrix_subv::operator ()(const int &i1,const int &i2)"));
482 return cimatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
490 #if(CXSC_INDEX_CHECK) 491 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
495 {
return _mvvassign(*
this,v); }
497 #if(CXSC_INDEX_CHECK) 498 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
502 {
return _mvvassign(*
this,
civector(v)); }
507 #if(CXSC_INDEX_CHECK) 508 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
512 {
return _mvvassign(*
this,v); }
514 #if(CXSC_INDEX_CHECK) 515 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
519 {
return _mvvassign(*
this,
civector(v)); }
524 #if(CXSC_INDEX_CHECK) 525 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
529 {
return _mvvassign(*
this,v); }
531 #if(CXSC_INDEX_CHECK) 532 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
536 {
return _mvvassign(*
this,
civector(v)); }
541 #if(CXSC_INDEX_CHECK) 542 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
546 {
return _mvvassign(*
this,v); }
548 #if(CXSC_INDEX_CHECK) 549 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
553 {
return _mvvassign(*
this,
civector(v)); }
579 INLINE cimatrix::operator
void*()
throw() {
return _mvoid(*
this); }
582 #if(CXSC_INDEX_CHECK) 583 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
587 {
return _msmassign(*
this,m); }
589 #if(CXSC_INDEX_CHECK) 590 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
594 {
return _msmsassign(*
this,ms); }
597 #if(CXSC_INDEX_CHECK) 598 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
602 {
return _msmassign(*
this,
cimatrix(v)); }
604 #if(CXSC_INDEX_CHECK) 605 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
611 #if(CXSC_INDEX_CHECK) 612 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
619 #if(CXSC_INDEX_CHECK) 620 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
624 {
return _msmassign(*
this,m); }
626 #if(CXSC_INDEX_CHECK) 627 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
631 {
return _msmsassign(*
this,ms); }
634 #if(CXSC_INDEX_CHECK) 635 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
639 {
return _msmassign(*
this,
cimatrix(v)); }
641 #if(CXSC_INDEX_CHECK) 642 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
648 #if(CXSC_INDEX_CHECK) 649 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
656 #if(CXSC_INDEX_CHECK) 657 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
661 {
return _msmassign(*
this,m); }
663 #if(CXSC_INDEX_CHECK) 664 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
668 {
return _msmsassign(*
this,ms); }
671 #if(CXSC_INDEX_CHECK) 672 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
676 {
return _msmassign(*
this,
cimatrix(v)); }
678 #if(CXSC_INDEX_CHECK) 679 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
685 #if(CXSC_INDEX_CHECK) 686 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
693 #if(CXSC_INDEX_CHECK) 694 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
698 {
return _msmassign(*
this,m); }
700 #if(CXSC_INDEX_CHECK) 701 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
705 {
return _msmsassign(*
this,ms); }
708 #if(CXSC_INDEX_CHECK) 709 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
713 {
return _msmassign(*
this,
cimatrix(v)); }
715 #if(CXSC_INDEX_CHECK) 716 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
722 #if(CXSC_INDEX_CHECK) 723 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
729 INLINE cimatrix_slice::operator
void*()
throw() {
return _msvoid(*
this); }
747 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
749 for(
int i=0;i<m.xsize*m.ysize;i++)
750 erg.dat[i]=
InfRe(m.dat[i]);
757 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
759 for(
int i=0;i<sl.sysize;i++)
761 for(
int j=0;j<sl.sxsize;j++)
763 erg.dat[i*sl.sxsize+j]=
InfRe(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
772 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
774 for(
int i=0;i<m.xsize*m.ysize;i++)
775 erg.dat[i]=
SupRe(m.dat[i]);
782 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
784 for(
int i=0;i<sl.sysize;i++)
786 for(
int j=0;j<sl.sxsize;j++)
788 erg.dat[i*sl.sxsize+j]=
SupRe(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
797 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
799 for(
int i=0;i<m.xsize*m.ysize;i++)
800 erg.dat[i]=
InfIm(m.dat[i]);
807 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
809 for(
int i=0;i<sl.sysize;i++)
811 for(
int j=0;j<sl.sxsize;j++)
813 erg.dat[i*sl.sxsize+j]=
InfIm(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
822 rmatrix erg(m.lb1,m.lb2,m.ub1,m.ub2);
824 for(
int i=0;i<m.xsize*m.ysize;i++)
825 erg.dat[i]=
SupIm(m.dat[i]);
832 rmatrix erg(sl.start1,sl.start2,sl.end1,sl.end2);
834 for(
int i=0;i<sl.sysize;i++)
836 for(
int j=0;j<sl.sxsize;j++)
838 erg.dat[i*sl.sxsize+j]=
SupIm(sl.dat[(i+sl.offset1)*sl.mxsize+j+sl.offset2]);
846 #if(CXSC_INDEX_CHECK) 847 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
851 {
return _mvvsetinf(iv,rv); }
853 #if(CXSC_INDEX_CHECK) 854 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
858 {
return _mvvsetsup(iv,rv); }
860 #if(CXSC_INDEX_CHECK) 861 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
865 {
return _mvvusetinf(iv,rv); }
867 #if(CXSC_INDEX_CHECK) 868 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
872 {
return _mvvusetsup(iv,rv); }
874 #if(CXSC_INDEX_CHECK) 875 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
879 {
return _mvvsetim(iv,rv); }
881 #if(CXSC_INDEX_CHECK) 882 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
886 {
return _mvvsetre(iv,rv); }
897 #if(CXSC_INDEX_CHECK) 898 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
902 {
return _mvmvcimult<cimatrix_subv,cimatrix_subv,cinterval>(rv1,rv2); }
904 #if(CXSC_INDEX_CHECK) 905 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
909 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(rv1,rv2); }
911 #if(CXSC_INDEX_CHECK) 912 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
916 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(rv2,rv1); }
918 #if(CXSC_INDEX_CHECK) 919 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
923 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(
civector(sl),sv); }
925 #if(CXSC_INDEX_CHECK) 926 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
930 {
return _vmvcimult<civector,cimatrix_subv,cinterval>(
civector(vs),mv); }
932 #if(CXSC_INDEX_CHECK) 933 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
937 {
return _mvmvplus<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
939 #if(CXSC_INDEX_CHECK) 940 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
944 {
return _mvvplus<cimatrix_subv,civector,civector>(rv1,rv2); }
946 #if(CXSC_INDEX_CHECK) 947 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
951 {
return _mvvplus<cimatrix_subv,civector,civector>(rv2,rv1); }
953 #if(CXSC_INDEX_CHECK) 954 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
958 {
return _mvvplus<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
960 #if(CXSC_INDEX_CHECK) 961 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
965 {
return _mvvplus<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
967 #if(CXSC_INDEX_CHECK) 968 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
972 {
return _mvvplusassign(*
this,rv); }
974 #if(CXSC_INDEX_CHECK) 975 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
979 {
return _mvvplusassign(*
this,
civector(rv)); }
981 #if(CXSC_INDEX_CHECK) 982 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
986 {
return _mvmvminus<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
988 #if(CXSC_INDEX_CHECK) 989 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
993 {
return _vmvminus<civector,cimatrix_subv,civector>(rv1,rv2); }
995 #if(CXSC_INDEX_CHECK) 996 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1000 {
return _mvvminus<cimatrix_subv,civector,civector>(rv1,rv2); }
1002 #if(CXSC_INDEX_CHECK) 1003 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1007 {
return _vmvminus<civector,cimatrix_subv,civector>(
civector(sl),mv); }
1009 #if(CXSC_INDEX_CHECK) 1010 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1014 {
return _mvvminus<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
1016 #if(CXSC_INDEX_CHECK) 1017 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1021 {
return _mvvminusassign(*
this,rv); }
1023 #if(CXSC_INDEX_CHECK) 1024 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1028 {
return _mvvminusassign(*
this,
civector(rv)); }
1030 #if(CXSC_INDEX_CHECK) 1031 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1035 {
return _mvmvconv<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
1037 #if(CXSC_INDEX_CHECK) 1038 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1042 {
return _mvvconv<cimatrix_subv,civector,civector>(rv1,rv2); }
1044 #if(CXSC_INDEX_CHECK) 1045 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1049 {
return _mvvconv<cimatrix_subv,civector,civector>(rv2,rv1); }
1051 #if(CXSC_INDEX_CHECK) 1052 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1056 {
return _mvvconv<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
1058 #if(CXSC_INDEX_CHECK) 1059 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1063 {
return _mvvconv<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
1065 #if(CXSC_INDEX_CHECK) 1066 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1070 {
return _mvvconvassign(*
this,rv); }
1072 #if(CXSC_INDEX_CHECK) 1073 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1077 {
return _mvvconvassign(*
this,
civector(rv)); }
1079 #if(CXSC_INDEX_CHECK) 1080 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1084 {
return _mvmvsect<cimatrix_subv,cimatrix_subv,civector>(rv1,rv2); }
1086 #if(CXSC_INDEX_CHECK) 1087 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1091 {
return _mvvsect<cimatrix_subv,civector,civector>(rv1,rv2); }
1093 #if(CXSC_INDEX_CHECK) 1094 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1098 {
return _mvvsect<cimatrix_subv,civector,civector>(rv2,rv1); }
1100 #if(CXSC_INDEX_CHECK) 1101 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1105 {
return _mvvsect<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
1107 #if(CXSC_INDEX_CHECK) 1108 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1112 {
return _mvvsect<cimatrix_subv,civector,civector>(mv,
civector(sl)); }
1114 #if(CXSC_INDEX_CHECK) 1115 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1119 {
return _mvvsectassign(*
this,rv); }
1121 #if(CXSC_INDEX_CHECK) 1122 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1126 {
return _mvvsectassign(*
this,
civector(rv)); }
1157 #if(CXSC_INDEX_CHECK) 1158 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL)
1162 {
return _mlb(rm,i); }
1164 #if(CXSC_INDEX_CHECK) 1165 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL)
1169 {
return _mub(rm,i); }
1171 #if(CXSC_INDEX_CHECK) 1172 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL)
1176 {
return _mslb(rm,i); }
1178 #if(CXSC_INDEX_CHECK) 1179 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL)
1183 {
return _msub(rm,i); }
1185 #if(CXSC_INDEX_CHECK) 1186 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL)
1190 {
return _msetlb(m,i,j); }
1192 #if(CXSC_INDEX_CHECK) 1193 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL)
1197 {
return _msetub(m,i,j); }
1200 {
return Ub(A,2)-
Lb(A,2)+1; }
1203 {
return Ub(A,1)-
Lb(A,1)+1; }
1206 {
return Ub(A,2)-
Lb(A,2)+1; }
1209 {
return Ub(A,1)-
Lb(A,1)+1; }
1213 #if(CXSC_INDEX_CHECK) 1214 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES)
1218 { _mresize<cimatrix,cinterval>(A,m,n); }
1219 INLINE
void Resize(
cimatrix &A,
const int &m1,
const int &m2,
const int &n1,
const int &n2)
1220 #if(CXSC_INDEX_CHECK) 1221 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES)
1225 { _mresize<cimatrix,cinterval>(A,m1,m2,n1,n2); }
1237 #if(CXSC_INDEX_CHECK) 1238 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1242 {
return _mmsetinf<cimatrix,cmatrix>(cm,rm); }
1244 #if(CXSC_INDEX_CHECK) 1245 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1249 {
return _msmsetinf<cimatrix_slice,cmatrix>(cm,rm); }
1251 #if(CXSC_INDEX_CHECK) 1252 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1256 {
return _mmssetinf<cimatrix,cmatrix_slice>(cm,rm); }
1258 #if(CXSC_INDEX_CHECK) 1259 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1263 {
return _msmssetinf<cimatrix_slice,cmatrix_slice>(cm,rm); }
1265 #if(CXSC_INDEX_CHECK) 1266 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1270 {
return _mmsetsup<cimatrix,cmatrix>(cm,rm); }
1272 #if(CXSC_INDEX_CHECK) 1273 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1277 {
return _msmsetsup<cimatrix_slice,cmatrix>(cm,rm); }
1279 #if(CXSC_INDEX_CHECK) 1280 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1284 {
return _mmssetsup<cimatrix,cmatrix_slice>(cm,rm); }
1286 #if(CXSC_INDEX_CHECK) 1287 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1291 {
return _msmssetsup<cimatrix_slice,cmatrix_slice>(cm,rm); }
1293 #if(CXSC_INDEX_CHECK) 1294 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1298 {
return _mmusetinf<cimatrix,cmatrix>(cm,rm); }
1300 #if(CXSC_INDEX_CHECK) 1301 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1305 {
return _msmusetinf<cimatrix_slice,cmatrix>(cm,rm); }
1307 #if(CXSC_INDEX_CHECK) 1308 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1312 {
return _mmsusetinf<cimatrix,cmatrix_slice>(cm,rm); }
1314 #if(CXSC_INDEX_CHECK) 1315 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1319 {
return _msmsusetinf<cimatrix_slice,cmatrix_slice>(cm,rm); }
1321 #if(CXSC_INDEX_CHECK) 1322 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1326 {
return _mmusetsup<cimatrix,cmatrix>(cm,rm); }
1328 #if(CXSC_INDEX_CHECK) 1329 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1333 {
return _msmusetsup<cimatrix_slice,cmatrix>(cm,rm); }
1335 #if(CXSC_INDEX_CHECK) 1336 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1340 {
return _mmsusetsup<cimatrix,cmatrix_slice>(cm,rm); }
1342 #if(CXSC_INDEX_CHECK) 1343 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1347 {
return _msmsusetsup<cimatrix_slice,cmatrix_slice>(cm,rm); }
1353 #if(CXSC_INDEX_CHECK) 1354 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1358 {
return _mmsetim<cimatrix,imatrix>(cm,rm); }
1360 #if(CXSC_INDEX_CHECK) 1361 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1365 {
return _msmsetim<cimatrix_slice,imatrix>(cm,rm); }
1367 #if(CXSC_INDEX_CHECK) 1368 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1372 {
return _mmssetim<cimatrix,imatrix_slice>(cm,rm); }
1374 #if(CXSC_INDEX_CHECK) 1375 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1379 {
return _msmssetim<cimatrix_slice,imatrix_slice>(cm,rm); }
1381 #if(CXSC_INDEX_CHECK) 1382 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1386 {
return _mmsetre<cimatrix,imatrix>(cm,rm); }
1388 #if(CXSC_INDEX_CHECK) 1389 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1393 {
return _msmsetre<cimatrix_slice,imatrix>(cm,rm); }
1395 #if(CXSC_INDEX_CHECK) 1396 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1400 {
return _mmssetre<cimatrix,imatrix_slice>(cm,rm); }
1402 #if(CXSC_INDEX_CHECK) 1403 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1407 {
return _msmssetre<cimatrix_slice,imatrix_slice>(cm,rm); }
1409 #if(CXSC_INDEX_CHECK) 1410 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_CIMATRIX_USE_OF_UNINITIALIZED_OBJ)
1414 { _smconstr(*
this,m); }
1422 #if(CXSC_INDEX_CHECK) 1423 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1427 {
return _mvvplusassign(*
this,rv); }
1429 #if(CXSC_INDEX_CHECK) 1430 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1434 {
return _mvvplusassign(*
this,
rvector(rv)); }
1436 #if(CXSC_INDEX_CHECK) 1437 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1441 {
return _mvvminusassign(*
this,rv); }
1443 #if(CXSC_INDEX_CHECK) 1444 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1448 {
return _mvvminusassign(*
this,
rvector(rv)); }
1450 #if(CXSC_INDEX_CHECK) 1451 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1455 {
return _mvvconvassign(*
this,rv); }
1457 #if(CXSC_INDEX_CHECK) 1458 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1462 {
return _mvvconvassign(*
this,
rvector(rv)); }
1464 #if(CXSC_INDEX_CHECK) 1465 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1469 {
return _mvvsectassign(*
this,rv); }
1471 #if(CXSC_INDEX_CHECK) 1472 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1476 {
return _mvvsectassign(*
this,
rvector(rv)); }
1483 #if(CXSC_INDEX_CHECK) 1484 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1488 {
return _mvvplusassign(*
this,rv); }
1490 #if(CXSC_INDEX_CHECK) 1491 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1495 {
return _mvvplusassign(*
this,
cvector(rv)); }
1497 #if(CXSC_INDEX_CHECK) 1498 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1502 {
return _mvvminusassign(*
this,rv); }
1504 #if(CXSC_INDEX_CHECK) 1505 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1509 {
return _mvvminusassign(*
this,
cvector(rv)); }
1511 #if(CXSC_INDEX_CHECK) 1512 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1516 {
return _mvvconvassign(*
this,rv); }
1518 #if(CXSC_INDEX_CHECK) 1519 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1523 {
return _mvvconvassign(*
this,
cvector(rv)); }
1525 #if(CXSC_INDEX_CHECK) 1526 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1530 {
return _mvvsectassign(*
this,rv); }
1532 #if(CXSC_INDEX_CHECK) 1533 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1537 {
return _mvvsectassign(*
this,
cvector(rv)); }
1544 #if(CXSC_INDEX_CHECK) 1545 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1549 {
return _mvvplusassign(*
this,rv); }
1551 #if(CXSC_INDEX_CHECK) 1552 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1556 {
return _mvvplusassign(*
this,
ivector(rv)); }
1558 #if(CXSC_INDEX_CHECK) 1559 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1563 {
return _mvvminusassign(*
this,rv); }
1565 #if(CXSC_INDEX_CHECK) 1566 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1570 {
return _mvvminusassign(*
this,
ivector(rv)); }
1572 #if(CXSC_INDEX_CHECK) 1573 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1577 {
return _mvvconvassign(*
this,rv); }
1579 #if(CXSC_INDEX_CHECK) 1580 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1584 {
return _mvvconvassign(*
this,
ivector(rv)); }
1586 #if(CXSC_INDEX_CHECK) 1587 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1591 {
return _mvvsectassign(*
this,rv); }
1593 #if(CXSC_INDEX_CHECK) 1594 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
1598 {
return _mvvsectassign(*
this,
ivector(rv)); }
1607 #if(CXSC_INDEX_CHECK) 1608 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1612 {
return (*
this=*
this*m); }
1614 #if(CXSC_INDEX_CHECK) 1615 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1619 {
return (*
this=*
this*m); }
1632 #if(CXSC_INDEX_CHECK) 1633 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1637 {
return (*
this=*
this*m); }
1639 #if(CXSC_INDEX_CHECK) 1640 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1644 {
return (*
this=*
this*m); }
1657 #if(CXSC_INDEX_CHECK) 1658 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1662 {
return (*
this=*
this*m); }
1664 #if(CXSC_INDEX_CHECK) 1665 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1669 {
return (*
this=*
this*m); }
1682 #if(CXSC_INDEX_CHECK) 1683 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1687 {
return (*
this=*
this*m); }
1689 #if(CXSC_INDEX_CHECK) 1690 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1694 {
return (*
this=*
this*m); }
1726 #if(CXSC_INDEX_CHECK) 1727 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1731 { _vmconstr<civector,cimatrix,cinterval>(*
this,sl); }
1733 #if(CXSC_INDEX_CHECK) 1734 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1738 { _vmsconstr<civector,cimatrix_slice,cinterval>(*
this,sl); }
1740 #if(CXSC_INDEX_CHECK) 1741 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1745 {
return _vmassign<civector,cimatrix,cinterval>(*
this,m); }
1747 #if(CXSC_INDEX_CHECK) 1748 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1752 {
return _vmassign<civector,cimatrix,cinterval>(*
this,
cimatrix(m)); }
1754 #if(CXSC_INDEX_CHECK) 1755 throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1761 #if(CXSC_INDEX_CHECK) 1762 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1766 {
return _mvvassign(*
this,
civector(m)); }
1768 #if(CXSC_INDEX_CHECK) 1769 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1775 #if(CXSC_INDEX_CHECK) 1776 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1780 {
return _mvcimult<cimatrix,civector,civector>(m,v); }
1782 #if(CXSC_INDEX_CHECK) 1783 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1787 {
return _msvcimult<cimatrix_slice,civector,civector>(ms,v); }
1789 #if(CXSC_INDEX_CHECK) 1790 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1794 {
return _vmcimult<civector,cimatrix,civector>(v,m); }
1796 #if(CXSC_INDEX_CHECK) 1797 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1801 {
return _vmscimult<civector,cimatrix_slice,civector>(v,ms); }
1803 #if(CXSC_INDEX_CHECK) 1804 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1808 {
return _vmcimultassign<civector,cimatrix,cinterval>(v,m); }
1810 #if(CXSC_INDEX_CHECK) 1811 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1815 {
return _vmscimultassign<civector,cimatrix_slice,cinterval>(v,ms); }
1817 #if(CXSC_INDEX_CHECK) 1818 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1822 {
return _vsmcimultassign<civector_slice,cimatrix,cinterval>(*
this,m); }
1824 #if(CXSC_INDEX_CHECK) 1825 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1829 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1831 #if(CXSC_INDEX_CHECK) 1832 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1836 {
return _vmscimult<civector,cimatrix_slice,civector>(
civector(v),m); }
1839 #if(CXSC_INDEX_CHECK) 1840 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1844 {
return _mvvassign(*
this,
rvector(m)); }
1846 #if(CXSC_INDEX_CHECK) 1847 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1853 #if(CXSC_INDEX_CHECK) 1854 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1858 {
return _vmcimult<rvector,cimatrix,civector>(v,m); }
1860 #if(CXSC_INDEX_CHECK) 1861 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1865 {
return _vmscimult<rvector,cimatrix_slice,civector>(v,ms); }
1867 #if(CXSC_INDEX_CHECK) 1868 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1872 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1874 #if(CXSC_INDEX_CHECK) 1875 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1879 {
return _mvcimult<cimatrix,rvector,civector>(m,v); }
1881 #if(CXSC_INDEX_CHECK) 1882 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1886 {
return _msvcimult<cimatrix_slice,rvector,civector>(ms,v); }
1889 #if(CXSC_INDEX_CHECK) 1890 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1894 {
return _mvvassign(*
this,
cvector(m)); }
1896 #if(CXSC_INDEX_CHECK) 1897 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1903 #if(CXSC_INDEX_CHECK) 1904 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1908 {
return _vmcimult<cvector,cimatrix,civector>(v,m); }
1910 #if(CXSC_INDEX_CHECK) 1911 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1915 {
return _vmscimult<cvector,cimatrix_slice,civector>(v,ms); }
1917 #if(CXSC_INDEX_CHECK) 1918 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1922 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1924 #if(CXSC_INDEX_CHECK) 1925 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1929 {
return _mvcimult<cimatrix,cvector,civector>(m,v); }
1931 #if(CXSC_INDEX_CHECK) 1932 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1936 {
return _msvcimult<cimatrix_slice,cvector,civector>(ms,v); }
1939 #if(CXSC_INDEX_CHECK) 1940 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1944 {
return _mvvassign(*
this,
ivector(m)); }
1946 #if(CXSC_INDEX_CHECK) 1947 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
1953 #if(CXSC_INDEX_CHECK) 1954 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1958 {
return _vmcimult<ivector,cimatrix,civector>(v,m); }
1960 #if(CXSC_INDEX_CHECK) 1961 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1965 {
return _vmscimult<ivector,cimatrix_slice,civector>(v,ms); }
1967 #if(CXSC_INDEX_CHECK) 1968 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1972 {
return _vmcimult<civector,cimatrix,civector>(
civector(v),m); }
1974 #if(CXSC_INDEX_CHECK) 1975 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1979 {
return _mvcimult<cimatrix,ivector,civector>(m,v); }
1981 #if(CXSC_INDEX_CHECK) 1982 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1986 {
return _msvcimult<cimatrix_slice,ivector,civector>(ms,v); }
1991 #if(CXSC_INDEX_CHECK) 1992 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
1996 {
return _mmplus<cimatrix,cimatrix,cimatrix>(m1,m2); }
1998 #if(CXSC_INDEX_CHECK) 1999 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2003 {
return _mmsplus<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2005 #if(CXSC_INDEX_CHECK) 2006 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2010 {
return _mmsplus<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2012 #if(CXSC_INDEX_CHECK) 2013 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2017 {
return _msmsplus<cimatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2019 #if(CXSC_INDEX_CHECK) 2020 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2024 {
return _mmplusassign(m1,m2); }
2026 #if(CXSC_INDEX_CHECK) 2027 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2031 {
return _mmsplusassign(m1,ms); }
2033 #if(CXSC_INDEX_CHECK) 2034 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2038 {
return _msmplusassign(*
this,m1); }
2040 #if(CXSC_INDEX_CHECK) 2041 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2045 {
return _msmsplusassign(*
this,ms2); }
2049 #if(CXSC_INDEX_CHECK) 2050 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2054 {
return _mmminus<cimatrix,cimatrix,cimatrix>(m1,m2); }
2056 #if(CXSC_INDEX_CHECK) 2057 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2061 {
return _mmsminus<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2063 #if(CXSC_INDEX_CHECK) 2064 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2068 {
return _msmminus<cimatrix_slice,cimatrix,cimatrix>(ms,m); }
2070 #if(CXSC_INDEX_CHECK) 2071 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2075 {
return _msmsminus<cimatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2077 #if(CXSC_INDEX_CHECK) 2078 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2082 {
return _mmminusassign(m1,m2); }
2084 #if(CXSC_INDEX_CHECK) 2085 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2089 {
return _mmsminusassign(m1,ms); }
2091 #if(CXSC_INDEX_CHECK) 2092 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2096 {
return _msmminusassign(*
this,m1); }
2098 #if(CXSC_INDEX_CHECK) 2099 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2103 {
return _msmsminusassign(*
this,ms2); }
2105 #if(CXSC_INDEX_CHECK) 2106 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2110 {
return _mmcimult<cimatrix,cimatrix,cimatrix>(m1,m2); }
2112 #if(CXSC_INDEX_CHECK) 2113 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2117 {
return _mmscimult<cimatrix,cimatrix_slice,cimatrix>(m1,ms); }
2119 #if(CXSC_INDEX_CHECK) 2120 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2124 {
return _msmcimult<cimatrix_slice,cimatrix,cimatrix>(ms,m1); }
2126 #if(CXSC_INDEX_CHECK) 2127 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2131 {
return _msmscimult<cimatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2133 #if(CXSC_INDEX_CHECK) 2134 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2138 {
return _mmcimultassign<cimatrix,cimatrix,cinterval>(m1,m2); }
2140 #if(CXSC_INDEX_CHECK) 2141 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2145 {
return _mmscimultassign<cimatrix,cimatrix_slice,cinterval>(m1,ms); }
2147 #if(CXSC_INDEX_CHECK) 2148 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2152 {
return _mmconv<cimatrix,cimatrix,cimatrix>(m1,m2); }
2154 #if(CXSC_INDEX_CHECK) 2155 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2159 {
return _mmsconv<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2161 #if(CXSC_INDEX_CHECK) 2162 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2166 {
return _mmsconv<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2168 #if(CXSC_INDEX_CHECK) 2169 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2173 {
return _msmsconv<cimatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2175 #if(CXSC_INDEX_CHECK) 2176 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2180 {
return _mmconvassign(m1,m2); }
2182 #if(CXSC_INDEX_CHECK) 2183 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2187 {
return _mmsconvassign(m1,ms); }
2189 #if(CXSC_INDEX_CHECK) 2190 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2194 {
return _msmconvassign(*
this,m1); }
2196 #if(CXSC_INDEX_CHECK) 2197 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2201 {
return _msmsconvassign(*
this,ms2); }
2203 #if(CXSC_INDEX_CHECK) 2204 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2208 {
return _mmsect<cimatrix,cimatrix,cimatrix>(m1,m2); }
2210 #if(CXSC_INDEX_CHECK) 2211 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2215 {
return _mmssect<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2217 #if(CXSC_INDEX_CHECK) 2218 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2222 {
return _mmssect<cimatrix,cimatrix_slice,cimatrix>(m,ms); }
2224 #if(CXSC_INDEX_CHECK) 2225 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2229 {
return _msmssect<cimatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2231 #if(CXSC_INDEX_CHECK) 2232 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2236 {
return _mmsectassign(m1,m2); }
2238 #if(CXSC_INDEX_CHECK) 2239 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2243 {
return _mmssectassign(m1,ms); }
2245 #if(CXSC_INDEX_CHECK) 2246 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2250 {
return _msmsectassign(*
this,m1); }
2252 #if(CXSC_INDEX_CHECK) 2253 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2257 {
return _msmssectassign(*
this,ms2); }
2260 #if(CXSC_INDEX_CHECK) 2261 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2265 {
return _mmplus<rmatrix,cimatrix,cimatrix>(m1,m2); }
2267 #if(CXSC_INDEX_CHECK) 2268 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2272 {
return _mmplus<rmatrix,cimatrix,cimatrix>(m2,m1); }
2274 #if(CXSC_INDEX_CHECK) 2275 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2279 {
return _mmsplus<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2281 #if(CXSC_INDEX_CHECK) 2282 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2286 {
return _mmsplus<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2288 #if(CXSC_INDEX_CHECK) 2289 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2293 {
return _mmsplus<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2295 #if(CXSC_INDEX_CHECK) 2296 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2300 {
return _mmsplus<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2302 #if(CXSC_INDEX_CHECK) 2303 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2307 {
return _msmsplus<rmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2309 #if(CXSC_INDEX_CHECK) 2310 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2314 {
return _msmsplus<rmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2316 #if(CXSC_INDEX_CHECK) 2317 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2321 {
return _mmplusassign(m1,m2); }
2323 #if(CXSC_INDEX_CHECK) 2324 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2328 {
return _mmsplusassign(m1,ms); }
2330 #if(CXSC_INDEX_CHECK) 2331 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2335 {
return _msmplusassign(*
this,m1); }
2337 #if(CXSC_INDEX_CHECK) 2338 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2342 {
return _msmsplusassign(*
this,ms2); }
2344 #if(CXSC_INDEX_CHECK) 2345 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2349 {
return _mmminus<rmatrix,cimatrix,cimatrix>(m1,m2); }
2351 #if(CXSC_INDEX_CHECK) 2352 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2356 {
return _mmminus<cimatrix,rmatrix,cimatrix>(m1,m2); }
2358 #if(CXSC_INDEX_CHECK) 2359 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2363 {
return _mmsminus<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2365 #if(CXSC_INDEX_CHECK) 2366 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2370 {
return _mmsminus<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2372 #if(CXSC_INDEX_CHECK) 2373 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2377 {
return _msmminus<rmatrix_slice,cimatrix,cimatrix>(ms,m); }
2379 #if(CXSC_INDEX_CHECK) 2380 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2384 {
return _msmminus<cimatrix_slice,rmatrix,cimatrix>(ms,m); }
2386 #if(CXSC_INDEX_CHECK) 2387 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2391 {
return _msmsminus<rmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2393 #if(CXSC_INDEX_CHECK) 2394 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2398 {
return _msmsminus<cimatrix_slice,rmatrix_slice,cimatrix>(ms1,ms2); }
2400 #if(CXSC_INDEX_CHECK) 2401 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2405 {
return _mmminusassign(m1,m2); }
2407 #if(CXSC_INDEX_CHECK) 2408 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2412 {
return _mmsminusassign(m1,ms); }
2414 #if(CXSC_INDEX_CHECK) 2415 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2419 {
return _msmminusassign(*
this,m1); }
2421 #if(CXSC_INDEX_CHECK) 2422 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2426 {
return _msmsminusassign(*
this,ms2); }
2428 #if(CXSC_INDEX_CHECK) 2429 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2433 {
return _mmcimult<rmatrix,cimatrix,cimatrix>(m1,m2); }
2435 #if(CXSC_INDEX_CHECK) 2436 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2440 {
return _mmcimult<cimatrix,rmatrix,cimatrix>(m1,m2); }
2442 #if(CXSC_INDEX_CHECK) 2443 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2447 {
return _mmscimult<rmatrix,cimatrix_slice,cimatrix>(m1,ms); }
2449 #if(CXSC_INDEX_CHECK) 2450 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2454 {
return _mmscimult<cimatrix,rmatrix_slice,cimatrix>(m1,ms); }
2456 #if(CXSC_INDEX_CHECK) 2457 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2461 {
return _msmcimult<rmatrix_slice,cimatrix,cimatrix>(ms,m1); }
2463 #if(CXSC_INDEX_CHECK) 2464 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2468 {
return _msmcimult<cimatrix_slice,rmatrix,cimatrix>(ms,m1); }
2470 #if(CXSC_INDEX_CHECK) 2471 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2475 {
return _msmscimult<rmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2477 #if(CXSC_INDEX_CHECK) 2478 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2482 {
return _msmscimult<cimatrix_slice,rmatrix_slice,cimatrix>(ms1,ms2); }
2484 #if(CXSC_INDEX_CHECK) 2485 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2489 {
return _mmcimultassign<cimatrix,rmatrix,cinterval>(m1,m2); }
2491 #if(CXSC_INDEX_CHECK) 2492 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2496 {
return _mmscimultassign<cimatrix,rmatrix_slice,cinterval>(m1,ms); }
2498 #if(CXSC_INDEX_CHECK) 2499 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2503 {
return _mmconv<rmatrix,cimatrix,cimatrix>(m1,m2); }
2505 #if(CXSC_INDEX_CHECK) 2506 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2510 {
return _mmconv<rmatrix,cimatrix,cimatrix>(m2,m1); }
2512 #if(CXSC_INDEX_CHECK) 2513 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2517 {
return _mmsconv<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2519 #if(CXSC_INDEX_CHECK) 2520 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2524 {
return _mmsconv<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2526 #if(CXSC_INDEX_CHECK) 2527 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2531 {
return _mmsconv<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2533 #if(CXSC_INDEX_CHECK) 2534 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2538 {
return _mmsconv<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2540 #if(CXSC_INDEX_CHECK) 2541 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2545 {
return _msmsconv<rmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2547 #if(CXSC_INDEX_CHECK) 2548 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2552 {
return _msmsconv<rmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2554 #if(CXSC_INDEX_CHECK) 2555 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2559 {
return _mmconvassign(m1,m2); }
2561 #if(CXSC_INDEX_CHECK) 2562 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2566 {
return _mmsconvassign(m1,ms); }
2568 #if(CXSC_INDEX_CHECK) 2569 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2573 {
return _msmconvassign(*
this,m1); }
2575 #if(CXSC_INDEX_CHECK) 2576 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2580 {
return _msmsconvassign(*
this,ms2); }
2582 #if(CXSC_INDEX_CHECK) 2583 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2587 {
return _mmsect<rmatrix,cimatrix,cimatrix>(m1,m2); }
2589 #if(CXSC_INDEX_CHECK) 2590 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2594 {
return _mmsect<rmatrix,cimatrix,cimatrix>(m2,m1); }
2596 #if(CXSC_INDEX_CHECK) 2597 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2601 {
return _mmssect<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2603 #if(CXSC_INDEX_CHECK) 2604 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2608 {
return _mmssect<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2610 #if(CXSC_INDEX_CHECK) 2611 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2615 {
return _mmssect<cimatrix,rmatrix_slice,cimatrix>(m,ms); }
2617 #if(CXSC_INDEX_CHECK) 2618 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2622 {
return _mmssect<rmatrix,cimatrix_slice,cimatrix>(m,ms); }
2624 #if(CXSC_INDEX_CHECK) 2625 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2629 {
return _msmssect<rmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2631 #if(CXSC_INDEX_CHECK) 2632 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2636 {
return _msmssect<rmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2638 #if(CXSC_INDEX_CHECK) 2639 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2643 {
return _mmsectassign(m1,m2); }
2645 #if(CXSC_INDEX_CHECK) 2646 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2650 {
return _mmssectassign(m1,ms); }
2652 #if(CXSC_INDEX_CHECK) 2653 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2657 {
return _msmsectassign(*
this,m1); }
2659 #if(CXSC_INDEX_CHECK) 2660 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2664 {
return _msmssectassign(*
this,ms2); }
2667 #if(CXSC_INDEX_CHECK) 2668 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2672 {
return _mmplus<cmatrix,cimatrix,cimatrix>(m1,m2); }
2674 #if(CXSC_INDEX_CHECK) 2675 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2679 {
return _mmplus<cmatrix,cimatrix,cimatrix>(m2,m1); }
2681 #if(CXSC_INDEX_CHECK) 2682 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2686 {
return _mmsplus<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2688 #if(CXSC_INDEX_CHECK) 2689 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2693 {
return _mmsplus<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2695 #if(CXSC_INDEX_CHECK) 2696 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2700 {
return _mmsplus<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2702 #if(CXSC_INDEX_CHECK) 2703 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2707 {
return _mmsplus<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2709 #if(CXSC_INDEX_CHECK) 2710 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2714 {
return _msmsplus<cmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2716 #if(CXSC_INDEX_CHECK) 2717 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2721 {
return _msmsplus<cmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2723 #if(CXSC_INDEX_CHECK) 2724 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2728 {
return _mmplusassign(m1,m2); }
2730 #if(CXSC_INDEX_CHECK) 2731 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2735 {
return _mmsplusassign(m1,ms); }
2737 #if(CXSC_INDEX_CHECK) 2738 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2742 {
return _msmplusassign(*
this,m1); }
2744 #if(CXSC_INDEX_CHECK) 2745 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2749 {
return _msmsplusassign(*
this,ms2); }
2751 #if(CXSC_INDEX_CHECK) 2752 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2756 {
return _mmminus<cmatrix,cimatrix,cimatrix>(m1,m2); }
2758 #if(CXSC_INDEX_CHECK) 2759 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2763 {
return _mmminus<cimatrix,cmatrix,cimatrix>(m1,m2); }
2765 #if(CXSC_INDEX_CHECK) 2766 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2770 {
return _mmsminus<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2772 #if(CXSC_INDEX_CHECK) 2773 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2777 {
return _mmsminus<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2779 #if(CXSC_INDEX_CHECK) 2780 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2784 {
return _msmminus<cmatrix_slice,cimatrix,cimatrix>(ms,m); }
2786 #if(CXSC_INDEX_CHECK) 2787 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2791 {
return _msmminus<cimatrix_slice,cmatrix,cimatrix>(ms,m); }
2793 #if(CXSC_INDEX_CHECK) 2794 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2798 {
return _msmsminus<cmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2800 #if(CXSC_INDEX_CHECK) 2801 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2805 {
return _msmsminus<cimatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
2807 #if(CXSC_INDEX_CHECK) 2808 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2812 {
return _mmminusassign(m1,m2); }
2814 #if(CXSC_INDEX_CHECK) 2815 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2819 {
return _mmsminusassign(m1,ms); }
2821 #if(CXSC_INDEX_CHECK) 2822 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2826 {
return _msmminusassign(*
this,m1); }
2828 #if(CXSC_INDEX_CHECK) 2829 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2833 {
return _msmsminusassign(*
this,ms2); }
2835 #if(CXSC_INDEX_CHECK) 2836 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2840 {
return _mmcimult<cmatrix,cimatrix,cimatrix>(m1,m2); }
2842 #if(CXSC_INDEX_CHECK) 2843 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2847 {
return _mmcimult<cimatrix,cmatrix,cimatrix>(m1,m2); }
2849 #if(CXSC_INDEX_CHECK) 2850 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2854 {
return _mmscimult<cmatrix,cimatrix_slice,cimatrix>(m1,ms); }
2856 #if(CXSC_INDEX_CHECK) 2857 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2861 {
return _mmscimult<cimatrix,cmatrix_slice,cimatrix>(m1,ms); }
2863 #if(CXSC_INDEX_CHECK) 2864 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2868 {
return _msmcimult<cmatrix_slice,cimatrix,cimatrix>(ms,m1); }
2870 #if(CXSC_INDEX_CHECK) 2871 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2875 {
return _msmcimult<cimatrix_slice,cmatrix,cimatrix>(ms,m1); }
2877 #if(CXSC_INDEX_CHECK) 2878 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2882 {
return _msmscimult<cmatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
2884 #if(CXSC_INDEX_CHECK) 2885 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2889 {
return _msmscimult<cimatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
2891 #if(CXSC_INDEX_CHECK) 2892 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2896 {
return _mmcimultassign<cimatrix,cmatrix,cinterval>(m1,m2); }
2898 #if(CXSC_INDEX_CHECK) 2899 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2903 {
return _mmscimultassign<cimatrix,cmatrix_slice,cinterval>(m1,ms); }
2905 #if(CXSC_INDEX_CHECK) 2906 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2910 {
return _mmconv<cmatrix,cimatrix,cimatrix>(m1,m2); }
2912 #if(CXSC_INDEX_CHECK) 2913 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2917 {
return _mmconv<cmatrix,cimatrix,cimatrix>(m2,m1); }
2919 #if(CXSC_INDEX_CHECK) 2920 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2924 {
return _mmsconv<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2926 #if(CXSC_INDEX_CHECK) 2927 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2931 {
return _mmsconv<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2933 #if(CXSC_INDEX_CHECK) 2934 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2938 {
return _mmsconv<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
2940 #if(CXSC_INDEX_CHECK) 2941 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2945 {
return _mmsconv<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
2947 #if(CXSC_INDEX_CHECK) 2948 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2952 {
return _msmsconv<cmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
2954 #if(CXSC_INDEX_CHECK) 2955 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2959 {
return _msmsconv<cmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
2961 #if(CXSC_INDEX_CHECK) 2962 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2966 {
return _mmconvassign(m1,m2); }
2968 #if(CXSC_INDEX_CHECK) 2969 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2973 {
return _mmsconvassign(m1,ms); }
2975 #if(CXSC_INDEX_CHECK) 2976 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2980 {
return _msmconvassign(*
this,m1); }
2982 #if(CXSC_INDEX_CHECK) 2983 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2987 {
return _msmsconvassign(*
this,ms2); }
2989 #if(CXSC_INDEX_CHECK) 2990 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
2994 {
return _mmsect<cmatrix,cimatrix,cimatrix>(m1,m2); }
2996 #if(CXSC_INDEX_CHECK) 2997 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3001 {
return _mmsect<cmatrix,cimatrix,cimatrix>(m2,m1); }
3003 #if(CXSC_INDEX_CHECK) 3004 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3008 {
return _mmssect<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
3010 #if(CXSC_INDEX_CHECK) 3011 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3015 {
return _mmssect<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
3017 #if(CXSC_INDEX_CHECK) 3018 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3022 {
return _mmssect<cimatrix,cmatrix_slice,cimatrix>(m,ms); }
3024 #if(CXSC_INDEX_CHECK) 3025 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3029 {
return _mmssect<cmatrix,cimatrix_slice,cimatrix>(m,ms); }
3031 #if(CXSC_INDEX_CHECK) 3032 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3036 {
return _msmssect<cmatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3038 #if(CXSC_INDEX_CHECK) 3039 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3043 {
return _msmssect<cmatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3045 #if(CXSC_INDEX_CHECK) 3046 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3050 {
return _mmsectassign(m1,m2); }
3052 #if(CXSC_INDEX_CHECK) 3053 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3057 {
return _mmssectassign(m1,ms); }
3059 #if(CXSC_INDEX_CHECK) 3060 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3064 {
return _msmsectassign(*
this,m1); }
3066 #if(CXSC_INDEX_CHECK) 3067 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3071 {
return _msmssectassign(*
this,ms2); }
3074 #if(CXSC_INDEX_CHECK) 3075 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3079 {
return _mmplus<imatrix,cimatrix,cimatrix>(m1,m2); }
3081 #if(CXSC_INDEX_CHECK) 3082 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3086 {
return _mmplus<imatrix,cimatrix,cimatrix>(m2,m1); }
3088 #if(CXSC_INDEX_CHECK) 3089 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3093 {
return _mmsplus<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3095 #if(CXSC_INDEX_CHECK) 3096 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3100 {
return _mmsplus<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3102 #if(CXSC_INDEX_CHECK) 3103 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3107 {
return _mmsplus<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3109 #if(CXSC_INDEX_CHECK) 3110 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3114 {
return _mmsplus<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3116 #if(CXSC_INDEX_CHECK) 3117 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3121 {
return _msmsplus<imatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3123 #if(CXSC_INDEX_CHECK) 3124 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3128 {
return _msmsplus<imatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3130 #if(CXSC_INDEX_CHECK) 3131 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3135 {
return _mmplusassign(m1,m2); }
3137 #if(CXSC_INDEX_CHECK) 3138 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3142 {
return _mmsplusassign(m1,ms); }
3144 #if(CXSC_INDEX_CHECK) 3145 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3149 {
return _msmplusassign(*
this,m1); }
3151 #if(CXSC_INDEX_CHECK) 3152 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3156 {
return _msmsplusassign(*
this,ms2); }
3158 #if(CXSC_INDEX_CHECK) 3159 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3163 {
return _mmminus<imatrix,cimatrix,cimatrix>(m1,m2); }
3165 #if(CXSC_INDEX_CHECK) 3166 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3170 {
return _mmminus<cimatrix,imatrix,cimatrix>(m1,m2); }
3172 #if(CXSC_INDEX_CHECK) 3173 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3177 {
return _mmsminus<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3179 #if(CXSC_INDEX_CHECK) 3180 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3184 {
return _mmsminus<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3186 #if(CXSC_INDEX_CHECK) 3187 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3191 {
return _msmminus<imatrix_slice,cimatrix,cimatrix>(ms,m); }
3193 #if(CXSC_INDEX_CHECK) 3194 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3198 {
return _msmminus<cimatrix_slice,imatrix,cimatrix>(ms,m); }
3200 #if(CXSC_INDEX_CHECK) 3201 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3205 {
return _msmsminus<imatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
3207 #if(CXSC_INDEX_CHECK) 3208 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3212 {
return _msmsminus<cimatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3214 #if(CXSC_INDEX_CHECK) 3215 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3219 {
return _mmminusassign(m1,m2); }
3221 #if(CXSC_INDEX_CHECK) 3222 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3226 {
return _mmsminusassign(m1,ms); }
3228 #if(CXSC_INDEX_CHECK) 3229 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3233 {
return _msmminusassign(*
this,m1); }
3235 #if(CXSC_INDEX_CHECK) 3236 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3240 {
return _msmsminusassign(*
this,ms2); }
3242 #if(CXSC_INDEX_CHECK) 3243 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3247 {
return _mmcimult<imatrix,cimatrix,cimatrix>(m1,m2); }
3249 #if(CXSC_INDEX_CHECK) 3250 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3254 {
return _mmcimult<cimatrix,imatrix,cimatrix>(m1,m2); }
3256 #if(CXSC_INDEX_CHECK) 3257 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3261 {
return _mmscimult<imatrix,cimatrix_slice,cimatrix>(m1,ms); }
3263 #if(CXSC_INDEX_CHECK) 3264 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3268 {
return _mmscimult<cimatrix,imatrix_slice,cimatrix>(m1,ms); }
3270 #if(CXSC_INDEX_CHECK) 3271 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3275 {
return _msmcimult<imatrix_slice,cimatrix,cimatrix>(ms,m1); }
3277 #if(CXSC_INDEX_CHECK) 3278 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3282 {
return _msmcimult<cimatrix_slice,imatrix,cimatrix>(ms,m1); }
3284 #if(CXSC_INDEX_CHECK) 3285 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3289 {
return _msmscimult<imatrix_slice,cimatrix_slice,cimatrix>(ms1,ms2); }
3291 #if(CXSC_INDEX_CHECK) 3292 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3296 {
return _msmscimult<cimatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3298 #if(CXSC_INDEX_CHECK) 3299 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3303 {
return _mmcimultassign<cimatrix,imatrix,cinterval>(m1,m2); }
3305 #if(CXSC_INDEX_CHECK) 3306 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3310 {
return _mmscimultassign<cimatrix,imatrix_slice,cinterval>(m1,ms); }
3312 #if(CXSC_INDEX_CHECK) 3313 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3317 {
return _mmconv<imatrix,cimatrix,cimatrix>(m1,m2); }
3319 #if(CXSC_INDEX_CHECK) 3320 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3324 {
return _mmconv<imatrix,cimatrix,cimatrix>(m2,m1); }
3326 #if(CXSC_INDEX_CHECK) 3327 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3331 {
return _mmsconv<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3333 #if(CXSC_INDEX_CHECK) 3334 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3338 {
return _mmsconv<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3340 #if(CXSC_INDEX_CHECK) 3341 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3345 {
return _mmsconv<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3347 #if(CXSC_INDEX_CHECK) 3348 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3352 {
return _mmsconv<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3354 #if(CXSC_INDEX_CHECK) 3355 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3359 {
return _msmsconv<imatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3361 #if(CXSC_INDEX_CHECK) 3362 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3366 {
return _msmsconv<imatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3368 #if(CXSC_INDEX_CHECK) 3369 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3373 {
return _mmconvassign(m1,m2); }
3375 #if(CXSC_INDEX_CHECK) 3376 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3380 {
return _mmsconvassign(m1,ms); }
3382 #if(CXSC_INDEX_CHECK) 3383 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3387 {
return _msmconvassign(*
this,m1); }
3389 #if(CXSC_INDEX_CHECK) 3390 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3394 {
return _msmsconvassign(*
this,ms2); }
3396 #if(CXSC_INDEX_CHECK) 3397 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3401 {
return _mmsect<imatrix,cimatrix,cimatrix>(m1,m2); }
3403 #if(CXSC_INDEX_CHECK) 3404 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3408 {
return _mmsect<imatrix,cimatrix,cimatrix>(m2,m1); }
3410 #if(CXSC_INDEX_CHECK) 3411 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3415 {
return _mmssect<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3417 #if(CXSC_INDEX_CHECK) 3418 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3422 {
return _mmssect<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3424 #if(CXSC_INDEX_CHECK) 3425 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3429 {
return _mmssect<cimatrix,imatrix_slice,cimatrix>(m,ms); }
3431 #if(CXSC_INDEX_CHECK) 3432 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3436 {
return _mmssect<imatrix,cimatrix_slice,cimatrix>(m,ms); }
3438 #if(CXSC_INDEX_CHECK) 3439 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3443 {
return _msmssect<imatrix_slice,cimatrix_slice,cimatrix>(m1,m2); }
3445 #if(CXSC_INDEX_CHECK) 3446 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3450 {
return _msmssect<imatrix_slice,cimatrix_slice,cimatrix>(m2,m1); }
3452 #if(CXSC_INDEX_CHECK) 3453 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3457 {
return _mmsectassign(m1,m2); }
3459 #if(CXSC_INDEX_CHECK) 3460 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3464 {
return _mmssectassign(m1,ms); }
3466 #if(CXSC_INDEX_CHECK) 3467 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3471 {
return _msmsectassign(*
this,m1); }
3473 #if(CXSC_INDEX_CHECK) 3474 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3478 {
return _msmssectassign(*
this,ms2); }
3481 #if(CXSC_INDEX_CHECK) 3482 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3486 {
return _mmplus<cmatrix,imatrix,cimatrix>(m1,m2); }
3488 #if(CXSC_INDEX_CHECK) 3489 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3493 {
return _mmplus<cmatrix,imatrix,cimatrix>(m2,m1); }
3495 #if(CXSC_INDEX_CHECK) 3496 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3500 {
return _mmsplus<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3502 #if(CXSC_INDEX_CHECK) 3503 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3507 {
return _mmsplus<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3509 #if(CXSC_INDEX_CHECK) 3510 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3514 {
return _mmsplus<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3516 #if(CXSC_INDEX_CHECK) 3517 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3521 {
return _mmsplus<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3523 #if(CXSC_INDEX_CHECK) 3524 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3528 {
return _msmsplus<cmatrix_slice,imatrix_slice,cimatrix>(m1,m2); }
3530 #if(CXSC_INDEX_CHECK) 3531 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3535 {
return _msmsplus<cmatrix_slice,imatrix_slice,cimatrix>(m2,m1); }
3537 #if(CXSC_INDEX_CHECK) 3538 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3542 {
return _mmminus<cmatrix,imatrix,cimatrix>(m1,m2); }
3544 #if(CXSC_INDEX_CHECK) 3545 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3549 {
return _mmminus<imatrix,cmatrix,cimatrix>(m1,m2); }
3551 #if(CXSC_INDEX_CHECK) 3552 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3556 {
return _mmsminus<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3558 #if(CXSC_INDEX_CHECK) 3559 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3563 {
return _mmsminus<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3565 #if(CXSC_INDEX_CHECK) 3566 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3570 {
return _msmminus<cmatrix_slice,imatrix,cimatrix>(ms,m); }
3572 #if(CXSC_INDEX_CHECK) 3573 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3577 {
return _msmminus<imatrix_slice,cmatrix,cimatrix>(ms,m); }
3579 #if(CXSC_INDEX_CHECK) 3580 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3584 {
return _msmsminus<cmatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3586 #if(CXSC_INDEX_CHECK) 3587 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3591 {
return _msmsminus<imatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
3593 #if(CXSC_INDEX_CHECK) 3594 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3598 {
return _mmcimult<cmatrix,imatrix,cimatrix>(m1,m2); }
3600 #if(CXSC_INDEX_CHECK) 3601 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3605 {
return _mmcimult<imatrix,cmatrix,cimatrix>(m1,m2); }
3607 #if(CXSC_INDEX_CHECK) 3608 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3612 {
return _mmscimult<cmatrix,imatrix_slice,cimatrix>(m1,ms); }
3614 #if(CXSC_INDEX_CHECK) 3615 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3619 {
return _mmscimult<imatrix,cmatrix_slice,cimatrix>(m1,ms); }
3621 #if(CXSC_INDEX_CHECK) 3622 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3626 {
return _msmcimult<cmatrix_slice,imatrix,cimatrix>(ms,m1); }
3628 #if(CXSC_INDEX_CHECK) 3629 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3633 {
return _msmcimult<imatrix_slice,cmatrix,cimatrix>(ms,m1); }
3635 #if(CXSC_INDEX_CHECK) 3636 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3640 {
return _msmscimult<cmatrix_slice,imatrix_slice,cimatrix>(ms1,ms2); }
3642 #if(CXSC_INDEX_CHECK) 3643 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3647 {
return _msmscimult<imatrix_slice,cmatrix_slice,cimatrix>(ms1,ms2); }
3649 #if(CXSC_INDEX_CHECK) 3650 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3654 {
return _mmconv<cmatrix,imatrix,cimatrix>(m1,m2); }
3656 #if(CXSC_INDEX_CHECK) 3657 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3661 {
return _mmconv<cmatrix,imatrix,cimatrix>(m2,m1); }
3663 #if(CXSC_INDEX_CHECK) 3664 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3668 {
return _mmsconv<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3670 #if(CXSC_INDEX_CHECK) 3671 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3675 {
return _mmsconv<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3677 #if(CXSC_INDEX_CHECK) 3678 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3682 {
return _mmsconv<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3684 #if(CXSC_INDEX_CHECK) 3685 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3689 {
return _mmsconv<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3691 #if(CXSC_INDEX_CHECK) 3692 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3696 {
return _msmsconv<cmatrix_slice,imatrix_slice,cimatrix>(m1,m2); }
3698 #if(CXSC_INDEX_CHECK) 3699 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3703 {
return _msmsconv<cmatrix_slice,imatrix_slice,cimatrix>(m2,m1); }
3705 #if(CXSC_INDEX_CHECK) 3706 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3710 {
return _mmsect<cmatrix,imatrix,cimatrix>(m1,m2); }
3712 #if(CXSC_INDEX_CHECK) 3713 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3717 {
return _mmsect<cmatrix,imatrix,cimatrix>(m2,m1); }
3719 #if(CXSC_INDEX_CHECK) 3720 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3724 {
return _mmssect<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3726 #if(CXSC_INDEX_CHECK) 3727 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3731 {
return _mmssect<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3733 #if(CXSC_INDEX_CHECK) 3734 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3738 {
return _mmssect<imatrix,cmatrix_slice,cimatrix>(m,ms); }
3740 #if(CXSC_INDEX_CHECK) 3741 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3745 {
return _mmssect<cmatrix,imatrix_slice,cimatrix>(m,ms); }
3747 #if(CXSC_INDEX_CHECK) 3748 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3752 {
return _msmssect<cmatrix_slice,imatrix_slice,cimatrix>(m1,m2); }
3754 #if(CXSC_INDEX_CHECK) 3755 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM)
3759 {
return _msmssect<cmatrix_slice,imatrix_slice,cimatrix>(m2,m1); }
3763 #if(CXSC_INDEX_CHECK) 3764 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3768 {
return _mmconv<rmatrix,cmatrix,cimatrix>(rv1,rv2); }
3770 #if(CXSC_INDEX_CHECK) 3771 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3775 {
return _mmconv<rmatrix,cmatrix,cimatrix>(rv2,rv1); }
3777 #if(CXSC_INDEX_CHECK) 3778 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3782 {
return _mmsconv<cmatrix,rmatrix_slice,cimatrix>(rv,sl); }
3784 #if(CXSC_INDEX_CHECK) 3785 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3789 {
return _mmsconv<cmatrix,rmatrix_slice,cimatrix>(rv,sl); }
3791 #if(CXSC_INDEX_CHECK) 3792 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3796 {
return _mmsconv<rmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3798 #if(CXSC_INDEX_CHECK) 3799 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3803 {
return _mmsconv<rmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3805 #if(CXSC_INDEX_CHECK) 3806 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3810 {
return _msmsconv<rmatrix_slice,cmatrix_slice,cimatrix>(sl2,sl1); }
3812 #if(CXSC_INDEX_CHECK) 3813 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3817 {
return _msmsconv<rmatrix_slice,cmatrix_slice,cimatrix>(sl1,sl2); }
3821 #if(CXSC_INDEX_CHECK) 3822 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3826 {
return _mmconv<cmatrix,cmatrix,cimatrix>(rv1,rv2); }
3828 #if(CXSC_INDEX_CHECK) 3829 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3833 {
return _mmsconv<cmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3835 #if(CXSC_INDEX_CHECK) 3836 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3840 {
return _mmsconv<cmatrix,cmatrix_slice,cimatrix>(rv,sl); }
3842 #if(CXSC_INDEX_CHECK) 3843 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>)
3847 {
return _msmsconv<cmatrix_slice,cmatrix_slice,cimatrix>(sl1,sl2); }
3849 INLINE
bool operator ==(
const cimatrix &m1,
const cimatrix &m2)
throw() {
return _mmeq(m1,m2); }
3850 INLINE
bool operator !=(
const cimatrix &m1,
const cimatrix &m2)
throw() {
return _mmneq(m1,m2); }
3851 INLINE
bool operator <(
const cimatrix &m1,
const cimatrix &m2)
throw() {
return _mmless(m1,m2); }
3852 INLINE
bool operator <=(
const cimatrix &m1,
const cimatrix &m2)
throw() {
return _mmleq(m1,m2); }
3853 INLINE
bool operator >(
const cimatrix &m1,
const cimatrix &m2)
throw() {
return _mmless(m2,m1); }
3854 INLINE
bool operator >=(
const cimatrix &m1,
const cimatrix &m2)
throw() {
return _mmleq(m2,m1); }
3867 INLINE
bool operator !(
const cimatrix &ms)
throw() {
return _mnot(ms); }
3869 INLINE std::ostream &operator <<(std::ostream &s,
const cimatrix &r)
throw() {
return _mout(s,r); }
3870 INLINE std::ostream &operator <<(std::ostream &s,
const cimatrix_slice &r)
throw() {
return _msout(s,r); }
3871 INLINE std::istream &operator >>(std::istream &s,
cimatrix &r)
throw() {
return _min(s,r); }
3872 INLINE std::istream &operator >>(std::istream &s,
cimatrix_slice &r)
throw() {
return _msin(s,r); }
3877 for(
int i=0 ; i<
ColLen(A) ; i++)
3878 for(
int j=0 ; j<
RowLen(A) ; j++)
3879 A[i+
Lb(A,1)][j+
Lb(A,2)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)][q[j+
Lb(q)]+
Lb(A,2)];
3886 for(
int i=0 ; i<
ColLen(A) ; i++)
3887 A[i+
Lb(A,1)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)];
3901 return (*
this)(p,q);
friend rmatrix InfIm(const cimatrix &v)
Returns the infimum of imaginary part of the matrix.
cinterval(void)
Constructor of class cinterval.
The Data Type rmatrix_slice.
cimatrix & operator=(const cinterval &r)
Implementation of standard assigning operator.
cimatrix_slice & operator/=(const cinterval &c)
Implementation of division and allocation operation.
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
cimatrix_subv operator[](const int &i)
Operator for accessing a single row of the matrix.
friend rmatrix InfRe(const cimatrix &v)
Returns the infimum of real part of the matrix.
The Data Type imatrix_subv.
cinterval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
cimatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
friend rmatrix SupIm(const cimatrix &v)
Returns the supremum of imaginary part of the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
The Data Type cimatrix_subv.
cimatrix & operator-=(const scimatrix &m1)
Implementation of substraction and allocation operation.
The Data Type cimatrix_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.
cimatrix & operator()()
Operator for accessing the whole matrix.
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
The Scalar Type interval.
cimatrix_subv Col(cimatrix &m, const int &i)
Returns one column of the matrix as a vector.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
cimatrix & operator*=(const scimatrix &m1)
Implementation of multiplication and allocation operation.
cimatrix & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix_slice & operator=(const cimatrix &m)
Implementation of standard assigning operator.
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix_slice & operator-=(const cinterval &c)
Implementation of subtraction and allocation operation.
cimatrix_slice & operator+=(const cinterval &c)
Implementation of addition and allocation operation.
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
The Data Type ivector_slice.
cimatrix_subv & operator+=(const cinterval &c)
Implementation of addition and allocation operation.
cimatrix_subv & operator/=(const cinterval &c)
Implementation of division and allocation operation.
cimatrix()
Constructor of class cimatrix.
The Data Type imatrix_slice.
The Data Type rvector_slice.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
The Data Type rmatrix_subv.
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
The Scalar Type cinterval.
cimatrix_subv & operator()()
Operator for accessing the whole vector.
cimatrix_slice & operator()()
Operator for accessing the whole matrix.
void Resize(cimatrix &A)
Resizes the matrix.
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
The Data Type civector_slice.
int ColLen(const cimatrix &)
Returns the column dimension.
cimatrix_subv & operator-=(const cinterval &c)
Implementation of subtraction and allocation operation.
The Data Type cmatrix_subv.
cimatrix_subv Row(cimatrix &m, const int &i)
Returns one row of the matrix as a vector.
int RowLen(const cimatrix &)
Returns the row dimension.
The Data Type cmatrix_slice.
cimatrix _imatrix(const cimatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
civector_slice & operator*=(const cinterval &r)
Implementation of multiplication and allocation operation.
civector()
Constructor of class civector.
cimatrix_subv & operator*=(const cinterval &c)
Implementation of multiplication and allocation operation.
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
friend rmatrix SupRe(const cimatrix &v)
Returns the supremum of real part of the matrix.
cimatrix_slice & operator*=(const cinterval &c)
Implementation of multiplication and allocation operation.
The Data Type cvector_slice.
civector & operator=(const civector &rv)
Implementation of standard assigning operator.
civector & operator()()
Operator for accessing the whole vector.
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.