26 #ifndef _CXSC_IMATRIX_INL_INCLUDED 27 #define _CXSC_IMATRIX_INL_INCLUDED 31 INLINE
imatrix::imatrix() throw():dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
47 INLINE
imatrix::imatrix(
const imatrix &rm)
throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
50 for(
int i=0;i<xsize*ysize;i++)
54 INLINE
imatrix::imatrix(
const rmatrix &rm)
throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
57 for(
int i=0;i<xsize*ysize;i++)
63 throw(ERROR_IMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
65 throw():lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
69 if((n<0)||(m<0)) cxscthrow(ERROR_IMATRIX_WRONG_BOUNDARIES(
"imatrix::imatrix(const int &m, const int &n)"));
76 throw(ERROR_IMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
78 throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
82 if((m2<m1)||(n2<n1)) cxscthrow(ERROR_IMATRIX_WRONG_BOUNDARIES(
"imatrix::imatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
90 for (
int i=0, j=v.start;i<v.size;i++,j+=v.offset)
97 for(
int i=0;i<v.size;i++)
104 for(
int i=0;i<v.size;i++)
111 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
118 for(
int i=0,j=v.start-v.l;i<v.size;i++,j++)
129 for (i=0;i<ysize;i++)
133 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
143 for (i=0;i<ysize;i++)
147 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
153 #if(CXSC_INDEX_CHECK) 154 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
164 #if(CXSC_INDEX_CHECK) 165 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
175 #if(CXSC_INDEX_CHECK) 176 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
186 #if(CXSC_INDEX_CHECK) 187 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
197 #if(CXSC_INDEX_CHECK) 198 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
203 #if(CXSC_INDEX_CHECK) 204 if((i<lb)||(i>ub)) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC(
"interval &imatrix_subv::operator [](const int &i) const"));
206 return dat[start+((i-lb)*offset)];
210 #if(CXSC_INDEX_CHECK) 211 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
216 #if(CXSC_INDEX_CHECK) 217 if((i<lb)||(i>ub)) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC(
"interval &imatrix_subv::operator [](const int &i)"));
219 return dat[start+((i-lb)*offset)];
224 #if(CXSC_INDEX_CHECK) 225 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
230 #if(CXSC_INDEX_CHECK) 231 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT(
"imatrix_subv imatrix::operator [](const int &i)"));
233 return imatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
237 #if(CXSC_INDEX_CHECK) 238 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
243 #if(CXSC_INDEX_CHECK) 244 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT(
"imatrix_subv imatrix::operator [](const cxscmatrix_column &i)"));
246 return imatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
250 #if(CXSC_INDEX_CHECK) 251 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
256 #if(CXSC_INDEX_CHECK) 257 if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG(
"imatrix_slice imatrix::operator ()(const int &m, const int &n)"));
263 #if(CXSC_INDEX_CHECK) 264 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
269 #if(CXSC_INDEX_CHECK) 270 if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG(
"imatrix_slice imatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
276 #if(CXSC_INDEX_CHECK) 277 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
282 #if(CXSC_INDEX_CHECK) 283 if((i<start1)||(i>end1)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT(
"imatrix_subv imatrix_slice::operator [](const int &i)"));
285 return imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
289 #if(CXSC_INDEX_CHECK) 290 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
295 #if(CXSC_INDEX_CHECK) 296 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT(
"imatrix_subv imatrix_slice::operator [](const cxscmatrix_column &i)"));
298 return imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
302 #if(CXSC_INDEX_CHECK) 303 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
308 #if(CXSC_INDEX_CHECK) 309 if((i<start1)||(i>end1)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT(
"imatrix_subv imatrix_slice::operator [](const int &i)"));
311 return imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
315 #if(CXSC_INDEX_CHECK) 316 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
321 #if(CXSC_INDEX_CHECK) 322 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT(
"imatrix_subv imatrix_slice::operator [](const cxscmatrix_column &i)"));
324 return imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
329 #if(CXSC_INDEX_CHECK) 330 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
335 #if(CXSC_INDEX_CHECK) 336 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG(
"imatrix_slice imatrix_slice::operator ()(const int &m, const int &n)"));
342 #if(CXSC_INDEX_CHECK) 343 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
348 #if(CXSC_INDEX_CHECK) 349 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG(
"imatrix_slice imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
355 #if(CXSC_INDEX_CHECK) 356 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
361 #if(CXSC_INDEX_CHECK) 362 if(1<lb||i>ub) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG(
"imatrix_subv imatrix_subv::operator ()(const int &i)"));
364 return imatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
368 #if(CXSC_INDEX_CHECK) 369 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
374 #if(CXSC_INDEX_CHECK) 375 if(i1<lb||i2>ub) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG(
"imatrix_subv imatrix_subv::operator ()(const int &i1,const int &i2)"));
377 return imatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
383 #if(CXSC_INDEX_CHECK) 384 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
388 {
return _mvvassign(*
this,v); }
390 #if(CXSC_INDEX_CHECK) 391 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
395 {
return _mvvassign(*
this,
ivector(v)); }
399 #if(CXSC_INDEX_CHECK) 400 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
404 {
return _mvvassign(*
this,v); }
406 #if(CXSC_INDEX_CHECK) 407 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
411 {
return _mvvassign(*
this,
ivector(v)); }
426 INLINE imatrix::operator
void*()
throw() {
return _mvoid(*
this); }
429 #if(CXSC_INDEX_CHECK) 430 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
434 {
return _msmassign(*
this,m); }
436 #if(CXSC_INDEX_CHECK) 437 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
441 {
return _msmsassign(*
this,ms); }
444 #if(CXSC_INDEX_CHECK) 445 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
449 {
return _msmassign(*
this,
imatrix(v)); }
451 #if(CXSC_INDEX_CHECK) 452 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
458 #if(CXSC_INDEX_CHECK) 459 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
463 {
return _msmassign(*
this,m); }
465 #if(CXSC_INDEX_CHECK) 466 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
470 {
return _msmsassign(*
this,ms); }
473 #if(CXSC_INDEX_CHECK) 474 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
478 {
return _msmassign(*
this,
rmatrix(v)); }
480 #if(CXSC_INDEX_CHECK) 481 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
486 INLINE imatrix_slice::operator
void*()
throw() {
return _msvoid(*
this); }
498 for(
int i=
Lb(mv) ; i<=
Ub(mv) ; i++)
504 for(
int i=
Lb(mv) ; i<=
Ub(mv) ; i++)
513 #if(CXSC_INDEX_CHECK) 514 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
518 {
return _mvvsetinf(mv,rv); }
520 #if(CXSC_INDEX_CHECK) 521 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
525 {
return _mvvsetsup(mv,rv); }
527 #if(CXSC_INDEX_CHECK) 528 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
532 {
return _mvvusetinf(mv,rv); }
534 #if(CXSC_INDEX_CHECK) 535 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
539 {
return _mvvusetsup(mv,rv); }
549 #if(CXSC_INDEX_CHECK) 550 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
554 {
return _mvmvimult<imatrix_subv,imatrix_subv,interval>(rv1,rv2); }
556 #if(CXSC_INDEX_CHECK) 557 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
561 {
return _vmvimult<ivector,imatrix_subv,interval>(rv1,rv2); }
563 #if(CXSC_INDEX_CHECK) 564 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
568 {
return _vmvimult<ivector,imatrix_subv,interval>(rv2,rv1); }
570 #if(CXSC_INDEX_CHECK) 571 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
575 {
return _vmvimult<ivector,imatrix_subv,interval>(
ivector(sl),sv); }
577 #if(CXSC_INDEX_CHECK) 578 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
582 {
return _vmvimult<ivector,imatrix_subv,interval>(
ivector(vs),mv); }
584 #if(CXSC_INDEX_CHECK) 585 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
589 {
return _mvmvplus<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
591 #if(CXSC_INDEX_CHECK) 592 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
596 {
return _mvvplus<imatrix_subv,ivector,ivector>(rv1,rv2); }
598 #if(CXSC_INDEX_CHECK) 599 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
603 {
return _mvvplus<imatrix_subv,ivector,ivector>(rv2,rv1); }
605 #if(CXSC_INDEX_CHECK) 606 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
610 {
return _mvvplus<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
612 #if(CXSC_INDEX_CHECK) 613 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
617 {
return _mvvplus<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
619 #if(CXSC_INDEX_CHECK) 620 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
624 {
return _mvvplusassign(*
this,rv); }
626 #if(CXSC_INDEX_CHECK) 627 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
631 {
return _mvvplusassign(*
this,
ivector(rv)); }
633 #if(CXSC_INDEX_CHECK) 634 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
638 {
return _mvmvminus<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
640 #if(CXSC_INDEX_CHECK) 641 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
645 {
return _vmvminus<ivector,imatrix_subv,ivector>(rv1,rv2); }
647 #if(CXSC_INDEX_CHECK) 648 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
652 {
return _mvvminus<imatrix_subv,ivector,ivector>(rv1,rv2); }
654 #if(CXSC_INDEX_CHECK) 655 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
659 {
return _vmvminus<ivector,imatrix_subv,ivector>(
ivector(sl),mv); }
661 #if(CXSC_INDEX_CHECK) 662 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
666 {
return _mvvminus<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
668 #if(CXSC_INDEX_CHECK) 669 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
673 {
return _mvvminusassign(*
this,rv); }
675 #if(CXSC_INDEX_CHECK) 676 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
680 {
return _mvvminusassign(*
this,
ivector(rv)); }
682 #if(CXSC_INDEX_CHECK) 683 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
687 {
return _mvmvconv<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
689 #if(CXSC_INDEX_CHECK) 690 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
694 {
return _mvvconv<imatrix_subv,ivector,ivector>(rv1,rv2); }
696 #if(CXSC_INDEX_CHECK) 697 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
701 {
return _mvvconv<imatrix_subv,ivector,ivector>(rv2,rv1); }
703 #if(CXSC_INDEX_CHECK) 704 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
708 {
return _mvvconv<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
710 #if(CXSC_INDEX_CHECK) 711 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
715 {
return _mvvconv<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
717 #if(CXSC_INDEX_CHECK) 718 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
722 {
return _mvvconvassign(*
this,rv); }
724 #if(CXSC_INDEX_CHECK) 725 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
729 {
return _mvvconvassign(*
this,
ivector(rv)); }
731 #if(CXSC_INDEX_CHECK) 732 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
736 {
return _mvmvsect<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
738 #if(CXSC_INDEX_CHECK) 739 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
743 {
return _mvvsect<imatrix_subv,ivector,ivector>(rv1,rv2); }
745 #if(CXSC_INDEX_CHECK) 746 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
750 {
return _mvvsect<imatrix_subv,ivector,ivector>(rv2,rv1); }
752 #if(CXSC_INDEX_CHECK) 753 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
757 {
return _mvvsect<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
759 #if(CXSC_INDEX_CHECK) 760 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
764 {
return _mvvsect<imatrix_subv,ivector,ivector>(mv,
ivector(sl)); }
766 #if(CXSC_INDEX_CHECK) 767 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
771 {
return _mvvsectassign(*
this,rv); }
773 #if(CXSC_INDEX_CHECK) 774 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
778 {
return _mvvsectassign(*
this,
ivector(rv)); }
782 #if(CXSC_INDEX_CHECK) 783 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
787 {
return _mvvplusassign(*
this,rv); }
789 #if(CXSC_INDEX_CHECK) 790 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
794 {
return _mvvplusassign(*
this,
rvector(rv)); }
796 #if(CXSC_INDEX_CHECK) 797 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
801 {
return _mvvminusassign(*
this,rv); }
803 #if(CXSC_INDEX_CHECK) 804 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
808 {
return _mvvminusassign(*
this,
rvector(rv)); }
810 #if(CXSC_INDEX_CHECK) 811 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
815 {
return _mvvconvassign(*
this,rv); }
817 #if(CXSC_INDEX_CHECK) 818 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
822 {
return _mvvconvassign(*
this,
rvector(rv)); }
824 #if(CXSC_INDEX_CHECK) 825 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
829 {
return _mvvsectassign(*
this,rv); }
831 #if(CXSC_INDEX_CHECK) 832 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
836 {
return _mvvsectassign(*
this,
rvector(rv)); }
862 #if(CXSC_INDEX_CHECK) 863 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
867 {
return _mlb(rm,i); }
869 #if(CXSC_INDEX_CHECK) 870 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
874 {
return _mub(rm,i); }
876 #if(CXSC_INDEX_CHECK) 877 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
881 {
return _mslb(rm,i); }
883 #if(CXSC_INDEX_CHECK) 884 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
888 {
return _msub(rm,i); }
890 #if(CXSC_INDEX_CHECK) 891 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
895 {
return _msetlb(m,i,j); }
897 #if(CXSC_INDEX_CHECK) 898 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
902 {
return _msetub(m,i,j); }
905 {
return Ub(A,2)-
Lb(A,2)+1; }
908 {
return Ub(A,1)-
Lb(A,1)+1; }
911 {
return Ub(A,2)-
Lb(A,2)+1; }
914 {
return Ub(A,1)-
Lb(A,1)+1; }
918 #if(CXSC_INDEX_CHECK) 919 throw(ERROR_IMATRIX_WRONG_BOUNDARIES)
923 { _mresize<imatrix,interval>(A,m,n); }
924 INLINE
void Resize(
imatrix &A,
const int &m1,
const int &m2,
const int &n1,
const int &n2)
925 #if(CXSC_INDEX_CHECK) 926 throw(ERROR_IMATRIX_WRONG_BOUNDARIES)
930 { _mresize<imatrix,interval>(A,m1,m2,n1,n2); }
934 for(
int i=
Lb(m,1) ; i<=
Ub(m,1) ; i++)
935 for(
int j=
Lb(m,2) ; j<=
Ub(m,2) ; j++)
936 A[i][j] =
AbsMin(m[i][j]);
941 for(
int i=
Lb(m,1) ; i<=
Ub(m,1) ; i++)
942 for(
int j=
Lb(m,2) ; j<=
Ub(m,2) ; j++)
943 A[i][j] =
AbsMax(m[i][j]);
949 for(
int i=
Lb(m,1) ; i<=
Ub(m,1) ; i++)
950 for(
int j=
Lb(m,2) ; j<=
Ub(m,2) ; j++)
951 A[i][j] =
AbsMin(m[i][j]);
956 for(
int i=
Lb(m,1) ; i<=
Ub(m,1) ; i++)
957 for(
int j=
Lb(m,2) ; j<=
Ub(m,2) ; j++)
958 A[i][j] =
AbsMax(m[i][j]);
965 INLINE
rmatrix Inf(
const imatrix &m)
throw() {
return _minf<imatrix,rmatrix>(m); }
966 INLINE
rmatrix Sup(
const imatrix &m)
throw() {
return _msup<imatrix,rmatrix>(m); }
970 #if(CXSC_INDEX_CHECK) 971 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
975 {
return _mmsetinf<imatrix,rmatrix>(cm,rm); }
977 #if(CXSC_INDEX_CHECK) 978 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
982 {
return _msmsetinf<imatrix_slice,rmatrix>(cm,rm); }
984 #if(CXSC_INDEX_CHECK) 985 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
989 {
return _mmssetinf<imatrix,rmatrix_slice>(cm,rm); }
991 #if(CXSC_INDEX_CHECK) 992 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
996 {
return _msmssetinf<imatrix_slice,rmatrix_slice>(cm,rm); }
998 #if(CXSC_INDEX_CHECK) 999 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1003 {
return _mmsetsup<imatrix,rmatrix>(cm,rm); }
1005 #if(CXSC_INDEX_CHECK) 1006 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1010 {
return _msmsetsup<imatrix_slice,rmatrix>(cm,rm); }
1012 #if(CXSC_INDEX_CHECK) 1013 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1017 {
return _mmssetsup<imatrix,rmatrix_slice>(cm,rm); }
1019 #if(CXSC_INDEX_CHECK) 1020 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1024 {
return _msmssetsup<imatrix_slice,rmatrix_slice>(cm,rm); }
1026 #if(CXSC_INDEX_CHECK) 1027 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1031 {
return _mmusetinf<imatrix,rmatrix>(cm,rm); }
1033 #if(CXSC_INDEX_CHECK) 1034 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1038 {
return _msmusetinf<imatrix_slice,rmatrix>(cm,rm); }
1040 #if(CXSC_INDEX_CHECK) 1041 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1045 {
return _mmsusetinf<imatrix,rmatrix_slice>(cm,rm); }
1047 #if(CXSC_INDEX_CHECK) 1048 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1052 {
return _msmsusetinf<imatrix_slice,rmatrix_slice>(cm,rm); }
1054 #if(CXSC_INDEX_CHECK) 1055 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1059 {
return _mmusetsup<imatrix,rmatrix>(cm,rm); }
1061 #if(CXSC_INDEX_CHECK) 1062 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1066 {
return _msmusetsup<imatrix_slice,rmatrix>(cm,rm); }
1068 #if(CXSC_INDEX_CHECK) 1069 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1073 {
return _mmsusetsup<imatrix,rmatrix_slice>(cm,rm); }
1075 #if(CXSC_INDEX_CHECK) 1076 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1080 {
return _msmsusetsup<imatrix_slice,rmatrix_slice>(cm,rm); }
1082 #if(CXSC_INDEX_CHECK) 1083 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_IMATRIX_USE_OF_UNINITIALIZED_OBJ)
1087 { _smconstr(*
this,m); }
1095 #if(CXSC_INDEX_CHECK) 1096 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1100 {
return (*
this=*
this*m); }
1102 #if(CXSC_INDEX_CHECK) 1103 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1107 {
return (*
this=*
this*m); }
1119 #if(CXSC_INDEX_CHECK) 1120 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1124 {
return (*
this=*
this*m); }
1126 #if(CXSC_INDEX_CHECK) 1127 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1131 {
return (*
this=*
this*m); }
1146 #if(CXSC_INDEX_CHECK) 1147 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1151 { _vmconstr<ivector,imatrix,interval>(*
this,sl); }
1153 #if(CXSC_INDEX_CHECK) 1154 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1158 { _vmsconstr<ivector,imatrix_slice,interval>(*
this,sl); }
1160 #if(CXSC_INDEX_CHECK) 1161 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1165 {
return _vmassign<ivector,imatrix,interval>(*
this,m); }
1167 #if(CXSC_INDEX_CHECK) 1168 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1172 {
return _vmassign<ivector,imatrix,interval>(*
this,
imatrix(m)); }
1174 #if(CXSC_INDEX_CHECK) 1175 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1181 #if(CXSC_INDEX_CHECK) 1182 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1186 {
return _mvvassign(*
this,
ivector(m)); }
1188 #if(CXSC_INDEX_CHECK) 1189 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1195 #if(CXSC_INDEX_CHECK) 1196 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1200 {
return _mvimult<imatrix,ivector,ivector>(m,v); }
1202 #if(CXSC_INDEX_CHECK) 1203 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1207 {
return _msvimult<imatrix_slice,ivector,ivector>(ms,v); }
1209 #if(CXSC_INDEX_CHECK) 1210 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1214 {
return _vmimult<ivector,imatrix,ivector>(v,m); }
1216 #if(CXSC_INDEX_CHECK) 1217 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1221 {
return _vmsimult<ivector,imatrix_slice,ivector>(v,ms); }
1223 #if(CXSC_INDEX_CHECK) 1224 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1228 {
return _vmimultassign<ivector,imatrix,interval>(v,m); }
1230 #if(CXSC_INDEX_CHECK) 1231 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1235 {
return _vmsimultassign<ivector,imatrix_slice,interval>(v,ms); }
1237 #if(CXSC_INDEX_CHECK) 1238 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1242 {
return _vsmimultassign<ivector_slice,imatrix,interval>(*
this,m); }
1244 #if(CXSC_INDEX_CHECK) 1245 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1249 {
return _vmimult<ivector,imatrix,ivector>(
ivector(v),m); }
1251 #if(CXSC_INDEX_CHECK) 1252 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1256 {
return _vmsimult<ivector,imatrix_slice,ivector>(
ivector(v),m); }
1258 #if(CXSC_INDEX_CHECK) 1259 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1263 {
return _mvvassign(*
this,
rvector(m)); }
1265 #if(CXSC_INDEX_CHECK) 1266 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
1272 #if(CXSC_INDEX_CHECK) 1273 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1277 {
return _vmimult<rvector,imatrix,ivector>(v,m); }
1279 #if(CXSC_INDEX_CHECK) 1280 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1284 {
return _vmsimult<rvector,imatrix_slice,ivector>(v,ms); }
1286 #if(CXSC_INDEX_CHECK) 1287 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1291 {
return _vmimult<ivector,imatrix,ivector>(
ivector(v),m); }
1293 #if(CXSC_INDEX_CHECK) 1294 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1298 {
return _mvimult<imatrix,rvector,ivector>(m,v); }
1300 #if(CXSC_INDEX_CHECK) 1301 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1305 {
return _msvimult<imatrix_slice,rvector,ivector>(ms,v); }
1311 #if(CXSC_INDEX_CHECK) 1312 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1316 {
return _mmplus<imatrix,imatrix,imatrix>(m1,m2); }
1318 #if(CXSC_INDEX_CHECK) 1319 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1323 {
return _mmsplus<imatrix,imatrix_slice,imatrix>(m,ms); }
1325 #if(CXSC_INDEX_CHECK) 1326 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1330 {
return _mmsplus<imatrix,imatrix_slice,imatrix>(m,ms); }
1332 #if(CXSC_INDEX_CHECK) 1333 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1337 {
return _msmsplus<imatrix_slice,imatrix_slice,imatrix>(m1,m2); }
1339 #if(CXSC_INDEX_CHECK) 1340 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1344 {
return _mmplusassign(m1,m2); }
1346 #if(CXSC_INDEX_CHECK) 1347 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1351 {
return _mmsplusassign(m1,ms); }
1353 #if(CXSC_INDEX_CHECK) 1354 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1358 {
return _msmplusassign(*
this,m1); }
1360 #if(CXSC_INDEX_CHECK) 1361 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1365 {
return _msmsplusassign(*
this,ms2); }
1369 #if(CXSC_INDEX_CHECK) 1370 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1374 {
return _mmminus<imatrix,imatrix,imatrix>(m1,m2); }
1376 #if(CXSC_INDEX_CHECK) 1377 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1381 {
return _mmsminus<imatrix,imatrix_slice,imatrix>(m,ms); }
1383 #if(CXSC_INDEX_CHECK) 1384 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1388 {
return _msmminus<imatrix_slice,imatrix,imatrix>(ms,m); }
1390 #if(CXSC_INDEX_CHECK) 1391 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1395 {
return _msmsminus<imatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
1397 #if(CXSC_INDEX_CHECK) 1398 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1402 {
return _mmminusassign(m1,m2); }
1404 #if(CXSC_INDEX_CHECK) 1405 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1409 {
return _mmsminusassign(m1,ms); }
1411 #if(CXSC_INDEX_CHECK) 1412 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1416 {
return _msmminusassign(*
this,m1); }
1418 #if(CXSC_INDEX_CHECK) 1419 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1423 {
return _msmsminusassign(*
this,ms2); }
1425 #if(CXSC_INDEX_CHECK) 1426 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1430 {
return _mmimult<imatrix,imatrix,imatrix>(m1,m2); }
1432 #if(CXSC_INDEX_CHECK) 1433 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1437 {
return _mmsimult<imatrix,imatrix_slice,imatrix>(m1,ms); }
1439 #if(CXSC_INDEX_CHECK) 1440 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1444 {
return _msmimult<imatrix_slice,imatrix,imatrix>(ms,m1); }
1446 #if(CXSC_INDEX_CHECK) 1447 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1451 {
return _msmsimult<imatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
1453 #if(CXSC_INDEX_CHECK) 1454 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1458 {
return _mmimultassign<imatrix,imatrix,interval>(m1,m2); }
1460 #if(CXSC_INDEX_CHECK) 1461 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1465 {
return _mmsimultassign<imatrix,imatrix_slice,interval>(m1,ms); }
1467 #if(CXSC_INDEX_CHECK) 1468 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1472 {
return _mmconv<imatrix,imatrix,imatrix>(m1,m2); }
1474 #if(CXSC_INDEX_CHECK) 1475 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1479 {
return _mmsconv<imatrix,imatrix_slice,imatrix>(m,ms); }
1481 #if(CXSC_INDEX_CHECK) 1482 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1486 {
return _mmsconv<imatrix,imatrix_slice,imatrix>(m,ms); }
1488 #if(CXSC_INDEX_CHECK) 1489 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1493 {
return _msmsconv<imatrix_slice,imatrix_slice,imatrix>(m1,m2); }
1495 #if(CXSC_INDEX_CHECK) 1496 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1500 {
return _mmconvassign(m1,m2); }
1502 #if(CXSC_INDEX_CHECK) 1503 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1507 {
return _mmsconvassign(m1,ms); }
1509 #if(CXSC_INDEX_CHECK) 1510 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1514 {
return _msmconvassign(*
this,m1); }
1516 #if(CXSC_INDEX_CHECK) 1517 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1521 {
return _msmsconvassign(*
this,ms2); }
1523 #if(CXSC_INDEX_CHECK) 1524 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1528 {
return _mmsect<imatrix,imatrix,imatrix>(m1,m2); }
1530 #if(CXSC_INDEX_CHECK) 1531 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1535 {
return _mmssect<imatrix,imatrix_slice,imatrix>(m,ms); }
1537 #if(CXSC_INDEX_CHECK) 1538 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1542 {
return _mmssect<imatrix,imatrix_slice,imatrix>(m,ms); }
1544 #if(CXSC_INDEX_CHECK) 1545 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1549 {
return _msmssect<imatrix_slice,imatrix_slice,imatrix>(m1,m2); }
1551 #if(CXSC_INDEX_CHECK) 1552 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1556 {
return _mmsectassign(m1,m2); }
1558 #if(CXSC_INDEX_CHECK) 1559 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1563 {
return _mmssectassign(m1,ms); }
1565 #if(CXSC_INDEX_CHECK) 1566 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1570 {
return _msmsectassign(*
this,m1); }
1572 #if(CXSC_INDEX_CHECK) 1573 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1577 {
return _msmssectassign(*
this,ms2); }
1579 #if(CXSC_INDEX_CHECK) 1580 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1584 {
return _mmplus<rmatrix,imatrix,imatrix>(m1,m2); }
1586 #if(CXSC_INDEX_CHECK) 1587 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1591 {
return _mmplus<rmatrix,imatrix,imatrix>(m2,m1); }
1593 #if(CXSC_INDEX_CHECK) 1594 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1598 {
return _mmsplus<rmatrix,imatrix_slice,imatrix>(m,ms); }
1600 #if(CXSC_INDEX_CHECK) 1601 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1605 {
return _mmsplus<imatrix,rmatrix_slice,imatrix>(m,ms); }
1607 #if(CXSC_INDEX_CHECK) 1608 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1612 {
return _mmsplus<imatrix,rmatrix_slice,imatrix>(m,ms); }
1614 #if(CXSC_INDEX_CHECK) 1615 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1619 {
return _mmsplus<rmatrix,imatrix_slice,imatrix>(m,ms); }
1621 #if(CXSC_INDEX_CHECK) 1622 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1626 {
return _msmsplus<rmatrix_slice,imatrix_slice,imatrix>(m1,m2); }
1628 #if(CXSC_INDEX_CHECK) 1629 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1633 {
return _msmsplus<rmatrix_slice,imatrix_slice,imatrix>(m2,m1); }
1635 #if(CXSC_INDEX_CHECK) 1636 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1640 {
return _mmplusassign(m1,m2); }
1642 #if(CXSC_INDEX_CHECK) 1643 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1647 {
return _mmsplusassign(m1,ms); }
1649 #if(CXSC_INDEX_CHECK) 1650 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1654 {
return _msmplusassign(*
this,m1); }
1656 #if(CXSC_INDEX_CHECK) 1657 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1661 {
return _msmsplusassign(*
this,ms2); }
1663 #if(CXSC_INDEX_CHECK) 1664 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1668 {
return _mmminus<rmatrix,imatrix,imatrix>(m1,m2); }
1670 #if(CXSC_INDEX_CHECK) 1671 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1675 {
return _mmminus<imatrix,rmatrix,imatrix>(m1,m2); }
1677 #if(CXSC_INDEX_CHECK) 1678 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1682 {
return _mmsminus<rmatrix,imatrix_slice,imatrix>(m,ms); }
1684 #if(CXSC_INDEX_CHECK) 1685 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1689 {
return _mmsminus<imatrix,rmatrix_slice,imatrix>(m,ms); }
1691 #if(CXSC_INDEX_CHECK) 1692 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1696 {
return _msmminus<rmatrix_slice,imatrix,imatrix>(ms,m); }
1698 #if(CXSC_INDEX_CHECK) 1699 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1703 {
return _msmminus<imatrix_slice,rmatrix,imatrix>(ms,m); }
1705 #if(CXSC_INDEX_CHECK) 1706 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1710 {
return _msmsminus<rmatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
1712 #if(CXSC_INDEX_CHECK) 1713 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1717 {
return _msmsminus<imatrix_slice,rmatrix_slice,imatrix>(ms1,ms2); }
1719 #if(CXSC_INDEX_CHECK) 1720 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1724 {
return _mmminusassign(m1,m2); }
1726 #if(CXSC_INDEX_CHECK) 1727 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1731 {
return _mmsminusassign(m1,ms); }
1733 #if(CXSC_INDEX_CHECK) 1734 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1738 {
return _msmminusassign(*
this,m1); }
1740 #if(CXSC_INDEX_CHECK) 1741 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1745 {
return _msmsminusassign(*
this,ms2); }
1747 #if(CXSC_INDEX_CHECK) 1748 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1752 {
return _mmimult<rmatrix,imatrix,imatrix>(m1,m2); }
1754 #if(CXSC_INDEX_CHECK) 1755 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1759 {
return _mmimult<imatrix,rmatrix,imatrix>(m1,m2); }
1761 #if(CXSC_INDEX_CHECK) 1762 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1766 {
return _mmsimult<rmatrix,imatrix_slice,imatrix>(m1,ms); }
1768 #if(CXSC_INDEX_CHECK) 1769 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1773 {
return _mmsimult<imatrix,rmatrix_slice,imatrix>(m1,ms); }
1775 #if(CXSC_INDEX_CHECK) 1776 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1780 {
return _msmimult<rmatrix_slice,imatrix,imatrix>(ms,m1); }
1782 #if(CXSC_INDEX_CHECK) 1783 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1787 {
return _msmimult<imatrix_slice,rmatrix,imatrix>(ms,m1); }
1789 #if(CXSC_INDEX_CHECK) 1790 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1794 {
return _msmsimult<rmatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
1796 #if(CXSC_INDEX_CHECK) 1797 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1801 {
return _msmsimult<imatrix_slice,rmatrix_slice,imatrix>(ms1,ms2); }
1803 #if(CXSC_INDEX_CHECK) 1804 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1808 {
return _mmimultassign<imatrix,rmatrix,interval>(m1,m2); }
1810 #if(CXSC_INDEX_CHECK) 1811 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1815 {
return _mmsimultassign<imatrix,rmatrix_slice,interval>(m1,ms); }
1817 #if(CXSC_INDEX_CHECK) 1818 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
1822 {
return _mmconv<rmatrix,rmatrix,imatrix>(m1,m2); }
1824 #if(CXSC_INDEX_CHECK) 1825 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
1829 {
return _mmsconv<rmatrix,rmatrix_slice,imatrix>(m,ms); }
1831 #if(CXSC_INDEX_CHECK) 1832 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
1836 {
return _mmsconv<rmatrix,rmatrix_slice,imatrix>(m,ms); }
1838 #if(CXSC_INDEX_CHECK) 1839 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
1843 {
return _msmsconv<rmatrix_slice,rmatrix_slice,imatrix>(m1,m2); }
1845 #if(CXSC_INDEX_CHECK) 1846 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1850 {
return _mmconv<rmatrix,imatrix,imatrix>(m1,m2); }
1852 #if(CXSC_INDEX_CHECK) 1853 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1857 {
return _mmconv<rmatrix,imatrix,imatrix>(m2,m1); }
1859 #if(CXSC_INDEX_CHECK) 1860 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1864 {
return _mmsconv<rmatrix,imatrix_slice,imatrix>(m,ms); }
1866 #if(CXSC_INDEX_CHECK) 1867 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1871 {
return _mmsconv<imatrix,rmatrix_slice,imatrix>(m,ms); }
1873 #if(CXSC_INDEX_CHECK) 1874 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1878 {
return _mmsconv<imatrix,rmatrix_slice,imatrix>(m,ms); }
1880 #if(CXSC_INDEX_CHECK) 1881 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1885 {
return _mmsconv<rmatrix,imatrix_slice,imatrix>(m,ms); }
1887 #if(CXSC_INDEX_CHECK) 1888 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1892 {
return _msmsconv<rmatrix_slice,imatrix_slice,imatrix>(m1,m2); }
1894 #if(CXSC_INDEX_CHECK) 1895 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1899 {
return _msmsconv<rmatrix_slice,imatrix_slice,imatrix>(m2,m1); }
1901 #if(CXSC_INDEX_CHECK) 1902 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1906 {
return _mmconvassign(m1,m2); }
1908 #if(CXSC_INDEX_CHECK) 1909 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1913 {
return _mmsconvassign(m1,ms); }
1915 #if(CXSC_INDEX_CHECK) 1916 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1920 {
return _msmconvassign(*
this,m1); }
1922 #if(CXSC_INDEX_CHECK) 1923 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1927 {
return _msmsconvassign(*
this,ms2); }
1929 #if(CXSC_INDEX_CHECK) 1930 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1934 {
return _mmsect<rmatrix,imatrix,imatrix>(m1,m2); }
1936 #if(CXSC_INDEX_CHECK) 1937 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1941 {
return _mmsect<rmatrix,imatrix,imatrix>(m2,m1); }
1943 #if(CXSC_INDEX_CHECK) 1944 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1948 {
return _mmssect<rmatrix,imatrix_slice,imatrix>(m,ms); }
1950 #if(CXSC_INDEX_CHECK) 1951 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1955 {
return _mmssect<imatrix,rmatrix_slice,imatrix>(m,ms); }
1957 #if(CXSC_INDEX_CHECK) 1958 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1962 {
return _mmssect<imatrix,rmatrix_slice,imatrix>(m,ms); }
1964 #if(CXSC_INDEX_CHECK) 1965 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1969 {
return _mmssect<rmatrix,imatrix_slice,imatrix>(m,ms); }
1971 #if(CXSC_INDEX_CHECK) 1972 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1976 {
return _msmssect<rmatrix_slice,imatrix_slice,imatrix>(m1,m2); }
1978 #if(CXSC_INDEX_CHECK) 1979 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1983 {
return _msmssect<rmatrix_slice,imatrix_slice,imatrix>(m2,m1); }
1985 #if(CXSC_INDEX_CHECK) 1986 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1990 {
return _mmsectassign(m1,m2); }
1992 #if(CXSC_INDEX_CHECK) 1993 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
1997 {
return _mmssectassign(m1,ms); }
1999 #if(CXSC_INDEX_CHECK) 2000 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
2004 {
return _msmsectassign(*
this,m1); }
2006 #if(CXSC_INDEX_CHECK) 2007 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
2011 {
return _msmssectassign(*
this,ms2); }
2012 INLINE
bool operator ==(
const imatrix &m1,
const imatrix &m2)
throw() {
return _mmeq(m1,m2); }
2013 INLINE
bool operator !=(
const imatrix &m1,
const imatrix &m2)
throw() {
return _mmneq(m1,m2); }
2014 INLINE
bool operator <(
const imatrix &m1,
const imatrix &m2)
throw() {
return _mmless(m1,m2); }
2015 INLINE
bool operator <=(
const imatrix &m1,
const imatrix &m2)
throw() {
return _mmleq(m1,m2); }
2016 INLINE
bool operator >(
const imatrix &m1,
const imatrix &m2)
throw() {
return _mmless(m2,m1); }
2017 INLINE
bool operator >=(
const imatrix &m1,
const imatrix &m2)
throw() {
return _mmleq(m2,m1); }
2030 INLINE
bool operator !(
const imatrix &ms)
throw() {
return _mnot(ms); }
2032 INLINE std::ostream &operator <<(std::ostream &s,
const imatrix &r)
throw() {
return _mout(s,r); }
2033 INLINE std::ostream &operator <<(std::ostream &s,
const imatrix_slice &r)
throw() {
return _msout(s,r); }
2034 INLINE std::istream &operator >>(std::istream &s,
imatrix &r)
throw() {
return _min(s,r); }
2035 INLINE std::istream &operator >>(std::istream &s,
imatrix_slice &r)
throw() {
return _msin(s,r); }
2040 for(
int i=0 ; i<
ColLen(A) ; i++)
2041 for(
int j=0 ; j<
RowLen(A) ; j++)
2042 A[i+
Lb(A,1)][j+
Lb(A,2)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)][q[j+
Lb(q)]+
Lb(A,2)];
2049 for(
int i=0 ; i<
ColLen(A) ; i++)
2050 A[i+
Lb(A,1)] = (*this)[p[i+
Lb(p)]+
Lb(A,1)];
2064 return (*
this)(p,q);
imatrix & operator-=(const simatrix &)
Implementation of substraction and assignment operator.
The Data Type rmatrix_slice.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
The Data Type imatrix_subv.
imatrix_slice & operator()()
Operator for accessing the whole matrix.
imatrix_subv & operator()()
Operator for accessing the whole vector.
imatrix_slice & operator*=(const imatrix &m)
Implementation of multiplication and allocation operation.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
ivector_slice & operator*=(const interval &r)
Implementation of multiplication and allocation operation.
imatrix_subv & operator*=(const interval &c)
Implementation of multiplication and allocation operation.
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
The namespace cxsc, providing all functionality of the class library C-XSC.
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
The Scalar Type interval.
imatrix_slice & operator/=(const interval &c)
Implementation of division and allocation operation.
imatrix_slice & operator&=(const imatrix &m1)
Allocates the intersection of the arguments to the first argument.
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.
real AbsMin(const interval &x)
Computes the smallest absolute value .
imatrix_subv & operator&=(const sivector &rv)
Implementation of subtraction and allocation operation.
imatrix & operator+=(const simatrix &)
Implementation of addition and assignment operator.
imatrix_subv operator[](const int &i) const
Operator for accessing a single row of the matrix.
imatrix_slice & operator+=(const imatrix &m1)
Implementation of addition and allocation operation.
The Data Type ivector_slice.
The Data Type imatrix_slice.
The Data Type rvector_slice.
imatrix & operator&=(const simatrix &)
Implementation of intersection and assignment operator.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
imatrix_subv & operator=(const simatrix_subv &rv)
Implementation of standard assigning operator.
The Data Type rmatrix_subv.
imatrix_slice & operator=(const imatrix &m)
Implementation of standard assigning operator.
imatrix_subv & operator+=(const interval &c)
Implementation of addition and allocation operation.
imatrix & 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.
real AbsMax(const interval &x)
Computes the greatest absolute value .
int ColLen(const cimatrix &)
Returns the column dimension.
interval()
Constructor of class interval.
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.
interval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
ivector & operator=(const ivector &rv)
Implementation of standard assigning operator.
rvector absmax(const imatrix_subv &mv)
Returns the absolute maximum value of the matrix.
cimatrix _imatrix(const cimatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
imatrix & operator|=(const simatrix &)
Implementation of convex hull and assignment operator.
imatrix_subv operator[](const int &i)
Operator for accessing a single row of the matrix.
imatrix_slice & operator-=(const imatrix &m1)
Implementation of subtraction and allocation operation.
imatrix_subv & operator/=(const interval &c)
Implementation of division and allocation operation.
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
imatrix_slice & operator|=(const imatrix &m1)
Allocates the convex hull of the arguments to the first argument.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
imatrix_subv & operator|=(const sivector &rv)
Implementation of addition and allocation operation.
imatrix & operator*=(const simatrix &)
Implementation of product and assignment operator.
rvector absmin(const imatrix_subv &mv)
Returns the absolute minimum value of the matrix.
ivector()
Constructor of class ivector.
imatrix & operator=(const interval &r)
Implementation of standard assigning operator.
ivector & operator()()
Operator for accessing the whole vector.
imatrix_subv & operator-=(const interval &c)
Implementation of subtraction and allocation operation.
imatrix()
Constructor of class imatrix.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.