26#ifndef _CXSC_CIVECTOR_INL_INCLUDED
27#define _CXSC_CIVECTOR_INL_INCLUDED
41 INLINE
civector::civector(
const class index &i)
noexcept:l(1),u(i._int()),size(i._int())
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_CIVECTOR_WRONG_BOUNDARIES(
"civector::civector(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++)
148 if(i<l||i>u) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval & civector::operator [](const int &i)const "));
161 if(i<l||i>u) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval & civector::operator [](const int &i)"));
174 if(i<start||i>end) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval & civector_slice::operator [](const int &i) const"));
188 if(i<start||i>end) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC(
"cinterval & civector_slice::operator [](const int &i)"));
203 if(1<l||i>u) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"civector_slice civector::operator ()(const int &i)"));
216 if(i1<l||i2>u) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"civector_slice civector::operator ()(const int &i1,const int &i2)"));
229 if(1<start||i>end) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"civector_slice civector_slice::operator ()(const int &i)"));
242 if(i1<start||i2>end) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG(
"civector_slice civector_slice::operator ()(const int &i1,const int &i2)"));
255 if(rv.size>1) cxscthrow(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ(
"cinterval::cinterval(const civector &rv)"));
256 else if(rv.size<1) cxscthrow(ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ(
"cinterval::cinterval(const civector &rv)"));
269 if(sl.size>1) cxscthrow(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ(
"cinterval::cinterval(const civector_slice &sl)"));
270 else if(sl.size<1) cxscthrow(ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ(
"cinterval::cinterval(const civector_slice &sl)"));
272 *
this=sl.dat[sl.start-sl.l];
341 INLINE civector::operator
void*()
noexcept {
return _vvoid(*
this); }
348 {
return _vsvsassign(*
this,sl); }
355 {
return _vsvassign(*
this,rv); }
363 {
return _vsvassign(*
this,
civector(m)); }
364 INLINE civector_slice::operator
void*()
noexcept {
return _vsvoid(*
this); }
376 {
return _vvsetinf(iv,rv); }
383 {
return _vsvsetinf(iv,rv); }
390 {
return _vvssetinf(iv,rv); }
397 {
return _vsvssetinf(iv,rv); }
404 {
return _vvusetinf(iv,rv); }
411 {
return _vsvusetinf(iv,rv); }
418 {
return _vvsusetinf(iv,rv); }
425 {
return _vsvsusetinf(iv,rv); }
433 {
return _vvsetsup(iv,rv); }
440 {
return _vsvsetsup(iv,rv); }
447 {
return _vvssetsup(iv,rv); }
454 {
return _vsvssetsup(iv,rv); }
461 {
return _vvusetsup(iv,rv); }
468 {
return _vsvusetsup(iv,rv); }
475 {
return _vvsusetsup(iv,rv); }
482 {
return _vsvsusetsup(iv,rv); }
490 {
return _vvsetre(iv,rv); }
497 {
return _vsvsetre(iv,rv); }
504 {
return _vvssetre(iv,rv); }
511 {
return _vsvssetre(iv,rv); }
519 {
return _vvsetim(iv,rv); }
526 {
return _vsvsetim(iv,rv); }
533 {
return _vvssetim(iv,rv); }
540 {
return _vsvssetim(iv,rv); }
556 INLINE ivector Re(
const civector &v)
noexcept
558 ivector erg(v.l,v.u);
560 for(
int i=0;i<v.size;i++)
561 erg[i+v.l]=Re(v.dat[i]);
566 INLINE ivector Re(
const civector_slice &sl)
noexcept
568 ivector erg(sl.start,sl.end);
570 for(
int i=0,j=sl.start-sl.l;i<sl.size;i++,j++)
571 erg[i+sl.start]=Re(sl.dat[j]);
580 for(
int i=0;i<v.size;i++)
581 erg.dat[i]=InfRe(v.dat[i]);
590 for(
int i=0,j=sl.start-sl.l;i<sl.size;i++,j++)
591 erg.dat[i]=InfRe(sl.dat[j]);
600 for(
int i=0;i<v.size;i++)
601 erg[i+v.l]=Im(v.dat[i]);
606 INLINE ivector Im(
const civector_slice &sl)
noexcept
608 ivector erg(sl.start,sl.end);
610 for(
int i=0,j=sl.start-sl.l;i<sl.size;i++,j++)
611 erg[i+sl.start]=Im(sl.dat[j]);
620 for(
int i=0;i<v.size;i++)
621 erg.dat[i]=InfIm(v.dat[i]);
630 for(
int i=0,j=sl.start-sl.l;i<sl.size;i++,j++)
631 erg.dat[i]=InfIm(sl.dat[j]);
641 for(
int i=0;i<v.size;i++)
642 erg.dat[i]=SupIm(v.dat[i]);
651 for(
int i=0,j=sl.start-sl.l;i<sl.size;i++,j++)
652 erg.dat[i]=SupIm(sl.dat[j]);
663 for(
int i=0;i<v.size;i++)
664 erg.dat[i]=SupRe(v.dat[i]);
673 for(
int i=0,j=sl.start-sl.l;i<sl.size;i++,j++)
674 erg.dat[i]=SupRe(sl.dat[j]);
686 { _vresize<class civector,class cinterval>(rv,len); }
693 { _vresize<class civector,class cinterval>(rv,lb,ub); }
708 INLINE
bool operator !(
const civector &rv)
noexcept {
return _vnot(rv); }
796 INLINE std::ostream &operator <<(std::ostream &s,
const civector &rv)
noexcept {
return _vout(s,rv); }
797 INLINE std::ostream &operator <<(std::ostream &o,
const civector_slice &sl)
noexcept {
return _vsout(o,sl); }
798 INLINE std::istream &operator >>(std::istream &s,
civector &rv)
noexcept {
return _vin(s,rv); }
799 INLINE std::istream &operator >>(std::istream &s,
civector_slice &rv)
noexcept {
return _vsin(s,rv); }
811 {
return _vvcimult<civector,civector,cinterval>(rv1,rv2); }
818 {
return _vsvcimult<civector_slice,civector,cinterval>(sl,rv); }
825 {
return _vsvcimult<civector_slice,civector,cinterval>(sl,rv); }
832 {
return _vsvscimult<civector_slice,civector_slice,cinterval>(sl1,sl2); }
842 {
return _vvplus<civector,civector,civector>(rv1,rv2); }
849 {
return _vvsplus<civector,civector_slice,civector>(rv,sl); }
856 {
return _vvsplus<civector,civector_slice,civector>(rv,sl); }
863 {
return _vsvsplus<civector_slice,civector_slice,civector>(sl1,sl2); }
870 {
return _vvplusassign(rv1,rv2); }
877 {
return _vvsplusassign(rv,sl); }
884 {
return _vsvplusassign(*
this,rv); }
891 {
return _vsvsplusassign(*
this,sl2); }
901 {
return _vvminus<civector,civector,civector>(rv1,rv2); }
908 {
return _vvsminus<civector,civector_slice,civector>(rv,sl); }
915 {
return _vsvminus<civector_slice,civector,civector>(sl,rv); }
922 {
return _vsvsminus<civector_slice,civector_slice,civector>(sl1,sl2); }
929 {
return _vvminusassign(rv1,rv2); }
936 {
return _vvsminusassign(rv,sl); }
943 {
return _vsvminusassign(*
this,rv); }
950 {
return _vsvsminusassign(*
this,sl2); }
958 {
return _vvconv<civector,civector,civector>(rv1,rv2); }
965 {
return _vvsconv<civector,civector_slice,civector>(rv,sl); }
972 {
return _vvsconv<civector,civector_slice,civector>(rv,sl); }
979 {
return _vsvsconv<civector_slice,civector_slice,civector>(sl1,sl2); }
986 {
return _vvconvassign(rv1,rv2); }
993 {
return _vvsconvassign(rv,sl); }
1000 {
return _vsvconvassign(*
this,rv); }
1002#if(CXSC_INDEX_CHECK)
1007 {
return _vsvsconvassign(*
this,sl2); }
1010#if(CXSC_INDEX_CHECK)
1015 {
return _vvsect<civector,civector,civector>(rv1,rv2); }
1017#if(CXSC_INDEX_CHECK)
1022 {
return _vvssect<civector,civector_slice,civector>(rv,sl); }
1024#if(CXSC_INDEX_CHECK)
1029 {
return _vvssect<civector,civector_slice,civector>(rv,sl); }
1031#if(CXSC_INDEX_CHECK)
1036 {
return _vsvssect<civector_slice,civector_slice,civector>(sl1,sl2); }
1038#if(CXSC_INDEX_CHECK)
1043 {
return _vvsectassign(rv1,rv2); }
1045#if(CXSC_INDEX_CHECK)
1050 {
return _vvssectassign(rv,sl); }
1052#if(CXSC_INDEX_CHECK)
1057 {
return _vsvsectassign(*
this,rv); }
1059#if(CXSC_INDEX_CHECK)
1064 {
return _vsvssectassign(*
this,sl2); }
1066 INLINE
bool operator ==(
const civector &rv1,
const civector &rv2)
noexcept {
return _vveq(rv1,rv2); }
1070 INLINE
bool operator !=(
const civector &rv1,
const civector &rv2)
noexcept {
return _vvneq(rv1,rv2); }
1074 INLINE
bool operator <(
const civector &rv1,
const civector &rv2)
noexcept {
return _vvless(rv1,rv2); }
1078 INLINE
bool operator <=(
const civector &rv1,
const civector &rv2)
noexcept {
return _vvleq(rv1,rv2); }
1082 INLINE
bool operator >(
const civector &rv1,
const civector &rv2)
noexcept {
return _vvless(rv2,rv1); }
1086 INLINE
bool operator >=(
const civector &rv1,
const civector &rv2)
noexcept {
return _vvleq(rv2,rv1); }
1097#if(CXSC_INDEX_CHECK)
1102 {
return _vsvassign(*
this,rv); }
1105#if(CXSC_INDEX_CHECK)
1110 {
return _vsvsassign(*
this,sl); }
1114#if(CXSC_INDEX_CHECK)
1119 {
return _vvcimult<rvector,civector,cinterval>(rv1,rv2); }
1121#if(CXSC_INDEX_CHECK)
1126 {
return _vsvcimult<rvector_slice,civector,cinterval>(sl,rv); }
1128#if(CXSC_INDEX_CHECK)
1133 {
return _vsvcimult<civector_slice,rvector,cinterval>(sl,rv); }
1135#if(CXSC_INDEX_CHECK)
1140 {
return _vsvscimult<rvector_slice,civector_slice,cinterval>(sl1,sl2); }
1143#if(CXSC_INDEX_CHECK)
1148 {
return _vvcimult<rvector,civector,cinterval>(rv2,rv1); }
1150#if(CXSC_INDEX_CHECK)
1155 {
return _vsvcimult<civector_slice,rvector,cinterval>(sl,rv); }
1157#if(CXSC_INDEX_CHECK)
1162 {
return _vsvcimult<rvector_slice,civector,cinterval>(sl,rv); }
1164#if(CXSC_INDEX_CHECK)
1169 {
return _vsvscimult<rvector_slice,civector_slice,cinterval>(sl2,sl1); }
1172#if(CXSC_INDEX_CHECK)
1177 {
return _vvplus<rvector,civector,civector>(rv1,rv2); }
1179#if(CXSC_INDEX_CHECK)
1184 {
return _vvsplus<rvector,civector_slice,civector>(rv,sl); }
1186#if(CXSC_INDEX_CHECK)
1191 {
return _vvsplus<civector,rvector_slice,civector>(rv,sl); }
1193#if(CXSC_INDEX_CHECK)
1198 {
return _vsvsplus<rvector_slice,civector_slice,civector>(sl1,sl2); }
1201#if(CXSC_INDEX_CHECK)
1206 {
return _vvplus<rvector,civector,civector>(rv2,rv1); }
1208#if(CXSC_INDEX_CHECK)
1213 {
return _vvsplus<civector,rvector_slice,civector>(rv,sl); }
1215#if(CXSC_INDEX_CHECK)
1220 {
return _vvsplus<rvector,civector_slice,civector>(rv,sl); }
1222#if(CXSC_INDEX_CHECK)
1227 {
return _vsvsplus<rvector_slice,civector_slice,civector>(sl2,sl1); }
1230#if(CXSC_INDEX_CHECK)
1235 {
return _vvplusassign(rv1,rv2); }
1237#if(CXSC_INDEX_CHECK)
1242 {
return _vvsplusassign(rv,sl); }
1244#if(CXSC_INDEX_CHECK)
1249 {
return _vsvplusassign(*
this,rv); }
1251#if(CXSC_INDEX_CHECK)
1256 {
return _vsvsplusassign(*
this,sl2); }
1259#if(CXSC_INDEX_CHECK)
1264 {
return _vvminus<rvector,civector,civector>(rv1,rv2); }
1266#if(CXSC_INDEX_CHECK)
1271 {
return _vvsminus<rvector,civector_slice,civector>(rv,sl); }
1273#if(CXSC_INDEX_CHECK)
1278 {
return _vsvminus<rvector_slice,civector,civector>(sl,rv); }
1280#if(CXSC_INDEX_CHECK)
1285 {
return _vsvsminus<rvector_slice,civector_slice,civector>(sl1,sl2); }
1288#if(CXSC_INDEX_CHECK)
1293 {
return _vvminus<civector,rvector,civector>(rv1,rv2); }
1295#if(CXSC_INDEX_CHECK)
1300 {
return _vvsminus<civector,rvector_slice,civector>(rv,sl); }
1302#if(CXSC_INDEX_CHECK)
1307 {
return _vsvminus<civector_slice,rvector,civector>(sl,rv); }
1309#if(CXSC_INDEX_CHECK)
1314 {
return _vsvsminus<civector_slice,rvector_slice,civector>(sl1,sl2); }
1317#if(CXSC_INDEX_CHECK)
1322 {
return _vvminusassign(rv1,rv2); }
1324#if(CXSC_INDEX_CHECK)
1329 {
return _vvsminusassign(rv,sl); }
1331#if(CXSC_INDEX_CHECK)
1336 {
return _vsvminusassign(*
this,rv); }
1338#if(CXSC_INDEX_CHECK)
1343 {
return _vsvsminusassign(*
this,sl2); }
1346#if(CXSC_INDEX_CHECK)
1351 {
return _vvconv<rvector,civector,civector>(rv1,rv2); }
1353#if(CXSC_INDEX_CHECK)
1358 {
return _vvsconv<rvector,civector_slice,civector>(rv,sl); }
1360#if(CXSC_INDEX_CHECK)
1365 {
return _vvsconv<civector,rvector_slice,civector>(rv,sl); }
1367#if(CXSC_INDEX_CHECK)
1372 {
return _vsvsconv<rvector_slice,civector_slice,civector>(sl1,sl2); }
1375#if(CXSC_INDEX_CHECK)
1380 {
return _vvconv<rvector,civector,civector>(rv2,rv1); }
1382#if(CXSC_INDEX_CHECK)
1387 {
return _vvsconv<civector,rvector_slice,civector>(rv,sl); }
1389#if(CXSC_INDEX_CHECK)
1394 {
return _vvsconv<rvector,civector_slice,civector>(rv,sl); }
1396#if(CXSC_INDEX_CHECK)
1401 {
return _vsvsconv<rvector_slice,civector_slice,civector>(sl2,sl1); }
1404#if(CXSC_INDEX_CHECK)
1409 {
return _vvconvassign(rv1,rv2); }
1411#if(CXSC_INDEX_CHECK)
1416 {
return _vvsconvassign(rv,sl); }
1418#if(CXSC_INDEX_CHECK)
1423 {
return _vsvconvassign(*
this,rv); }
1425#if(CXSC_INDEX_CHECK)
1430 {
return _vsvsconvassign(*
this,sl2); }
1433#if(CXSC_INDEX_CHECK)
1438 {
return _vvsect<rvector,civector,civector>(rv1,rv2); }
1440#if(CXSC_INDEX_CHECK)
1445 {
return _vvssect<rvector,civector_slice,civector>(rv,sl); }
1447#if(CXSC_INDEX_CHECK)
1452 {
return _vvssect<civector,rvector_slice,civector>(rv,sl); }
1454#if(CXSC_INDEX_CHECK)
1459 {
return _vsvssect<rvector_slice,civector_slice,civector>(sl1,sl2); }
1462#if(CXSC_INDEX_CHECK)
1467 {
return _vvsect<rvector,civector,civector>(rv2,rv1); }
1469#if(CXSC_INDEX_CHECK)
1474 {
return _vvssect<civector,rvector_slice,civector>(rv,sl); }
1476#if(CXSC_INDEX_CHECK)
1481 {
return _vvssect<rvector,civector_slice,civector>(rv,sl); }
1483#if(CXSC_INDEX_CHECK)
1488 {
return _vsvssect<rvector_slice,civector_slice,civector>(sl2,sl1); }
1491#if(CXSC_INDEX_CHECK)
1496 {
return _vvsectassign(rv1,rv2); }
1498#if(CXSC_INDEX_CHECK)
1503 {
return _vvssectassign(rv,sl); }
1505#if(CXSC_INDEX_CHECK)
1510 {
return _vsvsectassign(*
this,rv); }
1512#if(CXSC_INDEX_CHECK)
1517 {
return _vsvssectassign(*
this,sl2); }
1525#if(CXSC_INDEX_CHECK)
1530 {
return _vsvassign(*
this,rv); }
1533#if(CXSC_INDEX_CHECK)
1538 {
return _vsvsassign(*
this,sl); }
1542#if(CXSC_INDEX_CHECK)
1547 {
return _vvcimult<cvector,civector,cinterval>(rv1,rv2); }
1549#if(CXSC_INDEX_CHECK)
1554 {
return _vsvcimult<cvector_slice,civector,cinterval>(sl,rv); }
1556#if(CXSC_INDEX_CHECK)
1561 {
return _vsvcimult<civector_slice,cvector,cinterval>(sl,rv); }
1563#if(CXSC_INDEX_CHECK)
1568 {
return _vsvscimult<cvector_slice,civector_slice,cinterval>(sl1,sl2); }
1571#if(CXSC_INDEX_CHECK)
1576 {
return _vvcimult<cvector,civector,cinterval>(rv2,rv1); }
1578#if(CXSC_INDEX_CHECK)
1583 {
return _vsvcimult<civector_slice,cvector,cinterval>(sl,rv); }
1585#if(CXSC_INDEX_CHECK)
1590 {
return _vsvcimult<cvector_slice,civector,cinterval>(sl,rv); }
1592#if(CXSC_INDEX_CHECK)
1597 {
return _vsvscimult<cvector_slice,civector_slice,cinterval>(sl2,sl1); }
1600#if(CXSC_INDEX_CHECK)
1605 {
return _vvplus<cvector,civector,civector>(rv1,rv2); }
1607#if(CXSC_INDEX_CHECK)
1612 {
return _vvsplus<cvector,civector_slice,civector>(rv,sl); }
1614#if(CXSC_INDEX_CHECK)
1619 {
return _vvsplus<civector,cvector_slice,civector>(rv,sl); }
1621#if(CXSC_INDEX_CHECK)
1626 {
return _vsvsplus<cvector_slice,civector_slice,civector>(sl1,sl2); }
1629#if(CXSC_INDEX_CHECK)
1634 {
return _vvplus<cvector,civector,civector>(rv2,rv1); }
1636#if(CXSC_INDEX_CHECK)
1641 {
return _vvsplus<civector,cvector_slice,civector>(rv,sl); }
1643#if(CXSC_INDEX_CHECK)
1648 {
return _vvsplus<cvector,civector_slice,civector>(rv,sl); }
1650#if(CXSC_INDEX_CHECK)
1655 {
return _vsvsplus<cvector_slice,civector_slice,civector>(sl2,sl1); }
1658#if(CXSC_INDEX_CHECK)
1663 {
return _vvplusassign(rv1,rv2); }
1665#if(CXSC_INDEX_CHECK)
1670 {
return _vvsplusassign(rv,sl); }
1672#if(CXSC_INDEX_CHECK)
1677 {
return _vsvplusassign(*
this,rv); }
1679#if(CXSC_INDEX_CHECK)
1684 {
return _vsvsplusassign(*
this,sl2); }
1687#if(CXSC_INDEX_CHECK)
1692 {
return _vvminus<cvector,civector,civector>(rv1,rv2); }
1694#if(CXSC_INDEX_CHECK)
1699 {
return _vvsminus<cvector,civector_slice,civector>(rv,sl); }
1701#if(CXSC_INDEX_CHECK)
1706 {
return _vsvminus<cvector_slice,civector,civector>(sl,rv); }
1708#if(CXSC_INDEX_CHECK)
1713 {
return _vsvsminus<cvector_slice,civector_slice,civector>(sl1,sl2); }
1716#if(CXSC_INDEX_CHECK)
1721 {
return _vvminus<civector,cvector,civector>(rv1,rv2); }
1723#if(CXSC_INDEX_CHECK)
1728 {
return _vvsminus<civector,cvector_slice,civector>(rv,sl); }
1730#if(CXSC_INDEX_CHECK)
1735 {
return _vsvminus<civector_slice,cvector,civector>(sl,rv); }
1737#if(CXSC_INDEX_CHECK)
1742 {
return _vsvsminus<civector_slice,cvector_slice,civector>(sl1,sl2); }
1745#if(CXSC_INDEX_CHECK)
1750 {
return _vvminusassign(rv1,rv2); }
1752#if(CXSC_INDEX_CHECK)
1757 {
return _vvsminusassign(rv,sl); }
1759#if(CXSC_INDEX_CHECK)
1764 {
return _vsvminusassign(*
this,rv); }
1766#if(CXSC_INDEX_CHECK)
1771 {
return _vsvsminusassign(*
this,sl2); }
1774#if(CXSC_INDEX_CHECK)
1779 {
return _vvconv<cvector,civector,civector>(rv1,rv2); }
1781#if(CXSC_INDEX_CHECK)
1786 {
return _vvsconv<cvector,civector_slice,civector>(rv,sl); }
1788#if(CXSC_INDEX_CHECK)
1793 {
return _vvsconv<civector,cvector_slice,civector>(rv,sl); }
1795#if(CXSC_INDEX_CHECK)
1800 {
return _vsvsconv<cvector_slice,civector_slice,civector>(sl1,sl2); }
1803#if(CXSC_INDEX_CHECK)
1808 {
return _vvconv<cvector,civector,civector>(rv2,rv1); }
1810#if(CXSC_INDEX_CHECK)
1815 {
return _vvsconv<civector,cvector_slice,civector>(rv,sl); }
1817#if(CXSC_INDEX_CHECK)
1822 {
return _vvsconv<cvector,civector_slice,civector>(rv,sl); }
1824#if(CXSC_INDEX_CHECK)
1829 {
return _vsvsconv<cvector_slice,civector_slice,civector>(sl2,sl1); }
1832#if(CXSC_INDEX_CHECK)
1837 {
return _vvconvassign(rv1,rv2); }
1839#if(CXSC_INDEX_CHECK)
1844 {
return _vvsconvassign(rv,sl); }
1846#if(CXSC_INDEX_CHECK)
1851 {
return _vsvconvassign(*
this,rv); }
1853#if(CXSC_INDEX_CHECK)
1858 {
return _vsvsconvassign(*
this,sl2); }
1861#if(CXSC_INDEX_CHECK)
1866 {
return _vvsect<cvector,civector,civector>(rv1,rv2); }
1868#if(CXSC_INDEX_CHECK)
1873 {
return _vvssect<cvector,civector_slice,civector>(rv,sl); }
1875#if(CXSC_INDEX_CHECK)
1880 {
return _vvssect<civector,cvector_slice,civector>(rv,sl); }
1882#if(CXSC_INDEX_CHECK)
1887 {
return _vsvssect<cvector_slice,civector_slice,civector>(sl1,sl2); }
1890#if(CXSC_INDEX_CHECK)
1895 {
return _vvsect<cvector,civector,civector>(rv2,rv1); }
1897#if(CXSC_INDEX_CHECK)
1902 {
return _vvssect<civector,cvector_slice,civector>(rv,sl); }
1904#if(CXSC_INDEX_CHECK)
1909 {
return _vvssect<cvector,civector_slice,civector>(rv,sl); }
1911#if(CXSC_INDEX_CHECK)
1916 {
return _vsvssect<cvector_slice,civector_slice,civector>(sl2,sl1); }
1919#if(CXSC_INDEX_CHECK)
1924 {
return _vvsectassign(rv1,rv2); }
1926#if(CXSC_INDEX_CHECK)
1931 {
return _vvssectassign(rv,sl); }
1933#if(CXSC_INDEX_CHECK)
1938 {
return _vsvsectassign(*
this,rv); }
1940#if(CXSC_INDEX_CHECK)
1945 {
return _vsvssectassign(*
this,sl2); }
1953#if(CXSC_INDEX_CHECK)
1958 {
return _vsvassign(*
this,rv); }
1961#if(CXSC_INDEX_CHECK)
1966 {
return _vsvsassign(*
this,sl); }
1970#if(CXSC_INDEX_CHECK)
1975 {
return _vvcimult<ivector,civector,cinterval>(rv1,rv2); }
1977#if(CXSC_INDEX_CHECK)
1982 {
return _vsvcimult<ivector_slice,civector,cinterval>(sl,rv); }
1984#if(CXSC_INDEX_CHECK)
1989 {
return _vsvcimult<civector_slice,ivector,cinterval>(sl,rv); }
1991#if(CXSC_INDEX_CHECK)
1996 {
return _vsvscimult<ivector_slice,civector_slice,cinterval>(sl1,sl2); }
1999#if(CXSC_INDEX_CHECK)
2004 {
return _vvcimult<ivector,civector,cinterval>(rv2,rv1); }
2006#if(CXSC_INDEX_CHECK)
2011 {
return _vsvcimult<civector_slice,ivector,cinterval>(sl,rv); }
2013#if(CXSC_INDEX_CHECK)
2018 {
return _vsvcimult<ivector_slice,civector,cinterval>(sl,rv); }
2020#if(CXSC_INDEX_CHECK)
2025 {
return _vsvscimult<ivector_slice,civector_slice,cinterval>(sl2,sl1); }
2028#if(CXSC_INDEX_CHECK)
2033 {
return _vvplus<ivector,civector,civector>(rv1,rv2); }
2035#if(CXSC_INDEX_CHECK)
2040 {
return _vvsplus<ivector,civector_slice,civector>(rv,sl); }
2042#if(CXSC_INDEX_CHECK)
2047 {
return _vvsplus<civector,ivector_slice,civector>(rv,sl); }
2049#if(CXSC_INDEX_CHECK)
2054 {
return _vsvsplus<ivector_slice,civector_slice,civector>(sl1,sl2); }
2057#if(CXSC_INDEX_CHECK)
2062 {
return _vvplus<ivector,civector,civector>(rv2,rv1); }
2064#if(CXSC_INDEX_CHECK)
2069 {
return _vvsplus<civector,ivector_slice,civector>(rv,sl); }
2071#if(CXSC_INDEX_CHECK)
2076 {
return _vvsplus<ivector,civector_slice,civector>(rv,sl); }
2078#if(CXSC_INDEX_CHECK)
2083 {
return _vsvsplus<ivector_slice,civector_slice,civector>(sl2,sl1); }
2086#if(CXSC_INDEX_CHECK)
2091 {
return _vvplusassign(rv1,rv2); }
2093#if(CXSC_INDEX_CHECK)
2098 {
return _vvsplusassign(rv,sl); }
2100#if(CXSC_INDEX_CHECK)
2105 {
return _vsvplusassign(*
this,rv); }
2107#if(CXSC_INDEX_CHECK)
2112 {
return _vsvsplusassign(*
this,sl2); }
2115#if(CXSC_INDEX_CHECK)
2120 {
return _vvminus<ivector,civector,civector>(rv1,rv2); }
2122#if(CXSC_INDEX_CHECK)
2127 {
return _vvsminus<ivector,civector_slice,civector>(rv,sl); }
2129#if(CXSC_INDEX_CHECK)
2134 {
return _vsvminus<ivector_slice,civector,civector>(sl,rv); }
2136#if(CXSC_INDEX_CHECK)
2141 {
return _vsvsminus<ivector_slice,civector_slice,civector>(sl1,sl2); }
2144#if(CXSC_INDEX_CHECK)
2149 {
return _vvminus<civector,ivector,civector>(rv1,rv2); }
2151#if(CXSC_INDEX_CHECK)
2156 {
return _vvsminus<civector,ivector_slice,civector>(rv,sl); }
2158#if(CXSC_INDEX_CHECK)
2163 {
return _vsvminus<civector_slice,ivector,civector>(sl,rv); }
2165#if(CXSC_INDEX_CHECK)
2170 {
return _vsvsminus<civector_slice,ivector_slice,civector>(sl1,sl2); }
2173#if(CXSC_INDEX_CHECK)
2178 {
return _vvminusassign(rv1,rv2); }
2180#if(CXSC_INDEX_CHECK)
2185 {
return _vvsminusassign(rv,sl); }
2187#if(CXSC_INDEX_CHECK)
2192 {
return _vsvminusassign(*
this,rv); }
2194#if(CXSC_INDEX_CHECK)
2199 {
return _vsvsminusassign(*
this,sl2); }
2202#if(CXSC_INDEX_CHECK)
2207 {
return _vvconv<ivector,civector,civector>(rv1,rv2); }
2209#if(CXSC_INDEX_CHECK)
2214 {
return _vvsconv<ivector,civector_slice,civector>(rv,sl); }
2216#if(CXSC_INDEX_CHECK)
2221 {
return _vvsconv<civector,ivector_slice,civector>(rv,sl); }
2223#if(CXSC_INDEX_CHECK)
2228 {
return _vsvsconv<ivector_slice,civector_slice,civector>(sl1,sl2); }
2231#if(CXSC_INDEX_CHECK)
2236 {
return _vvconv<ivector,civector,civector>(rv2,rv1); }
2238#if(CXSC_INDEX_CHECK)
2243 {
return _vvsconv<civector,ivector_slice,civector>(rv,sl); }
2245#if(CXSC_INDEX_CHECK)
2250 {
return _vvsconv<ivector,civector_slice,civector>(rv,sl); }
2252#if(CXSC_INDEX_CHECK)
2257 {
return _vsvsconv<ivector_slice,civector_slice,civector>(sl2,sl1); }
2260#if(CXSC_INDEX_CHECK)
2265 {
return _vvconvassign(rv1,rv2); }
2267#if(CXSC_INDEX_CHECK)
2272 {
return _vvsconvassign(rv,sl); }
2274#if(CXSC_INDEX_CHECK)
2279 {
return _vsvconvassign(*
this,rv); }
2281#if(CXSC_INDEX_CHECK)
2286 {
return _vsvsconvassign(*
this,sl2); }
2289#if(CXSC_INDEX_CHECK)
2294 {
return _vvsect<ivector,civector,civector>(rv1,rv2); }
2296#if(CXSC_INDEX_CHECK)
2301 {
return _vvssect<ivector,civector_slice,civector>(rv,sl); }
2303#if(CXSC_INDEX_CHECK)
2308 {
return _vvssect<civector,ivector_slice,civector>(rv,sl); }
2310#if(CXSC_INDEX_CHECK)
2315 {
return _vsvssect<ivector_slice,civector_slice,civector>(sl1,sl2); }
2318#if(CXSC_INDEX_CHECK)
2323 {
return _vvsect<ivector,civector,civector>(rv2,rv1); }
2325#if(CXSC_INDEX_CHECK)
2330 {
return _vvssect<civector,ivector_slice,civector>(rv,sl); }
2332#if(CXSC_INDEX_CHECK)
2337 {
return _vvssect<ivector,civector_slice,civector>(rv,sl); }
2339#if(CXSC_INDEX_CHECK)
2344 {
return _vsvssect<ivector_slice,civector_slice,civector>(sl2,sl1); }
2347#if(CXSC_INDEX_CHECK)
2352 {
return _vvsectassign(rv1,rv2); }
2354#if(CXSC_INDEX_CHECK)
2359 {
return _vvssectassign(rv,sl); }
2361#if(CXSC_INDEX_CHECK)
2366 {
return _vsvsectassign(*
this,rv); }
2368#if(CXSC_INDEX_CHECK)
2373 {
return _vsvssectassign(*
this,sl2); }
2377#if(CXSC_INDEX_CHECK)
2382 {
return _vvconv<rvector,cvector,civector>(rv1,rv2); }
2384#if(CXSC_INDEX_CHECK)
2389 {
return _vvconv<rvector,cvector,civector>(rv2,rv1); }
2391#if(CXSC_INDEX_CHECK)
2396 {
return _vvsconv<cvector,rvector_slice,civector>(rv,sl); }
2398#if(CXSC_INDEX_CHECK)
2403 {
return _vvsconv<cvector,rvector_slice,civector>(rv,sl); }
2405#if(CXSC_INDEX_CHECK)
2410 {
return _vvsconv<rvector,cvector_slice,civector>(rv,sl); }
2412#if(CXSC_INDEX_CHECK)
2417 {
return _vvsconv<rvector,cvector_slice,civector>(rv,sl); }
2419#if(CXSC_INDEX_CHECK)
2424 {
return _vsvsconv<rvector_slice,cvector_slice,civector>(sl2,sl1); }
2426#if(CXSC_INDEX_CHECK)
2431 {
return _vsvsconv<rvector_slice,cvector_slice,civector>(sl1,sl2); }
2435#if(CXSC_INDEX_CHECK)
2440 {
return _vvconv<cvector,cvector,civector>(rv2,rv1); }
2442#if(CXSC_INDEX_CHECK)
2447 {
return _vvsconv<cvector,cvector_slice,civector>(rv,sl); }
2449#if(CXSC_INDEX_CHECK)
2454 {
return _vvsconv<cvector,cvector_slice,civector>(rv,sl); }
2456#if(CXSC_INDEX_CHECK)
2461 {
return _vsvsconv<cvector_slice,cvector_slice,civector>(sl1,sl2); }
2466#if(CXSC_INDEX_CHECK)
2471 {
return _vvplus<cvector,ivector,civector>(rv1,rv2); }
2473#if(CXSC_INDEX_CHECK)
2478 {
return _vvsplus<cvector,ivector_slice,civector>(rv,sl); }
2480#if(CXSC_INDEX_CHECK)
2485 {
return _vvsplus<ivector,cvector_slice,civector>(rv,sl); }
2487#if(CXSC_INDEX_CHECK)
2492 {
return _vsvsplus<cvector_slice,ivector_slice,civector>(sl1,sl2); }
2495#if(CXSC_INDEX_CHECK)
2500 {
return _vvplus<cvector,ivector,civector>(rv2,rv1); }
2502#if(CXSC_INDEX_CHECK)
2507 {
return _vvsplus<ivector,cvector_slice,civector>(rv,sl); }
2509#if(CXSC_INDEX_CHECK)
2514 {
return _vvsplus<cvector,ivector_slice,civector>(rv,sl); }
2516#if(CXSC_INDEX_CHECK)
2521 {
return _vsvsplus<cvector_slice,ivector_slice,civector>(sl2,sl1); }
2524#if(CXSC_INDEX_CHECK)
2529 {
return _vvminus<cvector,ivector,civector>(rv1,rv2); }
2531#if(CXSC_INDEX_CHECK)
2536 {
return _vvsminus<cvector,ivector_slice,civector>(rv,sl); }
2538#if(CXSC_INDEX_CHECK)
2543 {
return _vsvminus<cvector_slice,ivector,civector>(sl,rv); }
2545#if(CXSC_INDEX_CHECK)
2550 {
return _vsvsminus<cvector_slice,ivector_slice,civector>(sl1,sl2); }
2553#if(CXSC_INDEX_CHECK)
2558 {
return _vvminus<ivector,cvector,civector>(rv1,rv2); }
2560#if(CXSC_INDEX_CHECK)
2565 {
return _vvsminus<ivector,cvector_slice,civector>(rv,sl); }
2567#if(CXSC_INDEX_CHECK)
2572 {
return _vsvminus<ivector_slice,cvector,civector>(sl,rv); }
2574#if(CXSC_INDEX_CHECK)
2579 {
return _vsvsminus<ivector_slice,cvector_slice,civector>(sl1,sl2); }
2582#if(CXSC_INDEX_CHECK)
2587 {
return _vvconv<cvector,ivector,civector>(rv1,rv2); }
2589#if(CXSC_INDEX_CHECK)
2594 {
return _vvsconv<cvector,ivector_slice,civector>(rv,sl); }
2596#if(CXSC_INDEX_CHECK)
2601 {
return _vvsconv<ivector,cvector_slice,civector>(rv,sl); }
2603#if(CXSC_INDEX_CHECK)
2608 {
return _vsvsconv<cvector_slice,ivector_slice,civector>(sl1,sl2); }
2611#if(CXSC_INDEX_CHECK)
2616 {
return _vvconv<cvector,ivector,civector>(rv2,rv1); }
2618#if(CXSC_INDEX_CHECK)
2623 {
return _vvsconv<ivector,cvector_slice,civector>(rv,sl); }
2625#if(CXSC_INDEX_CHECK)
2630 {
return _vvsconv<cvector,ivector_slice,civector>(rv,sl); }
2632#if(CXSC_INDEX_CHECK)
2637 {
return _vsvsconv<cvector_slice,ivector_slice,civector>(sl2,sl1); }
2640#if(CXSC_INDEX_CHECK)
2645 {
return _vvsect<cvector,ivector,civector>(rv1,rv2); }
2647#if(CXSC_INDEX_CHECK)
2652 {
return _vvssect<cvector,ivector_slice,civector>(rv,sl); }
2654#if(CXSC_INDEX_CHECK)
2659 {
return _vvssect<ivector,cvector_slice,civector>(rv,sl); }
2661#if(CXSC_INDEX_CHECK)
2666 {
return _vsvssect<cvector_slice,ivector_slice,civector>(sl1,sl2); }
2669#if(CXSC_INDEX_CHECK)
2674 {
return _vvsect<cvector,ivector,civector>(rv2,rv1); }
2676#if(CXSC_INDEX_CHECK)
2681 {
return _vvssect<ivector,cvector_slice,civector>(rv,sl); }
2683#if(CXSC_INDEX_CHECK)
2688 {
return _vvssect<cvector,ivector_slice,civector>(rv,sl); }
2690#if(CXSC_INDEX_CHECK)
2695 {
return _vsvssect<cvector_slice,ivector_slice,civector>(sl2,sl1); }
2701 for(
int i=0 ; i<
VecLen(x) ; i++)
2702 x[i+
Lb(x)] = (*this)[p[i+
Lb(p)]+
Lb(*
this)];
2710 for(
int i=0 ; i<n && ret ; i++) {
2711 ret =
in(v1[
Lb(v1)+i], v2[
Lb(v2)+i]);
The Scalar Type cinterval.
cinterval(void) noexcept
Constructor of class cinterval.
The Data Type civector_slice.
civector_slice & operator|=(const civector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
civector_slice & operator&=(const civector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
civector_slice & operator*=(const cinterval &r) noexcept
Implementation of multiplication and allocation operation.
civector_slice & operator+=(const civector &rv) noexcept
Implementation of addition and allocation operation.
civector_slice & operator()() noexcept
Operator for accessing the whole vector.
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
civector_slice & operator/=(const cinterval &r) noexcept
Implementation of division and allocation operation.
civector_slice & operator-=(const civector &rv) noexcept
Implementation of subtraction and allocation operation.
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
friend int VecLen(const civector &rv) noexcept
Returns the dimension of the vector.
civector & operator()() noexcept
Operator for accessing the whole vector.
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
friend int Lb(const civector &rv) noexcept
Returns the lower bound of the vector.
civector() noexcept
Constructor of class civector.
The Data Type cvector_slice.
The Scalar Type interval.
The Data Type ivector_slice.
The Data Type rvector_slice.
The namespace cxsc, providing all functionality of the class library C-XSC.
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
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.
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
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.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.