26 #ifndef _CXSC_IVECTOR_INL_INCLUDED 27 #define _CXSC_IVECTOR_INL_INCLUDED 41 INLINE
ivector::ivector(
const class index &i)
throw():l(1),u(i._int()),size(i._int())
49 throw(ERROR_IVECTOR_WRONG_BOUNDARIES,ERROR_IVECTOR_NO_MORE_MEMORY):l(i1),u(i2),size(i2-i1+1)
51 throw():l(i1),u(i2),size(i2-i1+1)
55 if(i1>i2) cxscthrow(ERROR_IVECTOR_WRONG_BOUNDARIES(
"ivector::ivector(const int &i1,const int &i2)"));
63 for(
int i=0, j=l-rs.l;i<size;i++,j++)
70 for (
int i=0;i<size;i++)
83 for(
int i=0, j=l-rs.l;i<size;i++,j++)
90 for (
int i=0;i<size;i++)
101 #if(CXSC_INDEX_CHECK) 102 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
107 #if(CXSC_INDEX_CHECK) 108 if(i<l||i>u) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC(
"interval & ivector::operator [](const int &i) const"));
114 #if(CXSC_INDEX_CHECK) 115 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
120 #if(CXSC_INDEX_CHECK) 121 if(i<l||i>u) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC(
"interval & ivector::operator [](const int &i)"));
127 #if(CXSC_INDEX_CHECK) 128 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
133 #if(CXSC_INDEX_CHECK) 134 if(i<start||i>end) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC(
"interval & ivector_slice::operator [](const int &i) const"));
140 #if(CXSC_INDEX_CHECK) 141 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
146 #if(CXSC_INDEX_CHECK) 147 if(i<start||i>end) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC(
"interval & ivector_slice::operator [](const int &i)"));
154 #if(CXSC_INDEX_CHECK) 155 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
160 #if(CXSC_INDEX_CHECK) 161 if(1<l||i>u) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG(
"ivector_slice ivector::operator ()(const int &i)"));
167 #if(CXSC_INDEX_CHECK) 168 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
173 #if(CXSC_INDEX_CHECK) 174 if(i1<l||i2>u) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG(
"ivector_slice ivector::operator ()(const int &i1,const int &i2)"));
180 #if(CXSC_INDEX_CHECK) 181 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
186 #if(CXSC_INDEX_CHECK) 187 if(1<start||i>end) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG(
"ivector_slice ivector_slice::operator ()(const int &i)"));
193 #if(CXSC_INDEX_CHECK) 194 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
199 #if(CXSC_INDEX_CHECK) 200 if(i1<start||i2>end) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG(
"ivector_slice ivector_slice::operator ()(const int &i1,const int &i2)"));
206 #if(CXSC_INDEX_CHECK) 207 throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ)
212 #if(CXSC_INDEX_CHECK) 213 if(rv.size>1) cxscthrow(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ(
"interval::interval(const ivector &rv)"));
214 else if(rv.size<1) cxscthrow(ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ(
"interval::interval(const ivector &rv)"));
220 #if(CXSC_INDEX_CHECK) 221 throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ)
226 #if(CXSC_INDEX_CHECK) 227 if(sl.size>1) cxscthrow(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ(
"interval::interval(const ivector_slice &sl)"));
228 else if(sl.size<1) cxscthrow(ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ(
"interval::interval(const ivector_slice &sl)"));
230 *
this=sl.dat[sl.start-sl.l];
267 INLINE ivector::operator
void*()
throw() {
return _vvoid(*
this); }
269 #if(CXSC_INDEX_CHECK) 270 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
274 {
return _vsvsassign(*
this,sl); }
276 #if(CXSC_INDEX_CHECK) 277 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
281 {
return _vsvassign(*
this,rv); }
284 #if(CXSC_INDEX_CHECK) 285 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
289 {
return _vsvassign(*
this,
ivector(m)); }
291 #if(CXSC_INDEX_CHECK) 292 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
296 {
return _vsvsassign(*
this,sl); }
298 #if(CXSC_INDEX_CHECK) 299 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
303 {
return _vsvassign(*
this,rv); }
305 INLINE ivector_slice::operator
void*()
throw() {
return _vsvoid(*
this); }
312 #if(CXSC_INDEX_CHECK) 313 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
317 {
return _vvsetinf(iv,rv); }
319 #if(CXSC_INDEX_CHECK) 320 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
324 {
return _vsvsetinf(iv,rv); }
326 #if(CXSC_INDEX_CHECK) 327 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
331 {
return _vvssetinf(iv,rv); }
333 #if(CXSC_INDEX_CHECK) 334 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
338 {
return _vsvssetinf(iv,rv); }
340 #if(CXSC_INDEX_CHECK) 341 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
345 {
return _vvusetinf(iv,rv); }
347 #if(CXSC_INDEX_CHECK) 348 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
352 {
return _vsvusetinf(iv,rv); }
354 #if(CXSC_INDEX_CHECK) 355 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
359 {
return _vvsusetinf(iv,rv); }
361 #if(CXSC_INDEX_CHECK) 362 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
366 {
return _vsvsusetinf(iv,rv); }
369 #if(CXSC_INDEX_CHECK) 370 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
374 {
return _vvsetsup(iv,rv); }
376 #if(CXSC_INDEX_CHECK) 377 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
381 {
return _vsvsetsup(iv,rv); }
383 #if(CXSC_INDEX_CHECK) 384 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
388 {
return _vvssetsup(iv,rv); }
390 #if(CXSC_INDEX_CHECK) 391 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
395 {
return _vsvssetsup(iv,rv); }
397 #if(CXSC_INDEX_CHECK) 398 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
402 {
return _vvusetsup(iv,rv); }
404 #if(CXSC_INDEX_CHECK) 405 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
409 {
return _vsvusetsup(iv,rv); }
411 #if(CXSC_INDEX_CHECK) 412 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
416 {
return _vvsusetsup(iv,rv); }
418 #if(CXSC_INDEX_CHECK) 419 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
423 {
return _vsvsusetsup(iv,rv); }
436 #if(CXSC_INDEX_CHECK) 437 throw(ERROR__WRONG_BOUNDARIES<ivector>)
441 { _vresize<class ivector,class interval>(rv,len); }
443 #if(CXSC_INDEX_CHECK) 444 throw(ERROR__WRONG_BOUNDARIES<ivector>)
448 { _vresize<class ivector,class interval>(rv,lb,ub); }
454 for(
int i=
Lb(rv) ; i<=
Ub(rv) ; i++)
460 for(
int i=
Lb(sl) ; i<=
Ub(sl) ; i++)
466 for(
int i=
Lb(rv) ; i<=
Ub(rv) ; i++)
472 for(
int i=
Lb(sl) ; i<=
Ub(sl) ; i++)
480 INLINE
rvector Inf(
const ivector &v)
throw() {
return _vinf<ivector,rvector>(v); }
482 INLINE
rvector Sup(
const ivector &v)
throw() {
return _vsup<ivector,rvector>(v); }
484 INLINE
bool operator !(
const ivector &rv)
throw() {
return _vnot(rv); }
485 INLINE
bool operator !(
const ivector_slice &sl)
throw() {
return _vsnot(sl); }
528 INLINE std::ostream &operator <<(std::ostream &s,
const ivector &rv)
throw() {
return _vout(s,rv); }
529 INLINE std::ostream &operator <<(std::ostream &o,
const ivector_slice &sl)
throw() {
return _vsout(o,sl); }
530 INLINE std::istream &operator >>(std::istream &s,
ivector &rv)
throw() {
return _vin(s,rv); }
531 INLINE std::istream &operator >>(std::istream &s,
ivector_slice &rv)
throw() {
return _vsin(s,rv); }
538 #if(CXSC_INDEX_CHECK) 539 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
543 {
return _vvimult<ivector,ivector,interval>(rv1,rv2); }
545 #if(CXSC_INDEX_CHECK) 546 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
550 {
return _vsvimult<ivector_slice,ivector,interval>(sl,rv); }
552 #if(CXSC_INDEX_CHECK) 553 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
557 {
return _vsvimult<ivector_slice,ivector,interval>(sl,rv); }
559 #if(CXSC_INDEX_CHECK) 560 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
564 {
return _vsvsimult<ivector_slice,ivector_slice,interval>(sl1,sl2); }
569 #if(CXSC_INDEX_CHECK) 570 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
574 {
return _vvplus<ivector,ivector,ivector>(rv1,rv2); }
576 #if(CXSC_INDEX_CHECK) 577 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
581 {
return _vvsplus<ivector,ivector_slice,ivector>(rv,sl); }
583 #if(CXSC_INDEX_CHECK) 584 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
588 {
return _vvsplus<ivector,ivector_slice,ivector>(rv,sl); }
590 #if(CXSC_INDEX_CHECK) 591 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
595 {
return _vsvsplus<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
597 #if(CXSC_INDEX_CHECK) 598 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
602 {
return _vvplusassign(rv1,rv2); }
604 #if(CXSC_INDEX_CHECK) 605 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
609 {
return _vvsplusassign(rv,sl); }
611 #if(CXSC_INDEX_CHECK) 612 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
616 {
return _vsvplusassign(*
this,rv); }
618 #if(CXSC_INDEX_CHECK) 619 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
623 {
return _vsvsplusassign(*
this,sl2); }
628 #if(CXSC_INDEX_CHECK) 629 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
633 {
return _vvminus<ivector,ivector,ivector>(rv1,rv2); }
635 #if(CXSC_INDEX_CHECK) 636 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
640 {
return _vvsminus<ivector,ivector_slice,ivector>(rv,sl); }
642 #if(CXSC_INDEX_CHECK) 643 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
647 {
return _vsvminus<ivector_slice,ivector,ivector>(sl,rv); }
649 #if(CXSC_INDEX_CHECK) 650 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
654 {
return _vsvsminus<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
656 #if(CXSC_INDEX_CHECK) 657 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
661 {
return _vvminusassign(rv1,rv2); }
663 #if(CXSC_INDEX_CHECK) 664 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
668 {
return _vvsminusassign(rv,sl); }
670 #if(CXSC_INDEX_CHECK) 671 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
675 {
return _vsvminusassign(*
this,rv); }
677 #if(CXSC_INDEX_CHECK) 678 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
682 {
return _vsvsminusassign(*
this,sl2); }
685 #if(CXSC_INDEX_CHECK) 686 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
690 {
return _vvconv<ivector,ivector,ivector>(rv1,rv2); }
692 #if(CXSC_INDEX_CHECK) 693 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
697 {
return _vvsconv<ivector,ivector_slice,ivector>(rv,sl); }
699 #if(CXSC_INDEX_CHECK) 700 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
704 {
return _vvsconv<ivector,ivector_slice,ivector>(rv,sl); }
706 #if(CXSC_INDEX_CHECK) 707 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
711 {
return _vsvsconv<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
713 #if(CXSC_INDEX_CHECK) 714 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
718 {
return _vvconvassign(rv1,rv2); }
720 #if(CXSC_INDEX_CHECK) 721 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
725 {
return _vvsconvassign(rv,sl); }
727 #if(CXSC_INDEX_CHECK) 728 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
732 {
return _vsvconvassign(*
this,rv); }
734 #if(CXSC_INDEX_CHECK) 735 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
739 {
return _vsvsconvassign(*
this,sl2); }
742 #if(CXSC_INDEX_CHECK) 743 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
747 {
return _vvsect<ivector,ivector,ivector>(rv1,rv2); }
749 #if(CXSC_INDEX_CHECK) 750 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
754 {
return _vvssect<ivector,ivector_slice,ivector>(rv,sl); }
756 #if(CXSC_INDEX_CHECK) 757 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
761 {
return _vvssect<ivector,ivector_slice,ivector>(rv,sl); }
763 #if(CXSC_INDEX_CHECK) 764 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
768 {
return _vsvssect<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
770 #if(CXSC_INDEX_CHECK) 771 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
775 {
return _vvsectassign(rv1,rv2); }
777 #if(CXSC_INDEX_CHECK) 778 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
782 {
return _vvssectassign(rv,sl); }
784 #if(CXSC_INDEX_CHECK) 785 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
789 {
return _vsvsectassign(*
this,rv); }
791 #if(CXSC_INDEX_CHECK) 792 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
796 {
return _vsvssectassign(*
this,sl2); }
798 INLINE
bool operator ==(
const ivector &rv1,
const ivector &rv2)
throw() {
return _vveq(rv1,rv2); }
802 INLINE
bool operator !=(
const ivector &rv1,
const ivector &rv2)
throw() {
return _vvneq(rv1,rv2); }
806 INLINE
bool operator <(
const ivector &rv1,
const ivector &rv2)
throw() {
return _vvless(rv1,rv2); }
810 INLINE
bool operator <=(
const ivector &rv1,
const ivector &rv2)
throw() {
return _vvleq(rv1,rv2); }
814 INLINE
bool operator >(
const ivector &rv1,
const ivector &rv2)
throw() {
return _vvless(rv2,rv1); }
818 INLINE
bool operator >=(
const ivector &rv1,
const ivector &rv2)
throw() {
return _vvleq(rv2,rv1); }
829 #if(CXSC_INDEX_CHECK) 830 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
834 {
return _vvimult<rvector,ivector,interval>(rv1,rv2); }
836 #if(CXSC_INDEX_CHECK) 837 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
841 {
return _vsvimult<rvector_slice,ivector,interval>(sl,rv); }
843 #if(CXSC_INDEX_CHECK) 844 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
848 {
return _vsvimult<ivector_slice,rvector,interval>(sl,rv); }
850 #if(CXSC_INDEX_CHECK) 851 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
855 {
return _vsvsimult<rvector_slice,ivector_slice,interval>(sl1,sl2); }
858 #if(CXSC_INDEX_CHECK) 859 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
863 {
return _vvimult<rvector,ivector,interval>(rv2,rv1); }
865 #if(CXSC_INDEX_CHECK) 866 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
870 {
return _vsvimult<ivector_slice,rvector,interval>(sl,rv); }
872 #if(CXSC_INDEX_CHECK) 873 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
877 {
return _vsvimult<rvector_slice,ivector,interval>(sl,rv); }
879 #if(CXSC_INDEX_CHECK) 880 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
884 {
return _vsvsimult<rvector_slice,ivector_slice,interval>(sl2,sl1); }
887 #if(CXSC_INDEX_CHECK) 888 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
892 {
return _vvplus<rvector,ivector,ivector>(rv1,rv2); }
894 #if(CXSC_INDEX_CHECK) 895 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
899 {
return _vvsplus<rvector,ivector_slice,ivector>(rv,sl); }
901 #if(CXSC_INDEX_CHECK) 902 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
906 {
return _vvsplus<ivector,rvector_slice,ivector>(rv,sl); }
908 #if(CXSC_INDEX_CHECK) 909 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
913 {
return _vsvsplus<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
916 #if(CXSC_INDEX_CHECK) 917 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
921 {
return _vvplus<rvector,ivector,ivector>(rv2,rv1); }
923 #if(CXSC_INDEX_CHECK) 924 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
928 {
return _vvsplus<ivector,rvector_slice,ivector>(rv,sl); }
930 #if(CXSC_INDEX_CHECK) 931 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
935 {
return _vvsplus<rvector,ivector_slice,ivector>(rv,sl); }
937 #if(CXSC_INDEX_CHECK) 938 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
942 {
return _vsvsplus<rvector_slice,ivector_slice,ivector>(sl2,sl1); }
945 #if(CXSC_INDEX_CHECK) 946 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
950 {
return _vvplusassign(rv1,rv2); }
952 #if(CXSC_INDEX_CHECK) 953 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
957 {
return _vvsplusassign(rv,sl); }
959 #if(CXSC_INDEX_CHECK) 960 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
964 {
return _vsvplusassign(*
this,rv); }
966 #if(CXSC_INDEX_CHECK) 967 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
971 {
return _vsvsplusassign(*
this,sl2); }
974 #if(CXSC_INDEX_CHECK) 975 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
979 {
return _vvminus<rvector,ivector,ivector>(rv1,rv2); }
981 #if(CXSC_INDEX_CHECK) 982 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
986 {
return _vvsminus<rvector,ivector_slice,ivector>(rv,sl); }
988 #if(CXSC_INDEX_CHECK) 989 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
993 {
return _vsvminus<rvector_slice,ivector,ivector>(sl,rv); }
995 #if(CXSC_INDEX_CHECK) 996 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1000 {
return _vsvsminus<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
1003 #if(CXSC_INDEX_CHECK) 1004 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1008 {
return _vvminus<ivector,rvector,ivector>(rv1,rv2); }
1010 #if(CXSC_INDEX_CHECK) 1011 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1015 {
return _vvsminus<ivector,rvector_slice,ivector>(rv,sl); }
1017 #if(CXSC_INDEX_CHECK) 1018 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1022 {
return _vsvminus<ivector_slice,rvector,ivector>(sl,rv); }
1024 #if(CXSC_INDEX_CHECK) 1025 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1029 {
return _vsvsminus<ivector_slice,rvector_slice,ivector>(sl1,sl2); }
1032 #if(CXSC_INDEX_CHECK) 1033 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1037 {
return _vvminusassign(rv1,rv2); }
1039 #if(CXSC_INDEX_CHECK) 1040 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1044 {
return _vvsminusassign(rv,sl); }
1046 #if(CXSC_INDEX_CHECK) 1047 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1051 {
return _vsvminusassign(*
this,rv); }
1053 #if(CXSC_INDEX_CHECK) 1054 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1058 {
return _vsvsminusassign(*
this,sl2); }
1061 #if(CXSC_INDEX_CHECK) 1062 throw(ERROR__OP_WITH_WRONG_DIM<rvector>)
1066 {
return _vvconv<rvector,rvector,ivector>(rv1,rv2); }
1068 #if(CXSC_INDEX_CHECK) 1069 throw(ERROR__OP_WITH_WRONG_DIM<rvector>)
1073 {
return _vvsconv<rvector,rvector_slice,ivector>(rv,sl); }
1075 #if(CXSC_INDEX_CHECK) 1076 throw(ERROR__OP_WITH_WRONG_DIM<rvector>)
1080 {
return _vvsconv<rvector,rvector_slice,ivector>(rv,sl); }
1082 #if(CXSC_INDEX_CHECK) 1083 throw(ERROR__OP_WITH_WRONG_DIM<rvector>)
1087 {
return _vsvsconv<rvector_slice,rvector_slice,ivector>(sl1,sl2); }
1089 #if(CXSC_INDEX_CHECK) 1090 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1094 {
return _vvconv<rvector,ivector,ivector>(rv1,rv2); }
1096 #if(CXSC_INDEX_CHECK) 1097 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1101 {
return _vvsconv<rvector,ivector_slice,ivector>(rv,sl); }
1103 #if(CXSC_INDEX_CHECK) 1104 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1108 {
return _vvsconv<ivector,rvector_slice,ivector>(rv,sl); }
1110 #if(CXSC_INDEX_CHECK) 1111 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1115 {
return _vsvsconv<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
1118 #if(CXSC_INDEX_CHECK) 1119 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1123 {
return _vvconv<rvector,ivector,ivector>(rv2,rv1); }
1125 #if(CXSC_INDEX_CHECK) 1126 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1130 {
return _vvsconv<ivector,rvector_slice,ivector>(rv,sl); }
1132 #if(CXSC_INDEX_CHECK) 1133 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1137 {
return _vvsconv<rvector,ivector_slice,ivector>(rv,sl); }
1139 #if(CXSC_INDEX_CHECK) 1140 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1144 {
return _vsvsconv<rvector_slice,ivector_slice,ivector>(sl2,sl1); }
1147 #if(CXSC_INDEX_CHECK) 1148 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1152 {
return _vvconvassign(rv1,rv2); }
1154 #if(CXSC_INDEX_CHECK) 1155 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1159 {
return _vvsconvassign(rv,sl); }
1161 #if(CXSC_INDEX_CHECK) 1162 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1166 {
return _vsvconvassign(*
this,rv); }
1168 #if(CXSC_INDEX_CHECK) 1169 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1173 {
return _vsvsconvassign(*
this,sl2); }
1176 #if(CXSC_INDEX_CHECK) 1177 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1181 {
return _vvsect<rvector,ivector,ivector>(rv1,rv2); }
1183 #if(CXSC_INDEX_CHECK) 1184 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1188 {
return _vvssect<rvector,ivector_slice,ivector>(rv,sl); }
1190 #if(CXSC_INDEX_CHECK) 1191 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1195 {
return _vvssect<ivector,rvector_slice,ivector>(rv,sl); }
1197 #if(CXSC_INDEX_CHECK) 1198 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1202 {
return _vsvssect<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
1205 #if(CXSC_INDEX_CHECK) 1206 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1210 {
return _vvsect<rvector,ivector,ivector>(rv2,rv1); }
1212 #if(CXSC_INDEX_CHECK) 1213 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1217 {
return _vvssect<ivector,rvector_slice,ivector>(rv,sl); }
1219 #if(CXSC_INDEX_CHECK) 1220 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1224 {
return _vvssect<rvector,ivector_slice,ivector>(rv,sl); }
1226 #if(CXSC_INDEX_CHECK) 1227 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1231 {
return _vsvssect<rvector_slice,ivector_slice,ivector>(sl2,sl1); }
1234 #if(CXSC_INDEX_CHECK) 1235 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1239 {
return _vvsectassign(rv1,rv2); }
1241 #if(CXSC_INDEX_CHECK) 1242 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1246 {
return _vvssectassign(rv,sl); }
1248 #if(CXSC_INDEX_CHECK) 1249 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1253 {
return _vsvsectassign(*
this,rv); }
1255 #if(CXSC_INDEX_CHECK) 1256 throw(ERROR__OP_WITH_WRONG_DIM<ivector>)
1260 {
return _vsvssectassign(*
this,sl2); }
1266 for(
int i=0 ; i<
VecLen(x) ; i++)
1267 x[i+
Lb(x)] = (*this)[p[i+
Lb(p)]+
Lb(*
this)];
1273 #endif // _CXSC_IVECTOR_INL_INCLUDED friend int Lb(const ivector &rv)
Returns the lower bound of the vector.
ivector_slice & operator&=(const ivector &rv)
Allocates the intersection of the arguments to the first argument.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division 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 ivector &rv)
Allocates the convex hull of the arguments to the first argument.
ivector & operator+=(const srvector &)
Implementation of assignment and addition operator.
ivector_slice & operator*=(const interval &r)
Implementation of multiplication and allocation operation.
ivector & operator|=(const srvector &)
Implementation of assignment and hull operator.
ivector_slice & operator()()
Operator for accessing the whole vector.
The namespace cxsc, providing all functionality of the class library C-XSC.
ivector & operator &=(const sivector &)
Implementation of assignment and intersection operator.
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.
real AbsMin(const interval &x)
Computes the smallest absolute value .
friend int VecLen(const ivector &rv)
Returns the dimension of the vector.
The Data Type ivector_slice.
The Data Type rvector_slice.
The Data Type rmatrix_subv.
ivector_slice & operator+=(const ivector &rv)
Implementation of addition and allocation operation.
void Resize(cimatrix &A)
Resizes the matrix.
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
interval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
real AbsMax(const interval &x)
Computes the greatest absolute value .
interval()
Constructor of class interval.
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.
INLINE ivector _ivector(const rmatrix &sl)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
ivector_slice & operator/=(const interval &r)
Implementation of division and allocation operation.
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
friend int Ub(const ivector &rv)
Returns the upper bound of the vector.
rvector absmin(const imatrix_subv &mv)
Returns the absolute minimum value of the matrix.
ivector()
Constructor of class ivector.
ivector & operator()()
Operator for accessing the whole vector.
ivector_slice & operator-=(const ivector &rv)
Implementation of subtraction and allocation operation.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.