26#ifndef _CXSC_LIVECTOR_INL_INCLUDED
27#define _CXSC_LIVECTOR_INL_INCLUDED
49 :l(i1),u(i2),size(i2-i1+1)
51 noexcept: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++)
149 if(i<l||i>u) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC(
"l_interval & l_ivector::operator [](const int &i)"));
162 if(i<start||i>end) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC(
"l_interval & l_ivector_slice::operator [](const int &i)"));
175 if(1<l||i>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_ivector_slice l_ivector::operator ()(const int &i)"));
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)"));
201 if(1<start||i>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG(
"l_ivector_slice l_ivector_slice::operator ()(const int &i)"));
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)"));
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)"));
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*()
noexcept {
return _vvoid(*
this); }
320 {
return _vsvsassign(*
this,sl); }
327 {
return _vsvassign(*
this,rv); }
329 INLINE l_ivector_slice::operator
void*()
noexcept {
return _vsvoid(*
this); }
341 {
return _vvsetinf(iv,rv); }
348 {
return _vsvsetinf(iv,rv); }
355 {
return _vvssetinf(iv,rv); }
362 {
return _vsvssetinf(iv,rv); }
369 {
return _vvusetinf(iv,rv); }
376 {
return _vsvusetinf(iv,rv); }
383 {
return _vvsusetinf(iv,rv); }
390 {
return _vsvsusetinf(iv,rv); }
398 {
return _vvsetsup(iv,rv); }
405 {
return _vsvsetsup(iv,rv); }
412 {
return _vvssetsup(iv,rv); }
419 {
return _vsvssetsup(iv,rv); }
426 {
return _vvusetsup(iv,rv); }
433 {
return _vsvusetsup(iv,rv); }
440 {
return _vvsusetsup(iv,rv); }
447 {
return _vsvsusetsup(iv,rv); }
466 { _vresize<class l_ivector,class l_interval>(rv,len); }
473 { _vresize<class l_ivector,class l_interval>(rv,lb,ub); }
485 INLINE
bool operator !(
const l_ivector &rv)
noexcept {
return _vnot(rv); }
573 INLINE std::ostream &operator <<(std::ostream &s,
const l_ivector &rv)
noexcept {
return _vout(s,rv); }
574 INLINE std::ostream &operator <<(std::ostream &o,
const l_ivector_slice &sl)
noexcept {
return _vsout(o,sl); }
575 INLINE std::istream &operator >>(std::istream &s,
l_ivector &rv)
noexcept {
return _vin(s,rv); }
576 INLINE std::istream &operator >>(std::istream &s,
l_ivector_slice &rv)
noexcept {
return _vsin(s,rv); }
587 { _vvaccu(dp,rv1,rv2); }
594 { _vsvaccu(dp,sl,rv); }
601 { _vsvaccu(dp,sl,rv); }
602 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const l_imatrix_subv &rv2)
609 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const l_ivector &rv2)
622 { _vsvsaccu(dp,sl1,sl2); }
630 {
return _vvlimult<l_ivector,l_ivector,l_interval>(rv1,rv2); }
637 {
return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
644 {
return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
651 {
return _vsvslimult<l_ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
661 {
return _vvplus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
668 {
return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
675 {
return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
682 {
return _vsvsplus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
689 {
return _vvplusassign(rv1,rv2); }
696 {
return _vvsplusassign(rv,sl); }
703 {
return _vsvplusassign(*
this,rv); }
710 {
return _vsvsplusassign(*
this,sl2); }
720 {
return _vvminus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
727 {
return _vvsminus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
734 {
return _vsvminus<l_ivector_slice,l_ivector,l_ivector>(sl,rv); }
741 {
return _vsvsminus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
748 {
return _vvminusassign(rv1,rv2); }
755 {
return _vvsminusassign(rv,sl); }
762 {
return _vsvminusassign(*
this,rv); }
769 {
return _vsvsminusassign(*
this,sl2); }
777 {
return _vvconv<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
784 {
return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
791 {
return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
798 {
return _vsvsconv<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
805 {
return _vvconvassign(rv1,rv2); }
812 {
return _vvsconvassign(rv,sl); }
819 {
return _vsvconvassign(*
this,rv); }
826 {
return _vsvsconvassign(*
this,sl2); }
834 {
return _vvsect<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
841 {
return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
848 {
return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
855 {
return _vsvssect<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
862 {
return _vvsectassign(rv1,rv2); }
869 {
return _vvssectassign(rv,sl); }
876 {
return _vsvsectassign(*
this,rv); }
883 {
return _vsvssectassign(*
this,sl2); }
885 INLINE
bool operator ==(
const l_ivector &rv1,
const l_ivector &rv2)
noexcept {
return _vveq(rv1,rv2); }
889 INLINE
bool operator !=(
const l_ivector &rv1,
const l_ivector &rv2)
noexcept {
return _vvneq(rv1,rv2); }
893 INLINE
bool operator <(
const l_ivector &rv1,
const l_ivector &rv2)
noexcept {
return _vvless(rv1,rv2); }
897 INLINE
bool operator <=(
const l_ivector &rv1,
const l_ivector &rv2)
noexcept {
return _vvleq(rv1,rv2); }
901 INLINE
bool operator >(
const l_ivector &rv1,
const l_ivector &rv2)
noexcept {
return _vvless(rv2,rv1); }
905 INLINE
bool operator >=(
const l_ivector &rv1,
const l_ivector &rv2)
noexcept {
return _vvleq(rv2,rv1); }
921 {
return _vsvassign(*
this,rv); }
929 {
return _vsvsassign(*
this,sl); }
937 { _vvaccu(dp,rv1,rv2); }
944 { _vvaccu(dp,rv2,rv1); }
951 { _vsvaccu(dp,sl,rv); }
958 { _vsvaccu(dp,sl,rv); }
965 { _vsvaccu(dp,sl,rv); }
966 INLINE
void accumulate(idotprecision &dp,
const rvector & rv1,
const l_imatrix_subv &rv2)
973 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const rmatrix_subv &rv2)
986 { _vsvaccu(dp,sl,rv); }
987 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_ivector &rv2)
994 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const rvector &rv2)
1002#if(CXSC_INDEX_CHECK)
1007 { _vsvsaccu(dp,sl2,sl1); }
1009#if(CXSC_INDEX_CHECK)
1014 { _vsvsaccu(dp,sl1,sl2); }
1017#if(CXSC_INDEX_CHECK)
1022 {
return _vvlimult<rvector,l_ivector,l_interval>(rv1,rv2); }
1024#if(CXSC_INDEX_CHECK)
1029 {
return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1031#if(CXSC_INDEX_CHECK)
1036 {
return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1038#if(CXSC_INDEX_CHECK)
1043 {
return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1046#if(CXSC_INDEX_CHECK)
1051 {
return _vvlimult<rvector,l_ivector,l_interval>(rv2,rv1); }
1053#if(CXSC_INDEX_CHECK)
1058 {
return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1060#if(CXSC_INDEX_CHECK)
1065 {
return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1067#if(CXSC_INDEX_CHECK)
1072 {
return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1075#if(CXSC_INDEX_CHECK)
1080 {
return _vvplus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1082#if(CXSC_INDEX_CHECK)
1087 {
return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1089#if(CXSC_INDEX_CHECK)
1094 {
return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1096#if(CXSC_INDEX_CHECK)
1101 {
return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1104#if(CXSC_INDEX_CHECK)
1109 {
return _vvplus<rvector,l_ivector,l_ivector>(rv2,rv1); }
1111#if(CXSC_INDEX_CHECK)
1116 {
return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1118#if(CXSC_INDEX_CHECK)
1123 {
return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1125#if(CXSC_INDEX_CHECK)
1130 {
return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1133#if(CXSC_INDEX_CHECK)
1138 {
return _vvplusassign(rv1,rv2); }
1140#if(CXSC_INDEX_CHECK)
1145 {
return _vvsplusassign(rv,sl); }
1147#if(CXSC_INDEX_CHECK)
1152 {
return _vsvplusassign(*
this,rv); }
1154#if(CXSC_INDEX_CHECK)
1159 {
return _vsvsplusassign(*
this,sl2); }
1162#if(CXSC_INDEX_CHECK)
1167 {
return _vvminus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1169#if(CXSC_INDEX_CHECK)
1174 {
return _vvsminus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1176#if(CXSC_INDEX_CHECK)
1181 {
return _vsvminus<rvector_slice,l_ivector,l_ivector>(sl,rv); }
1183#if(CXSC_INDEX_CHECK)
1188 {
return _vsvsminus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1191#if(CXSC_INDEX_CHECK)
1196 {
return _vvminus<l_ivector,rvector,l_ivector>(rv1,rv2); }
1198#if(CXSC_INDEX_CHECK)
1203 {
return _vvsminus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1205#if(CXSC_INDEX_CHECK)
1210 {
return _vsvminus<l_ivector_slice,rvector,l_ivector>(sl,rv); }
1212#if(CXSC_INDEX_CHECK)
1217 {
return _vsvsminus<l_ivector_slice,rvector_slice,l_ivector>(sl1,sl2); }
1220#if(CXSC_INDEX_CHECK)
1225 {
return _vvminusassign(rv1,rv2); }
1227#if(CXSC_INDEX_CHECK)
1232 {
return _vvsminusassign(rv,sl); }
1234#if(CXSC_INDEX_CHECK)
1239 {
return _vsvminusassign(*
this,rv); }
1241#if(CXSC_INDEX_CHECK)
1246 {
return _vsvsminusassign(*
this,sl2); }
1249#if(CXSC_INDEX_CHECK)
1254 {
return _vvconv<rvector,l_ivector,l_ivector>(rv1,rv2); }
1256#if(CXSC_INDEX_CHECK)
1261 {
return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1263#if(CXSC_INDEX_CHECK)
1268 {
return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1270#if(CXSC_INDEX_CHECK)
1275 {
return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1278#if(CXSC_INDEX_CHECK)
1283 {
return _vvconv<rvector,l_ivector,l_ivector>(rv2,rv1); }
1285#if(CXSC_INDEX_CHECK)
1290 {
return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1292#if(CXSC_INDEX_CHECK)
1297 {
return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1299#if(CXSC_INDEX_CHECK)
1304 {
return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1307#if(CXSC_INDEX_CHECK)
1312 {
return _vvconvassign(rv1,rv2); }
1314#if(CXSC_INDEX_CHECK)
1319 {
return _vvsconvassign(rv,sl); }
1321#if(CXSC_INDEX_CHECK)
1326 {
return _vsvconvassign(*
this,rv); }
1328#if(CXSC_INDEX_CHECK)
1333 {
return _vsvsconvassign(*
this,sl2); }
1336#if(CXSC_INDEX_CHECK)
1341 {
return _vvsect<rvector,l_ivector,l_ivector>(rv1,rv2); }
1343#if(CXSC_INDEX_CHECK)
1348 {
return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1350#if(CXSC_INDEX_CHECK)
1355 {
return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1357#if(CXSC_INDEX_CHECK)
1362 {
return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1365#if(CXSC_INDEX_CHECK)
1370 {
return _vvsect<rvector,l_ivector,l_ivector>(rv2,rv1); }
1372#if(CXSC_INDEX_CHECK)
1377 {
return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1379#if(CXSC_INDEX_CHECK)
1384 {
return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1386#if(CXSC_INDEX_CHECK)
1391 {
return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1394#if(CXSC_INDEX_CHECK)
1399 {
return _vvsectassign(rv1,rv2); }
1401#if(CXSC_INDEX_CHECK)
1406 {
return _vvssectassign(rv,sl); }
1408#if(CXSC_INDEX_CHECK)
1413 {
return _vsvsectassign(*
this,rv); }
1415#if(CXSC_INDEX_CHECK)
1420 {
return _vsvssectassign(*
this,sl2); }
1428#if(CXSC_INDEX_CHECK)
1433 {
return _vsvassign(*
this,rv); }
1436#if(CXSC_INDEX_CHECK)
1441 {
return _vsvsassign(*
this,sl); }
1444#if(CXSC_INDEX_CHECK)
1449 { _vvaccu(dp,rv1,rv2); }
1451#if(CXSC_INDEX_CHECK)
1456 { _vvaccu(dp,rv2,rv1); }
1458#if(CXSC_INDEX_CHECK)
1463 { _vsvaccu(dp,sl,rv); }
1465#if(CXSC_INDEX_CHECK)
1470 { _vsvaccu(dp,sl,rv); }
1472#if(CXSC_INDEX_CHECK)
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)
1485 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const rmatrix_subv &rv2)
1486#if(CXSC_INDEX_CHECK)
1493#if(CXSC_INDEX_CHECK)
1498 { _vsvaccu(dp,sl,rv); }
1499 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_ivector &rv2)
1500#if(CXSC_INDEX_CHECK)
1506 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const l_rvector &rv2)
1507#if(CXSC_INDEX_CHECK)
1514#if(CXSC_INDEX_CHECK)
1519 { _vsvsaccu(dp,sl2,sl1); }
1521#if(CXSC_INDEX_CHECK)
1526 { _vsvsaccu(dp,sl1,sl2); }
1529#if(CXSC_INDEX_CHECK)
1534 {
return _vvlimult<l_rvector,l_ivector,l_interval>(rv1,rv2); }
1536#if(CXSC_INDEX_CHECK)
1541 {
return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1543#if(CXSC_INDEX_CHECK)
1548 {
return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1550#if(CXSC_INDEX_CHECK)
1555 {
return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1558#if(CXSC_INDEX_CHECK)
1563 {
return _vvlimult<l_rvector,l_ivector,l_interval>(rv2,rv1); }
1565#if(CXSC_INDEX_CHECK)
1570 {
return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1572#if(CXSC_INDEX_CHECK)
1577 {
return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1579#if(CXSC_INDEX_CHECK)
1584 {
return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1587#if(CXSC_INDEX_CHECK)
1592 {
return _vvplus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1594#if(CXSC_INDEX_CHECK)
1599 {
return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1601#if(CXSC_INDEX_CHECK)
1606 {
return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1608#if(CXSC_INDEX_CHECK)
1613 {
return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1616#if(CXSC_INDEX_CHECK)
1621 {
return _vvplus<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1623#if(CXSC_INDEX_CHECK)
1628 {
return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1630#if(CXSC_INDEX_CHECK)
1635 {
return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1637#if(CXSC_INDEX_CHECK)
1642 {
return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1645#if(CXSC_INDEX_CHECK)
1650 {
return _vvplusassign(rv1,rv2); }
1652#if(CXSC_INDEX_CHECK)
1657 {
return _vvsplusassign(rv,sl); }
1659#if(CXSC_INDEX_CHECK)
1664 {
return _vsvplusassign(*
this,rv); }
1666#if(CXSC_INDEX_CHECK)
1671 {
return _vsvsplusassign(*
this,sl2); }
1674#if(CXSC_INDEX_CHECK)
1679 {
return _vvminus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1681#if(CXSC_INDEX_CHECK)
1686 {
return _vvsminus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1688#if(CXSC_INDEX_CHECK)
1693 {
return _vsvminus<l_rvector_slice,l_ivector,l_ivector>(sl,rv); }
1695#if(CXSC_INDEX_CHECK)
1700 {
return _vsvsminus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1703#if(CXSC_INDEX_CHECK)
1708 {
return _vvminus<l_ivector,l_rvector,l_ivector>(rv1,rv2); }
1710#if(CXSC_INDEX_CHECK)
1715 {
return _vvsminus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1717#if(CXSC_INDEX_CHECK)
1722 {
return _vsvminus<l_ivector_slice,l_rvector,l_ivector>(sl,rv); }
1724#if(CXSC_INDEX_CHECK)
1729 {
return _vsvsminus<l_ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
1732#if(CXSC_INDEX_CHECK)
1737 {
return _vvminusassign(rv1,rv2); }
1739#if(CXSC_INDEX_CHECK)
1744 {
return _vvsminusassign(rv,sl); }
1746#if(CXSC_INDEX_CHECK)
1751 {
return _vsvminusassign(*
this,rv); }
1753#if(CXSC_INDEX_CHECK)
1758 {
return _vsvsminusassign(*
this,sl2); }
1761#if(CXSC_INDEX_CHECK)
1766 {
return _vvconv<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1768#if(CXSC_INDEX_CHECK)
1773 {
return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1775#if(CXSC_INDEX_CHECK)
1780 {
return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1782#if(CXSC_INDEX_CHECK)
1787 {
return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1790#if(CXSC_INDEX_CHECK)
1795 {
return _vvconv<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1797#if(CXSC_INDEX_CHECK)
1802 {
return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1804#if(CXSC_INDEX_CHECK)
1809 {
return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1811#if(CXSC_INDEX_CHECK)
1816 {
return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1819#if(CXSC_INDEX_CHECK)
1824 {
return _vvconvassign(rv1,rv2); }
1826#if(CXSC_INDEX_CHECK)
1831 {
return _vvsconvassign(rv,sl); }
1833#if(CXSC_INDEX_CHECK)
1838 {
return _vsvconvassign(*
this,rv); }
1840#if(CXSC_INDEX_CHECK)
1845 {
return _vsvsconvassign(*
this,sl2); }
1848#if(CXSC_INDEX_CHECK)
1853 {
return _vvsect<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1855#if(CXSC_INDEX_CHECK)
1860 {
return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1862#if(CXSC_INDEX_CHECK)
1867 {
return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1869#if(CXSC_INDEX_CHECK)
1874 {
return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1877#if(CXSC_INDEX_CHECK)
1882 {
return _vvsect<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1884#if(CXSC_INDEX_CHECK)
1889 {
return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1891#if(CXSC_INDEX_CHECK)
1896 {
return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1898#if(CXSC_INDEX_CHECK)
1903 {
return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1906#if(CXSC_INDEX_CHECK)
1911 {
return _vvsectassign(rv1,rv2); }
1913#if(CXSC_INDEX_CHECK)
1918 {
return _vvssectassign(rv,sl); }
1920#if(CXSC_INDEX_CHECK)
1925 {
return _vsvsectassign(*
this,rv); }
1927#if(CXSC_INDEX_CHECK)
1932 {
return _vsvssectassign(*
this,sl2); }
1940#if(CXSC_INDEX_CHECK)
1945 {
return _vsvassign(*
this,rv); }
1948#if(CXSC_INDEX_CHECK)
1953 {
return _vsvsassign(*
this,sl); }
1956#if(CXSC_INDEX_CHECK)
1961 { _vvaccu(dp,rv1,rv2); }
1963#if(CXSC_INDEX_CHECK)
1968 { _vvaccu(dp,rv2,rv1); }
1970#if(CXSC_INDEX_CHECK)
1975 { _vsvaccu(dp,sl,rv); }
1977#if(CXSC_INDEX_CHECK)
1982 { _vsvaccu(dp,sl,rv); }
1984#if(CXSC_INDEX_CHECK)
1989 { _vsvaccu(dp,sl,rv); }
1990 INLINE
void accumulate(idotprecision &dp,
const ivector & rv1,
const l_imatrix_subv &rv2)
1991#if(CXSC_INDEX_CHECK)
1997 INLINE
void accumulate(idotprecision &dp,
const l_ivector & rv1,
const rmatrix_subv &rv2)
1998#if(CXSC_INDEX_CHECK)
2005#if(CXSC_INDEX_CHECK)
2010 { _vsvaccu(dp,sl,rv); }
2011 INLINE
void accumulate(idotprecision &dp,
const rmatrix_subv & rv1,
const l_ivector &rv2)
2012#if(CXSC_INDEX_CHECK)
2018 INLINE
void accumulate(idotprecision &dp,
const l_imatrix_subv & rv1,
const ivector &rv2)
2019#if(CXSC_INDEX_CHECK)
2026#if(CXSC_INDEX_CHECK)
2031 { _vsvsaccu(dp,sl2,sl1); }
2033#if(CXSC_INDEX_CHECK)
2038 { _vsvsaccu(dp,sl1,sl2); }
2041#if(CXSC_INDEX_CHECK)
2046 {
return _vvlimult<ivector,l_ivector,l_interval>(rv1,rv2); }
2048#if(CXSC_INDEX_CHECK)
2053 {
return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2055#if(CXSC_INDEX_CHECK)
2060 {
return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2062#if(CXSC_INDEX_CHECK)
2067 {
return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
2070#if(CXSC_INDEX_CHECK)
2075 {
return _vvlimult<ivector,l_ivector,l_interval>(rv2,rv1); }
2077#if(CXSC_INDEX_CHECK)
2082 {
return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2084#if(CXSC_INDEX_CHECK)
2089 {
return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2091#if(CXSC_INDEX_CHECK)
2096 {
return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
2099#if(CXSC_INDEX_CHECK)
2104 {
return _vvplus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2106#if(CXSC_INDEX_CHECK)
2111 {
return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2113#if(CXSC_INDEX_CHECK)
2118 {
return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2120#if(CXSC_INDEX_CHECK)
2125 {
return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2128#if(CXSC_INDEX_CHECK)
2133 {
return _vvplus<ivector,l_ivector,l_ivector>(rv2,rv1); }
2135#if(CXSC_INDEX_CHECK)
2140 {
return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2142#if(CXSC_INDEX_CHECK)
2147 {
return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2149#if(CXSC_INDEX_CHECK)
2154 {
return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2157#if(CXSC_INDEX_CHECK)
2162 {
return _vvplusassign(rv1,rv2); }
2164#if(CXSC_INDEX_CHECK)
2169 {
return _vvsplusassign(rv,sl); }
2171#if(CXSC_INDEX_CHECK)
2176 {
return _vsvplusassign(*
this,rv); }
2178#if(CXSC_INDEX_CHECK)
2183 {
return _vsvsplusassign(*
this,sl2); }
2186#if(CXSC_INDEX_CHECK)
2191 {
return _vvminus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2193#if(CXSC_INDEX_CHECK)
2198 {
return _vvsminus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2200#if(CXSC_INDEX_CHECK)
2205 {
return _vsvminus<ivector_slice,l_ivector,l_ivector>(sl,rv); }
2207#if(CXSC_INDEX_CHECK)
2212 {
return _vsvsminus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2215#if(CXSC_INDEX_CHECK)
2220 {
return _vvminus<l_ivector,ivector,l_ivector>(rv1,rv2); }
2222#if(CXSC_INDEX_CHECK)
2227 {
return _vvsminus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2229#if(CXSC_INDEX_CHECK)
2234 {
return _vsvminus<l_ivector_slice,ivector,l_ivector>(sl,rv); }
2236#if(CXSC_INDEX_CHECK)
2241 {
return _vsvsminus<l_ivector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2244#if(CXSC_INDEX_CHECK)
2249 {
return _vvminusassign(rv1,rv2); }
2251#if(CXSC_INDEX_CHECK)
2256 {
return _vvsminusassign(rv,sl); }
2258#if(CXSC_INDEX_CHECK)
2263 {
return _vsvminusassign(*
this,rv); }
2265#if(CXSC_INDEX_CHECK)
2270 {
return _vsvsminusassign(*
this,sl2); }
2273#if(CXSC_INDEX_CHECK)
2278 {
return _vvconv<ivector,l_ivector,l_ivector>(rv1,rv2); }
2280#if(CXSC_INDEX_CHECK)
2285 {
return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2287#if(CXSC_INDEX_CHECK)
2292 {
return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2294#if(CXSC_INDEX_CHECK)
2299 {
return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2302#if(CXSC_INDEX_CHECK)
2307 {
return _vvconv<ivector,l_ivector,l_ivector>(rv2,rv1); }
2309#if(CXSC_INDEX_CHECK)
2314 {
return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2316#if(CXSC_INDEX_CHECK)
2321 {
return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2323#if(CXSC_INDEX_CHECK)
2328 {
return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2331#if(CXSC_INDEX_CHECK)
2336 {
return _vvconvassign(rv1,rv2); }
2338#if(CXSC_INDEX_CHECK)
2343 {
return _vvsconvassign(rv,sl); }
2345#if(CXSC_INDEX_CHECK)
2350 {
return _vsvconvassign(*
this,rv); }
2352#if(CXSC_INDEX_CHECK)
2357 {
return _vsvsconvassign(*
this,sl2); }
2360#if(CXSC_INDEX_CHECK)
2365 {
return _vvsect<ivector,l_ivector,l_ivector>(rv1,rv2); }
2367#if(CXSC_INDEX_CHECK)
2372 {
return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2374#if(CXSC_INDEX_CHECK)
2379 {
return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2381#if(CXSC_INDEX_CHECK)
2386 {
return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2389#if(CXSC_INDEX_CHECK)
2394 {
return _vvsect<ivector,l_ivector,l_ivector>(rv2,rv1); }
2396#if(CXSC_INDEX_CHECK)
2401 {
return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2403#if(CXSC_INDEX_CHECK)
2408 {
return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2410#if(CXSC_INDEX_CHECK)
2415 {
return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2418#if(CXSC_INDEX_CHECK)
2423 {
return _vvsectassign(rv1,rv2); }
2425#if(CXSC_INDEX_CHECK)
2430 {
return _vvssectassign(rv,sl); }
2432#if(CXSC_INDEX_CHECK)
2437 {
return _vsvsectassign(*
this,rv); }
2439#if(CXSC_INDEX_CHECK)
2444 {
return _vsvssectassign(*
this,sl2); }
2448#if(CXSC_INDEX_CHECK)
2453 {
return _vvconv<rvector,l_rvector,l_ivector>(rv1,rv2); }
2455#if(CXSC_INDEX_CHECK)
2460 {
return _vvconv<rvector,l_rvector,l_ivector>(rv2,rv1); }
2462#if(CXSC_INDEX_CHECK)
2467 {
return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2469#if(CXSC_INDEX_CHECK)
2474 {
return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2476#if(CXSC_INDEX_CHECK)
2481 {
return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2483#if(CXSC_INDEX_CHECK)
2488 {
return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2490#if(CXSC_INDEX_CHECK)
2495 {
return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl2,sl1); }
2497#if(CXSC_INDEX_CHECK)
2502 {
return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2506#if(CXSC_INDEX_CHECK)
2511 {
return _vvconv<l_rvector,l_rvector,l_ivector>(rv2,rv1); }
2513#if(CXSC_INDEX_CHECK)
2518 {
return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2520#if(CXSC_INDEX_CHECK)
2525 {
return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2527#if(CXSC_INDEX_CHECK)
2532 {
return _vsvsconv<l_rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2538#if(CXSC_INDEX_CHECK)
2543 {
return _vvplus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2545#if(CXSC_INDEX_CHECK)
2550 {
return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2552#if(CXSC_INDEX_CHECK)
2557 {
return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2559#if(CXSC_INDEX_CHECK)
2564 {
return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2567#if(CXSC_INDEX_CHECK)
2572 {
return _vvplus<l_rvector,ivector,l_ivector>(rv2,rv1); }
2574#if(CXSC_INDEX_CHECK)
2579 {
return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2581#if(CXSC_INDEX_CHECK)
2586 {
return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2588#if(CXSC_INDEX_CHECK)
2593 {
return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2596#if(CXSC_INDEX_CHECK)
2601 {
return _vvminus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2603#if(CXSC_INDEX_CHECK)
2608 {
return _vvsminus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2610#if(CXSC_INDEX_CHECK)
2615 {
return _vsvminus<l_rvector_slice,ivector,l_ivector>(sl,rv); }
2617#if(CXSC_INDEX_CHECK)
2622 {
return _vsvsminus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2625#if(CXSC_INDEX_CHECK)
2630 {
return _vvminus<ivector,l_rvector,l_ivector>(rv1,rv2); }
2632#if(CXSC_INDEX_CHECK)
2637 {
return _vvsminus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2639#if(CXSC_INDEX_CHECK)
2644 {
return _vsvminus<ivector_slice,l_rvector,l_ivector>(sl,rv); }
2646#if(CXSC_INDEX_CHECK)
2651 {
return _vsvsminus<ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2654#if(CXSC_INDEX_CHECK)
2659 {
return _vvconv<l_rvector,ivector,l_ivector>(rv1,rv2); }
2661#if(CXSC_INDEX_CHECK)
2666 {
return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2668#if(CXSC_INDEX_CHECK)
2673 {
return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2675#if(CXSC_INDEX_CHECK)
2680 {
return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2683#if(CXSC_INDEX_CHECK)
2688 {
return _vvconv<l_rvector,ivector,l_ivector>(rv2,rv1); }
2690#if(CXSC_INDEX_CHECK)
2695 {
return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2697#if(CXSC_INDEX_CHECK)
2702 {
return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2704#if(CXSC_INDEX_CHECK)
2709 {
return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2712#if(CXSC_INDEX_CHECK)
2717 {
return _vvsect<l_rvector,ivector,l_ivector>(rv1,rv2); }
2719#if(CXSC_INDEX_CHECK)
2724 {
return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2726#if(CXSC_INDEX_CHECK)
2731 {
return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2733#if(CXSC_INDEX_CHECK)
2738 {
return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2741#if(CXSC_INDEX_CHECK)
2746 {
return _vvsect<l_rvector,ivector,l_ivector>(rv2,rv1); }
2748#if(CXSC_INDEX_CHECK)
2753 {
return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2755#if(CXSC_INDEX_CHECK)
2760 {
return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2762#if(CXSC_INDEX_CHECK)
2767 {
return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
The Data Type idotprecision.
The Scalar Type interval.
The Data Type ivector_slice.
The Multiple-Precision Data Type l_interval.
l_interval() noexcept
Constructor of class l_interval.
The Multiple-Precision Data Type l_ivector_slice.
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
l_ivector_slice & operator-=(const l_ivector &rv) noexcept
Implementation of subtraction and allocation operation.
l_ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
l_ivector_slice & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
l_ivector_slice & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
l_ivector_slice & operator/=(const l_interval &r) noexcept
Implementation of division and allocation operation.
l_ivector_slice & operator+=(const l_ivector &rv) noexcept
Implementation of addition and allocation operation.
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
The Multiple-Precision Data Type l_ivector.
l_ivector & operator()() noexcept
Operator for accessing the whole vector.
l_ivector() noexcept
Constructor of class l_ivector.
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_real.
The Multiple-Precision Data Type l_rvector_slice.
The Multiple-Precision Data Type l_rvector.
The Data Type rvector_slice.
The namespace cxsc, providing all functionality of the class library C-XSC.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
l_ivector _l_ivector(const l_interval &r) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.