26 #ifndef _CXSC_LIVECTOR_INL_INCLUDED 27 #define _CXSC_LIVECTOR_INL_INCLUDED 49 throw(ERROR_LIVECTOR_WRONG_BOUNDARIES,ERROR_LIVECTOR_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_LIVECTOR_WRONG_BOUNDARIES(
"l_ivector::l_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, j=l-rs.l;i<size;i++,j++)
77 for(
int i=0, j=l-rs.l;i<size;i++,j++)
84 for(
int i=0, j=l-rs.l;i<size;i++,j++)
91 for (
int i=0;i<size;i++)
104 for (
int i=0;i<size;i++)
111 for (
int i=0;i<size;i++)
118 for (
int i=0;i<size;i++)
142 #if(CXSC_INDEX_CHECK) 143 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
148 #if(CXSC_INDEX_CHECK) 149 if(i<l||i>u) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC(
"l_interval & l_ivector::operator [](const int &i)"));
155 #if(CXSC_INDEX_CHECK) 156 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
161 #if(CXSC_INDEX_CHECK) 162 if(i<start||i>end) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC(
"l_interval & l_ivector_slice::operator [](const int &i)"));
168 #if(CXSC_INDEX_CHECK) 169 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
174 #if(CXSC_INDEX_CHECK) 175 if(1<l||i>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_ivector_slice l_ivector::operator ()(const int &i)"));
181 #if(CXSC_INDEX_CHECK) 182 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
187 #if(CXSC_INDEX_CHECK) 188 if(i1<l||i2>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_ivector_slice l_ivector::operator ()(const int &i1,const int &i2)"));
194 #if(CXSC_INDEX_CHECK) 195 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
200 #if(CXSC_INDEX_CHECK) 201 if(1<start||i>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_ivector_slice l_ivector_slice::operator ()(const int &i)"));
207 #if(CXSC_INDEX_CHECK) 208 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
213 #if(CXSC_INDEX_CHECK) 214 if(i1<start||i2>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_ivector_slice l_ivector_slice::operator ()(const int &i1,const int &i2)"));
220 #if(CXSC_INDEX_CHECK) 221 throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ)
226 #if(CXSC_INDEX_CHECK) 227 if(rv.size>1) cxscthrow(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ(
"l_interval::l_interval(const l_ivector &rv)"));
228 else if(rv.size<1) cxscthrow(ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ(
"l_interval::l_interval(const l_ivector &rv)"));
234 #if(CXSC_INDEX_CHECK) 235 throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ)
240 #if(CXSC_INDEX_CHECK) 241 if(sl.size>1) cxscthrow(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ(
"l_interval::l_interval(const l_ivector_slice &sl)"));
242 else if(sl.size<1) cxscthrow(ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ(
"l_interval::l_interval(const l_ivector_slice &sl)"));
244 *
this=sl.dat[sl.start-sl.l];
313 INLINE l_ivector::operator
void*()
throw() {
return _vvoid(*
this); }
315 #if(CXSC_INDEX_CHECK) 316 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
320 {
return _vsvsassign(*
this,sl); }
322 #if(CXSC_INDEX_CHECK) 323 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
327 {
return _vsvassign(*
this,rv); }
329 INLINE l_ivector_slice::operator
void*()
throw() {
return _vsvoid(*
this); }
336 #if(CXSC_INDEX_CHECK) 337 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
341 {
return _vvsetinf(iv,rv); }
343 #if(CXSC_INDEX_CHECK) 344 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
348 {
return _vsvsetinf(iv,rv); }
350 #if(CXSC_INDEX_CHECK) 351 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
355 {
return _vvssetinf(iv,rv); }
357 #if(CXSC_INDEX_CHECK) 358 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
362 {
return _vsvssetinf(iv,rv); }
364 #if(CXSC_INDEX_CHECK) 365 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
369 {
return _vvusetinf(iv,rv); }
371 #if(CXSC_INDEX_CHECK) 372 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
376 {
return _vsvusetinf(iv,rv); }
378 #if(CXSC_INDEX_CHECK) 379 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
383 {
return _vvsusetinf(iv,rv); }
385 #if(CXSC_INDEX_CHECK) 386 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
390 {
return _vsvsusetinf(iv,rv); }
393 #if(CXSC_INDEX_CHECK) 394 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
398 {
return _vvsetsup(iv,rv); }
400 #if(CXSC_INDEX_CHECK) 401 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
405 {
return _vsvsetsup(iv,rv); }
407 #if(CXSC_INDEX_CHECK) 408 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
412 {
return _vvssetsup(iv,rv); }
414 #if(CXSC_INDEX_CHECK) 415 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
419 {
return _vsvssetsup(iv,rv); }
421 #if(CXSC_INDEX_CHECK) 422 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
426 {
return _vvusetsup(iv,rv); }
428 #if(CXSC_INDEX_CHECK) 429 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
433 {
return _vsvusetsup(iv,rv); }
435 #if(CXSC_INDEX_CHECK) 436 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
440 {
return _vvsusetsup(iv,rv); }
442 #if(CXSC_INDEX_CHECK) 443 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
447 {
return _vsvsusetsup(iv,rv); }
461 #if(CXSC_INDEX_CHECK) 462 throw(ERROR__WRONG_BOUNDARIES<l_ivector>)
466 { _vresize<class l_ivector,class l_interval>(rv,len); }
468 #if(CXSC_INDEX_CHECK) 469 throw(ERROR__WRONG_BOUNDARIES<l_ivector>)
473 { _vresize<class l_ivector,class l_interval>(rv,lb,ub); }
485 INLINE
bool operator !(
const l_ivector &rv)
throw() {
return _vnot(rv); }
573 INLINE std::ostream &operator <<(std::ostream &s,
const l_ivector &rv)
throw() {
return _vout(s,rv); }
574 INLINE std::ostream &operator <<(std::ostream &o,
const l_ivector_slice &sl)
throw() {
return _vsout(o,sl); }
575 INLINE std::istream &operator >>(std::istream &s,
l_ivector &rv)
throw() {
return _vin(s,rv); }
576 INLINE std::istream &operator >>(std::istream &s,
l_ivector_slice &rv)
throw() {
return _vsin(s,rv); }
582 #if(CXSC_INDEX_CHECK) 583 throw(OP_WITH_WRONG_DIM)
587 { _vvaccu(dp,rv1,rv2); }
589 #if(CXSC_INDEX_CHECK) 590 throw(OP_WITH_WRONG_DIM)
594 { _vsvaccu(dp,sl,rv); }
596 #if(CXSC_INDEX_CHECK) 597 throw(OP_WITH_WRONG_DIM)
601 { _vsvaccu(dp,sl,rv); }
602 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const l_imatrix_subv &rv2)
603 #if(CXSC_INDEX_CHECK) 604 throw(OP_WITH_WRONG_DIM)
609 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const l_ivector &rv2)
610 #if(CXSC_INDEX_CHECK) 611 throw(OP_WITH_WRONG_DIM)
617 #if(CXSC_INDEX_CHECK) 618 throw(OP_WITH_WRONG_DIM)
622 { _vsvsaccu(dp,sl1,sl2); }
625 #if(CXSC_INDEX_CHECK) 626 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
630 {
return _vvlimult<l_ivector,l_ivector,l_interval>(rv1,rv2); }
632 #if(CXSC_INDEX_CHECK) 633 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
637 {
return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
639 #if(CXSC_INDEX_CHECK) 640 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
644 {
return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
646 #if(CXSC_INDEX_CHECK) 647 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
651 {
return _vsvslimult<l_ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
656 #if(CXSC_INDEX_CHECK) 657 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
661 {
return _vvplus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
663 #if(CXSC_INDEX_CHECK) 664 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
668 {
return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
670 #if(CXSC_INDEX_CHECK) 671 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
675 {
return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
677 #if(CXSC_INDEX_CHECK) 678 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
682 {
return _vsvsplus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
684 #if(CXSC_INDEX_CHECK) 685 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
689 {
return _vvplusassign(rv1,rv2); }
691 #if(CXSC_INDEX_CHECK) 692 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
696 {
return _vvsplusassign(rv,sl); }
698 #if(CXSC_INDEX_CHECK) 699 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
703 {
return _vsvplusassign(*
this,rv); }
705 #if(CXSC_INDEX_CHECK) 706 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
710 {
return _vsvsplusassign(*
this,sl2); }
715 #if(CXSC_INDEX_CHECK) 716 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
720 {
return _vvminus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
722 #if(CXSC_INDEX_CHECK) 723 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
727 {
return _vvsminus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
729 #if(CXSC_INDEX_CHECK) 730 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
734 {
return _vsvminus<l_ivector_slice,l_ivector,l_ivector>(sl,rv); }
736 #if(CXSC_INDEX_CHECK) 737 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
741 {
return _vsvsminus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
743 #if(CXSC_INDEX_CHECK) 744 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
748 {
return _vvminusassign(rv1,rv2); }
750 #if(CXSC_INDEX_CHECK) 751 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
755 {
return _vvsminusassign(rv,sl); }
757 #if(CXSC_INDEX_CHECK) 758 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
762 {
return _vsvminusassign(*
this,rv); }
764 #if(CXSC_INDEX_CHECK) 765 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
769 {
return _vsvsminusassign(*
this,sl2); }
772 #if(CXSC_INDEX_CHECK) 773 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
777 {
return _vvconv<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
779 #if(CXSC_INDEX_CHECK) 780 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
784 {
return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
786 #if(CXSC_INDEX_CHECK) 787 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
791 {
return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
793 #if(CXSC_INDEX_CHECK) 794 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
798 {
return _vsvsconv<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
800 #if(CXSC_INDEX_CHECK) 801 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
805 {
return _vvconvassign(rv1,rv2); }
807 #if(CXSC_INDEX_CHECK) 808 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
812 {
return _vvsconvassign(rv,sl); }
814 #if(CXSC_INDEX_CHECK) 815 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
819 {
return _vsvconvassign(*
this,rv); }
821 #if(CXSC_INDEX_CHECK) 822 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
826 {
return _vsvsconvassign(*
this,sl2); }
829 #if(CXSC_INDEX_CHECK) 830 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
834 {
return _vvsect<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
836 #if(CXSC_INDEX_CHECK) 837 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
841 {
return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
843 #if(CXSC_INDEX_CHECK) 844 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
848 {
return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
850 #if(CXSC_INDEX_CHECK) 851 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
855 {
return _vsvssect<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
857 #if(CXSC_INDEX_CHECK) 858 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
862 {
return _vvsectassign(rv1,rv2); }
864 #if(CXSC_INDEX_CHECK) 865 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
869 {
return _vvssectassign(rv,sl); }
871 #if(CXSC_INDEX_CHECK) 872 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
876 {
return _vsvsectassign(*
this,rv); }
878 #if(CXSC_INDEX_CHECK) 879 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
883 {
return _vsvssectassign(*
this,sl2); }
885 INLINE
bool operator ==(
const l_ivector &rv1,
const l_ivector &rv2)
throw() {
return _vveq(rv1,rv2); }
889 INLINE
bool operator !=(
const l_ivector &rv1,
const l_ivector &rv2)
throw() {
return _vvneq(rv1,rv2); }
893 INLINE
bool operator <(
const l_ivector &rv1,
const l_ivector &rv2)
throw() {
return _vvless(rv1,rv2); }
897 INLINE
bool operator <=(
const l_ivector &rv1,
const l_ivector &rv2)
throw() {
return _vvleq(rv1,rv2); }
901 INLINE
bool operator >(
const l_ivector &rv1,
const l_ivector &rv2)
throw() {
return _vvless(rv2,rv1); }
905 INLINE
bool operator >=(
const l_ivector &rv1,
const l_ivector &rv2)
throw() {
return _vvleq(rv2,rv1); }
916 #if(CXSC_INDEX_CHECK) 917 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
921 {
return _vsvassign(*
this,rv); }
924 #if(CXSC_INDEX_CHECK) 925 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
929 {
return _vsvsassign(*
this,sl); }
932 #if(CXSC_INDEX_CHECK) 933 throw(OP_WITH_WRONG_DIM)
937 { _vvaccu(dp,rv1,rv2); }
939 #if(CXSC_INDEX_CHECK) 940 throw(OP_WITH_WRONG_DIM)
944 { _vvaccu(dp,rv2,rv1); }
946 #if(CXSC_INDEX_CHECK) 947 throw(OP_WITH_WRONG_DIM)
951 { _vsvaccu(dp,sl,rv); }
953 #if(CXSC_INDEX_CHECK) 954 throw(OP_WITH_WRONG_DIM)
958 { _vsvaccu(dp,sl,rv); }
960 #if(CXSC_INDEX_CHECK) 961 throw(OP_WITH_WRONG_DIM)
965 { _vsvaccu(dp,sl,rv); }
966 INLINE
void accumulate(idotprecision &dp,
const rvector & rv1,
const l_imatrix_subv &rv2)
967 #if(CXSC_INDEX_CHECK) 968 throw(OP_WITH_WRONG_DIM)
973 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const rmatrix_subv &rv2)
974 #if(CXSC_INDEX_CHECK) 975 throw(OP_WITH_WRONG_DIM)
981 #if(CXSC_INDEX_CHECK) 982 throw(OP_WITH_WRONG_DIM)
986 { _vsvaccu(dp,sl,rv); }
987 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_ivector &rv2)
988 #if(CXSC_INDEX_CHECK) 989 throw(OP_WITH_WRONG_DIM)
994 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const rvector &rv2)
995 #if(CXSC_INDEX_CHECK) 996 throw(OP_WITH_WRONG_DIM)
1002 #if(CXSC_INDEX_CHECK) 1003 throw(OP_WITH_WRONG_DIM)
1007 { _vsvsaccu(dp,sl2,sl1); }
1009 #if(CXSC_INDEX_CHECK) 1010 throw(OP_WITH_WRONG_DIM)
1014 { _vsvsaccu(dp,sl1,sl2); }
1017 #if(CXSC_INDEX_CHECK) 1018 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1022 {
return _vvlimult<rvector,l_ivector,l_interval>(rv1,rv2); }
1024 #if(CXSC_INDEX_CHECK) 1025 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1029 {
return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1031 #if(CXSC_INDEX_CHECK) 1032 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1036 {
return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1038 #if(CXSC_INDEX_CHECK) 1039 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1043 {
return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1046 #if(CXSC_INDEX_CHECK) 1047 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1051 {
return _vvlimult<rvector,l_ivector,l_interval>(rv2,rv1); }
1053 #if(CXSC_INDEX_CHECK) 1054 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1058 {
return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1060 #if(CXSC_INDEX_CHECK) 1061 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1065 {
return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1067 #if(CXSC_INDEX_CHECK) 1068 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1072 {
return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1075 #if(CXSC_INDEX_CHECK) 1076 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1080 {
return _vvplus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1082 #if(CXSC_INDEX_CHECK) 1083 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1087 {
return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1089 #if(CXSC_INDEX_CHECK) 1090 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1094 {
return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1096 #if(CXSC_INDEX_CHECK) 1097 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1101 {
return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1104 #if(CXSC_INDEX_CHECK) 1105 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1109 {
return _vvplus<rvector,l_ivector,l_ivector>(rv2,rv1); }
1111 #if(CXSC_INDEX_CHECK) 1112 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1116 {
return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1118 #if(CXSC_INDEX_CHECK) 1119 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1123 {
return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1125 #if(CXSC_INDEX_CHECK) 1126 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1130 {
return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1133 #if(CXSC_INDEX_CHECK) 1134 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1138 {
return _vvplusassign(rv1,rv2); }
1140 #if(CXSC_INDEX_CHECK) 1141 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1145 {
return _vvsplusassign(rv,sl); }
1147 #if(CXSC_INDEX_CHECK) 1148 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1152 {
return _vsvplusassign(*
this,rv); }
1154 #if(CXSC_INDEX_CHECK) 1155 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1159 {
return _vsvsplusassign(*
this,sl2); }
1162 #if(CXSC_INDEX_CHECK) 1163 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1167 {
return _vvminus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1169 #if(CXSC_INDEX_CHECK) 1170 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1174 {
return _vvsminus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1176 #if(CXSC_INDEX_CHECK) 1177 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1181 {
return _vsvminus<rvector_slice,l_ivector,l_ivector>(sl,rv); }
1183 #if(CXSC_INDEX_CHECK) 1184 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1188 {
return _vsvsminus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1191 #if(CXSC_INDEX_CHECK) 1192 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1196 {
return _vvminus<l_ivector,rvector,l_ivector>(rv1,rv2); }
1198 #if(CXSC_INDEX_CHECK) 1199 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1203 {
return _vvsminus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1205 #if(CXSC_INDEX_CHECK) 1206 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1210 {
return _vsvminus<l_ivector_slice,rvector,l_ivector>(sl,rv); }
1212 #if(CXSC_INDEX_CHECK) 1213 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1217 {
return _vsvsminus<l_ivector_slice,rvector_slice,l_ivector>(sl1,sl2); }
1220 #if(CXSC_INDEX_CHECK) 1221 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1225 {
return _vvminusassign(rv1,rv2); }
1227 #if(CXSC_INDEX_CHECK) 1228 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1232 {
return _vvsminusassign(rv,sl); }
1234 #if(CXSC_INDEX_CHECK) 1235 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1239 {
return _vsvminusassign(*
this,rv); }
1241 #if(CXSC_INDEX_CHECK) 1242 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1246 {
return _vsvsminusassign(*
this,sl2); }
1249 #if(CXSC_INDEX_CHECK) 1250 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1254 {
return _vvconv<rvector,l_ivector,l_ivector>(rv1,rv2); }
1256 #if(CXSC_INDEX_CHECK) 1257 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1261 {
return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1263 #if(CXSC_INDEX_CHECK) 1264 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1268 {
return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1270 #if(CXSC_INDEX_CHECK) 1271 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1275 {
return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1278 #if(CXSC_INDEX_CHECK) 1279 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1283 {
return _vvconv<rvector,l_ivector,l_ivector>(rv2,rv1); }
1285 #if(CXSC_INDEX_CHECK) 1286 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1290 {
return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1292 #if(CXSC_INDEX_CHECK) 1293 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1297 {
return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1299 #if(CXSC_INDEX_CHECK) 1300 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1304 {
return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1307 #if(CXSC_INDEX_CHECK) 1308 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1312 {
return _vvconvassign(rv1,rv2); }
1314 #if(CXSC_INDEX_CHECK) 1315 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1319 {
return _vvsconvassign(rv,sl); }
1321 #if(CXSC_INDEX_CHECK) 1322 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1326 {
return _vsvconvassign(*
this,rv); }
1328 #if(CXSC_INDEX_CHECK) 1329 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1333 {
return _vsvsconvassign(*
this,sl2); }
1336 #if(CXSC_INDEX_CHECK) 1337 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1341 {
return _vvsect<rvector,l_ivector,l_ivector>(rv1,rv2); }
1343 #if(CXSC_INDEX_CHECK) 1344 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1348 {
return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1350 #if(CXSC_INDEX_CHECK) 1351 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1355 {
return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1357 #if(CXSC_INDEX_CHECK) 1358 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1362 {
return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1365 #if(CXSC_INDEX_CHECK) 1366 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1370 {
return _vvsect<rvector,l_ivector,l_ivector>(rv2,rv1); }
1372 #if(CXSC_INDEX_CHECK) 1373 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1377 {
return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1379 #if(CXSC_INDEX_CHECK) 1380 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1384 {
return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1386 #if(CXSC_INDEX_CHECK) 1387 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1391 {
return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1394 #if(CXSC_INDEX_CHECK) 1395 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1399 {
return _vvsectassign(rv1,rv2); }
1401 #if(CXSC_INDEX_CHECK) 1402 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1406 {
return _vvssectassign(rv,sl); }
1408 #if(CXSC_INDEX_CHECK) 1409 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1413 {
return _vsvsectassign(*
this,rv); }
1415 #if(CXSC_INDEX_CHECK) 1416 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1420 {
return _vsvssectassign(*
this,sl2); }
1428 #if(CXSC_INDEX_CHECK) 1429 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1433 {
return _vsvassign(*
this,rv); }
1436 #if(CXSC_INDEX_CHECK) 1437 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1441 {
return _vsvsassign(*
this,sl); }
1444 #if(CXSC_INDEX_CHECK) 1445 throw(OP_WITH_WRONG_DIM)
1449 { _vvaccu(dp,rv1,rv2); }
1451 #if(CXSC_INDEX_CHECK) 1452 throw(OP_WITH_WRONG_DIM)
1456 { _vvaccu(dp,rv2,rv1); }
1458 #if(CXSC_INDEX_CHECK) 1459 throw(OP_WITH_WRONG_DIM)
1463 { _vsvaccu(dp,sl,rv); }
1465 #if(CXSC_INDEX_CHECK) 1466 throw(OP_WITH_WRONG_DIM)
1470 { _vsvaccu(dp,sl,rv); }
1472 #if(CXSC_INDEX_CHECK) 1473 throw(OP_WITH_WRONG_DIM)
1477 { _vsvaccu(dp,sl,rv); }
1478 INLINE
void accumulate(idotprecision &dp,
const l_rvector & rv1,
const l_imatrix_subv &rv2)
1479 #if(CXSC_INDEX_CHECK) 1480 throw(OP_WITH_WRONG_DIM)
1485 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const rmatrix_subv &rv2)
1486 #if(CXSC_INDEX_CHECK) 1487 throw(OP_WITH_WRONG_DIM)
1493 #if(CXSC_INDEX_CHECK) 1494 throw(OP_WITH_WRONG_DIM)
1498 { _vsvaccu(dp,sl,rv); }
1499 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_ivector &rv2)
1500 #if(CXSC_INDEX_CHECK) 1501 throw(OP_WITH_WRONG_DIM)
1506 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const l_rvector &rv2)
1507 #if(CXSC_INDEX_CHECK) 1508 throw(OP_WITH_WRONG_DIM)
1514 #if(CXSC_INDEX_CHECK) 1515 throw(OP_WITH_WRONG_DIM)
1519 { _vsvsaccu(dp,sl2,sl1); }
1521 #if(CXSC_INDEX_CHECK) 1522 throw(OP_WITH_WRONG_DIM)
1526 { _vsvsaccu(dp,sl1,sl2); }
1529 #if(CXSC_INDEX_CHECK) 1530 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1534 {
return _vvlimult<l_rvector,l_ivector,l_interval>(rv1,rv2); }
1536 #if(CXSC_INDEX_CHECK) 1537 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1541 {
return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1543 #if(CXSC_INDEX_CHECK) 1544 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1548 {
return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1550 #if(CXSC_INDEX_CHECK) 1551 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1555 {
return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1558 #if(CXSC_INDEX_CHECK) 1559 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1563 {
return _vvlimult<l_rvector,l_ivector,l_interval>(rv2,rv1); }
1565 #if(CXSC_INDEX_CHECK) 1566 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1570 {
return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1572 #if(CXSC_INDEX_CHECK) 1573 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1577 {
return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1579 #if(CXSC_INDEX_CHECK) 1580 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1584 {
return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1587 #if(CXSC_INDEX_CHECK) 1588 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1592 {
return _vvplus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1594 #if(CXSC_INDEX_CHECK) 1595 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1599 {
return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1601 #if(CXSC_INDEX_CHECK) 1602 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1606 {
return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1608 #if(CXSC_INDEX_CHECK) 1609 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1613 {
return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1616 #if(CXSC_INDEX_CHECK) 1617 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1621 {
return _vvplus<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1623 #if(CXSC_INDEX_CHECK) 1624 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1628 {
return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1630 #if(CXSC_INDEX_CHECK) 1631 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1635 {
return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1637 #if(CXSC_INDEX_CHECK) 1638 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1642 {
return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1645 #if(CXSC_INDEX_CHECK) 1646 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1650 {
return _vvplusassign(rv1,rv2); }
1652 #if(CXSC_INDEX_CHECK) 1653 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1657 {
return _vvsplusassign(rv,sl); }
1659 #if(CXSC_INDEX_CHECK) 1660 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1664 {
return _vsvplusassign(*
this,rv); }
1666 #if(CXSC_INDEX_CHECK) 1667 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1671 {
return _vsvsplusassign(*
this,sl2); }
1674 #if(CXSC_INDEX_CHECK) 1675 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1679 {
return _vvminus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1681 #if(CXSC_INDEX_CHECK) 1682 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1686 {
return _vvsminus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1688 #if(CXSC_INDEX_CHECK) 1689 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1693 {
return _vsvminus<l_rvector_slice,l_ivector,l_ivector>(sl,rv); }
1695 #if(CXSC_INDEX_CHECK) 1696 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1700 {
return _vsvsminus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1703 #if(CXSC_INDEX_CHECK) 1704 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1708 {
return _vvminus<l_ivector,l_rvector,l_ivector>(rv1,rv2); }
1710 #if(CXSC_INDEX_CHECK) 1711 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1715 {
return _vvsminus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1717 #if(CXSC_INDEX_CHECK) 1718 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1722 {
return _vsvminus<l_ivector_slice,l_rvector,l_ivector>(sl,rv); }
1724 #if(CXSC_INDEX_CHECK) 1725 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1729 {
return _vsvsminus<l_ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
1732 #if(CXSC_INDEX_CHECK) 1733 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1737 {
return _vvminusassign(rv1,rv2); }
1739 #if(CXSC_INDEX_CHECK) 1740 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1744 {
return _vvsminusassign(rv,sl); }
1746 #if(CXSC_INDEX_CHECK) 1747 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1751 {
return _vsvminusassign(*
this,rv); }
1753 #if(CXSC_INDEX_CHECK) 1754 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1758 {
return _vsvsminusassign(*
this,sl2); }
1761 #if(CXSC_INDEX_CHECK) 1762 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1766 {
return _vvconv<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1768 #if(CXSC_INDEX_CHECK) 1769 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1773 {
return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1775 #if(CXSC_INDEX_CHECK) 1776 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1780 {
return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1782 #if(CXSC_INDEX_CHECK) 1783 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1787 {
return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1790 #if(CXSC_INDEX_CHECK) 1791 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1795 {
return _vvconv<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1797 #if(CXSC_INDEX_CHECK) 1798 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1802 {
return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1804 #if(CXSC_INDEX_CHECK) 1805 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1809 {
return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1811 #if(CXSC_INDEX_CHECK) 1812 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1816 {
return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1819 #if(CXSC_INDEX_CHECK) 1820 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1824 {
return _vvconvassign(rv1,rv2); }
1826 #if(CXSC_INDEX_CHECK) 1827 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1831 {
return _vvsconvassign(rv,sl); }
1833 #if(CXSC_INDEX_CHECK) 1834 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1838 {
return _vsvconvassign(*
this,rv); }
1840 #if(CXSC_INDEX_CHECK) 1841 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1845 {
return _vsvsconvassign(*
this,sl2); }
1848 #if(CXSC_INDEX_CHECK) 1849 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1853 {
return _vvsect<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1855 #if(CXSC_INDEX_CHECK) 1856 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1860 {
return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1862 #if(CXSC_INDEX_CHECK) 1863 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1867 {
return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1869 #if(CXSC_INDEX_CHECK) 1870 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1874 {
return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1877 #if(CXSC_INDEX_CHECK) 1878 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1882 {
return _vvsect<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1884 #if(CXSC_INDEX_CHECK) 1885 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1889 {
return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1891 #if(CXSC_INDEX_CHECK) 1892 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1896 {
return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1898 #if(CXSC_INDEX_CHECK) 1899 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1903 {
return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1906 #if(CXSC_INDEX_CHECK) 1907 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1911 {
return _vvsectassign(rv1,rv2); }
1913 #if(CXSC_INDEX_CHECK) 1914 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1918 {
return _vvssectassign(rv,sl); }
1920 #if(CXSC_INDEX_CHECK) 1921 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1925 {
return _vsvsectassign(*
this,rv); }
1927 #if(CXSC_INDEX_CHECK) 1928 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1932 {
return _vsvssectassign(*
this,sl2); }
1940 #if(CXSC_INDEX_CHECK) 1941 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1945 {
return _vsvassign(*
this,rv); }
1948 #if(CXSC_INDEX_CHECK) 1949 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
1953 {
return _vsvsassign(*
this,sl); }
1956 #if(CXSC_INDEX_CHECK) 1957 throw(OP_WITH_WRONG_DIM)
1961 { _vvaccu(dp,rv1,rv2); }
1963 #if(CXSC_INDEX_CHECK) 1964 throw(OP_WITH_WRONG_DIM)
1968 { _vvaccu(dp,rv2,rv1); }
1970 #if(CXSC_INDEX_CHECK) 1971 throw(OP_WITH_WRONG_DIM)
1975 { _vsvaccu(dp,sl,rv); }
1977 #if(CXSC_INDEX_CHECK) 1978 throw(OP_WITH_WRONG_DIM)
1982 { _vsvaccu(dp,sl,rv); }
1984 #if(CXSC_INDEX_CHECK) 1985 throw(OP_WITH_WRONG_DIM)
1989 { _vsvaccu(dp,sl,rv); }
1990 INLINE
void accumulate(idotprecision &dp,
const ivector & rv1,
const l_imatrix_subv &rv2)
1991 #if(CXSC_INDEX_CHECK) 1992 throw(OP_WITH_WRONG_DIM)
1997 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const rmatrix_subv &rv2)
1998 #if(CXSC_INDEX_CHECK) 1999 throw(OP_WITH_WRONG_DIM)
2005 #if(CXSC_INDEX_CHECK) 2006 throw(OP_WITH_WRONG_DIM)
2010 { _vsvaccu(dp,sl,rv); }
2011 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_ivector &rv2)
2012 #if(CXSC_INDEX_CHECK) 2013 throw(OP_WITH_WRONG_DIM)
2018 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const ivector &rv2)
2019 #if(CXSC_INDEX_CHECK) 2020 throw(OP_WITH_WRONG_DIM)
2026 #if(CXSC_INDEX_CHECK) 2027 throw(OP_WITH_WRONG_DIM)
2031 { _vsvsaccu(dp,sl2,sl1); }
2033 #if(CXSC_INDEX_CHECK) 2034 throw(OP_WITH_WRONG_DIM)
2038 { _vsvsaccu(dp,sl1,sl2); }
2041 #if(CXSC_INDEX_CHECK) 2042 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2046 {
return _vvlimult<ivector,l_ivector,l_interval>(rv1,rv2); }
2048 #if(CXSC_INDEX_CHECK) 2049 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2053 {
return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2055 #if(CXSC_INDEX_CHECK) 2056 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2060 {
return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2062 #if(CXSC_INDEX_CHECK) 2063 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2067 {
return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
2070 #if(CXSC_INDEX_CHECK) 2071 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2075 {
return _vvlimult<ivector,l_ivector,l_interval>(rv2,rv1); }
2077 #if(CXSC_INDEX_CHECK) 2078 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2082 {
return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2084 #if(CXSC_INDEX_CHECK) 2085 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2089 {
return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2091 #if(CXSC_INDEX_CHECK) 2092 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2096 {
return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
2099 #if(CXSC_INDEX_CHECK) 2100 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2104 {
return _vvplus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2106 #if(CXSC_INDEX_CHECK) 2107 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2111 {
return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2113 #if(CXSC_INDEX_CHECK) 2114 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2118 {
return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2120 #if(CXSC_INDEX_CHECK) 2121 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2125 {
return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2128 #if(CXSC_INDEX_CHECK) 2129 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2133 {
return _vvplus<ivector,l_ivector,l_ivector>(rv2,rv1); }
2135 #if(CXSC_INDEX_CHECK) 2136 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2140 {
return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2142 #if(CXSC_INDEX_CHECK) 2143 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2147 {
return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2149 #if(CXSC_INDEX_CHECK) 2150 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2154 {
return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2157 #if(CXSC_INDEX_CHECK) 2158 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2162 {
return _vvplusassign(rv1,rv2); }
2164 #if(CXSC_INDEX_CHECK) 2165 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2169 {
return _vvsplusassign(rv,sl); }
2171 #if(CXSC_INDEX_CHECK) 2172 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2176 {
return _vsvplusassign(*
this,rv); }
2178 #if(CXSC_INDEX_CHECK) 2179 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2183 {
return _vsvsplusassign(*
this,sl2); }
2186 #if(CXSC_INDEX_CHECK) 2187 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2191 {
return _vvminus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2193 #if(CXSC_INDEX_CHECK) 2194 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2198 {
return _vvsminus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2200 #if(CXSC_INDEX_CHECK) 2201 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2205 {
return _vsvminus<ivector_slice,l_ivector,l_ivector>(sl,rv); }
2207 #if(CXSC_INDEX_CHECK) 2208 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2212 {
return _vsvsminus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2215 #if(CXSC_INDEX_CHECK) 2216 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2220 {
return _vvminus<l_ivector,ivector,l_ivector>(rv1,rv2); }
2222 #if(CXSC_INDEX_CHECK) 2223 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2227 {
return _vvsminus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2229 #if(CXSC_INDEX_CHECK) 2230 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2234 {
return _vsvminus<l_ivector_slice,ivector,l_ivector>(sl,rv); }
2236 #if(CXSC_INDEX_CHECK) 2237 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2241 {
return _vsvsminus<l_ivector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2244 #if(CXSC_INDEX_CHECK) 2245 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2249 {
return _vvminusassign(rv1,rv2); }
2251 #if(CXSC_INDEX_CHECK) 2252 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2256 {
return _vvsminusassign(rv,sl); }
2258 #if(CXSC_INDEX_CHECK) 2259 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2263 {
return _vsvminusassign(*
this,rv); }
2265 #if(CXSC_INDEX_CHECK) 2266 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2270 {
return _vsvsminusassign(*
this,sl2); }
2273 #if(CXSC_INDEX_CHECK) 2274 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2278 {
return _vvconv<ivector,l_ivector,l_ivector>(rv1,rv2); }
2280 #if(CXSC_INDEX_CHECK) 2281 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2285 {
return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2287 #if(CXSC_INDEX_CHECK) 2288 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2292 {
return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2294 #if(CXSC_INDEX_CHECK) 2295 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2299 {
return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2302 #if(CXSC_INDEX_CHECK) 2303 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2307 {
return _vvconv<ivector,l_ivector,l_ivector>(rv2,rv1); }
2309 #if(CXSC_INDEX_CHECK) 2310 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2314 {
return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2316 #if(CXSC_INDEX_CHECK) 2317 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2321 {
return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2323 #if(CXSC_INDEX_CHECK) 2324 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2328 {
return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2331 #if(CXSC_INDEX_CHECK) 2332 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2336 {
return _vvconvassign(rv1,rv2); }
2338 #if(CXSC_INDEX_CHECK) 2339 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2343 {
return _vvsconvassign(rv,sl); }
2345 #if(CXSC_INDEX_CHECK) 2346 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2350 {
return _vsvconvassign(*
this,rv); }
2352 #if(CXSC_INDEX_CHECK) 2353 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2357 {
return _vsvsconvassign(*
this,sl2); }
2360 #if(CXSC_INDEX_CHECK) 2361 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2365 {
return _vvsect<ivector,l_ivector,l_ivector>(rv1,rv2); }
2367 #if(CXSC_INDEX_CHECK) 2368 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2372 {
return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2374 #if(CXSC_INDEX_CHECK) 2375 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2379 {
return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2381 #if(CXSC_INDEX_CHECK) 2382 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2386 {
return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2389 #if(CXSC_INDEX_CHECK) 2390 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2394 {
return _vvsect<ivector,l_ivector,l_ivector>(rv2,rv1); }
2396 #if(CXSC_INDEX_CHECK) 2397 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2401 {
return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2403 #if(CXSC_INDEX_CHECK) 2404 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2408 {
return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2410 #if(CXSC_INDEX_CHECK) 2411 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2415 {
return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2418 #if(CXSC_INDEX_CHECK) 2419 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2423 {
return _vvsectassign(rv1,rv2); }
2425 #if(CXSC_INDEX_CHECK) 2426 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2430 {
return _vvssectassign(rv,sl); }
2432 #if(CXSC_INDEX_CHECK) 2433 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2437 {
return _vsvsectassign(*
this,rv); }
2439 #if(CXSC_INDEX_CHECK) 2440 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2444 {
return _vsvssectassign(*
this,sl2); }
2448 #if(CXSC_INDEX_CHECK) 2449 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2453 {
return _vvconv<rvector,l_rvector,l_ivector>(rv1,rv2); }
2455 #if(CXSC_INDEX_CHECK) 2456 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2460 {
return _vvconv<rvector,l_rvector,l_ivector>(rv2,rv1); }
2462 #if(CXSC_INDEX_CHECK) 2463 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2467 {
return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2469 #if(CXSC_INDEX_CHECK) 2470 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2474 {
return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2476 #if(CXSC_INDEX_CHECK) 2477 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2481 {
return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2483 #if(CXSC_INDEX_CHECK) 2484 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2488 {
return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2490 #if(CXSC_INDEX_CHECK) 2491 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2495 {
return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl2,sl1); }
2497 #if(CXSC_INDEX_CHECK) 2498 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2502 {
return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2506 #if(CXSC_INDEX_CHECK) 2507 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2511 {
return _vvconv<l_rvector,l_rvector,l_ivector>(rv2,rv1); }
2513 #if(CXSC_INDEX_CHECK) 2514 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2518 {
return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2520 #if(CXSC_INDEX_CHECK) 2521 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2525 {
return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2527 #if(CXSC_INDEX_CHECK) 2528 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2532 {
return _vsvsconv<l_rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2538 #if(CXSC_INDEX_CHECK) 2539 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2543 {
return _vvplus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2545 #if(CXSC_INDEX_CHECK) 2546 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2550 {
return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2552 #if(CXSC_INDEX_CHECK) 2553 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2557 {
return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2559 #if(CXSC_INDEX_CHECK) 2560 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2564 {
return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2567 #if(CXSC_INDEX_CHECK) 2568 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2572 {
return _vvplus<l_rvector,ivector,l_ivector>(rv2,rv1); }
2574 #if(CXSC_INDEX_CHECK) 2575 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2579 {
return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2581 #if(CXSC_INDEX_CHECK) 2582 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2586 {
return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2588 #if(CXSC_INDEX_CHECK) 2589 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2593 {
return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2596 #if(CXSC_INDEX_CHECK) 2597 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2601 {
return _vvminus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2603 #if(CXSC_INDEX_CHECK) 2604 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2608 {
return _vvsminus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2610 #if(CXSC_INDEX_CHECK) 2611 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2615 {
return _vsvminus<l_rvector_slice,ivector,l_ivector>(sl,rv); }
2617 #if(CXSC_INDEX_CHECK) 2618 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2622 {
return _vsvsminus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2625 #if(CXSC_INDEX_CHECK) 2626 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2630 {
return _vvminus<ivector,l_rvector,l_ivector>(rv1,rv2); }
2632 #if(CXSC_INDEX_CHECK) 2633 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2637 {
return _vvsminus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2639 #if(CXSC_INDEX_CHECK) 2640 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2644 {
return _vsvminus<ivector_slice,l_rvector,l_ivector>(sl,rv); }
2646 #if(CXSC_INDEX_CHECK) 2647 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2651 {
return _vsvsminus<ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2654 #if(CXSC_INDEX_CHECK) 2655 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2659 {
return _vvconv<l_rvector,ivector,l_ivector>(rv1,rv2); }
2661 #if(CXSC_INDEX_CHECK) 2662 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2666 {
return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2668 #if(CXSC_INDEX_CHECK) 2669 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2673 {
return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2675 #if(CXSC_INDEX_CHECK) 2676 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2680 {
return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2683 #if(CXSC_INDEX_CHECK) 2684 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2688 {
return _vvconv<l_rvector,ivector,l_ivector>(rv2,rv1); }
2690 #if(CXSC_INDEX_CHECK) 2691 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2695 {
return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2697 #if(CXSC_INDEX_CHECK) 2698 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2702 {
return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2704 #if(CXSC_INDEX_CHECK) 2705 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2709 {
return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2712 #if(CXSC_INDEX_CHECK) 2713 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2717 {
return _vvsect<l_rvector,ivector,l_ivector>(rv1,rv2); }
2719 #if(CXSC_INDEX_CHECK) 2720 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2724 {
return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2726 #if(CXSC_INDEX_CHECK) 2727 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2731 {
return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2733 #if(CXSC_INDEX_CHECK) 2734 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2738 {
return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2741 #if(CXSC_INDEX_CHECK) 2742 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2746 {
return _vvsect<l_rvector,ivector,l_ivector>(rv2,rv1); }
2748 #if(CXSC_INDEX_CHECK) 2749 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2753 {
return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2755 #if(CXSC_INDEX_CHECK) 2756 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2760 {
return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2762 #if(CXSC_INDEX_CHECK) 2763 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
2767 {
return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2771 #endif // _CXSC_LIVECTOR_INL_INCLUDED The Multiple-Precision Data Type l_interval.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
The Data Type idotprecision.
The Multiple-Precision Data Type l_real.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
l_ivector & operator=(const l_ivector &rv)
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_ivector_slice.
The namespace cxsc, providing all functionality of the class library C-XSC.
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
l_ivector_slice & operator/=(const l_interval &r)
Implementation of division and allocation operation.
l_ivector_slice & operator*=(const l_interval &r)
Implementation of multiplication and allocation operation.
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
The Scalar Type interval.
l_ivector()
Constructor of class l_ivector.
l_ivector_slice & operator&=(const l_ivector &rv)
Allocates the intersection of the arguments to the first argument.
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
The Multiple-Precision Data Type l_ivector.
The Data Type ivector_slice.
The Data Type rvector_slice.
l_ivector _l_ivector(const l_interval &r)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
l_interval()
Constructor of class l_interval.
void Resize(cimatrix &A)
Resizes the matrix.
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
l_ivector_slice & operator-=(const l_ivector &rv)
Implementation of subtraction and allocation operation.
l_ivector_slice & operator=(const l_ivector_slice &sl)
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_rvector.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
l_ivector_slice & operator+=(const l_ivector &rv)
Implementation of addition and allocation operation.
l_ivector & operator()()
Operator for accessing the whole vector.
l_ivector_slice & operator|=(const l_ivector &rv)
Allocates the convex hull of the arguments to the first argument.
l_ivector_slice & operator()()
Operator for accessing the whole vector.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
The Multiple-Precision Data Type l_rvector_slice.
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.