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); }
688 INLINE ivector operator |(
const imatrix_subv &rv1,
const ivector &rv2)
689 #if(CXSC_INDEX_CHECK)
690 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
694 {
return _mvvconv<imatrix_subv,ivector,ivector>(rv1,rv2); }
695 INLINE ivector operator |(
const ivector & rv1,
const imatrix_subv &rv2)
696 #if(CXSC_INDEX_CHECK)
697 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
701 {
return _mvvconv<imatrix_subv,ivector,ivector>(rv2,rv1); }
702 INLINE ivector operator |(
const ivector_slice &sl,
const imatrix_subv &mv)
703 #if(CXSC_INDEX_CHECK)
704 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
708 {
return _mvvconv<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
709 INLINE ivector operator |(
const imatrix_subv &mv,
const ivector_slice &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); }
737 INLINE ivector operator &(
const imatrix_subv &rv1,
const ivector &rv2)
738 #if(CXSC_INDEX_CHECK)
739 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
743 {
return _mvvsect<imatrix_subv,ivector,ivector>(rv1,rv2); }
744 INLINE ivector operator &(
const ivector & rv1,
const imatrix_subv &rv2)
745 #if(CXSC_INDEX_CHECK)
746 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
750 {
return _mvvsect<imatrix_subv,ivector,ivector>(rv2,rv1); }
751 INLINE ivector operator &(
const ivector_slice &sl,
const imatrix_subv &mv)
752 #if(CXSC_INDEX_CHECK)
753 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
757 {
return _mvvsect<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
758 INLINE ivector operator &(
const imatrix_subv &mv,
const ivector_slice &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);