26 #ifndef _CXSC_SCIVECTOR_HPP_INCLUDED 27 #define _CXSC_SCIVECTOR_HPP_INCLUDED 29 #include <cinterval.hpp> 30 #include <civector.hpp> 33 #include <srvector.hpp> 34 #include <scvector.hpp> 35 #include <sivector.hpp> 36 #include <sparsecidot.hpp> 37 #include <sparsevector.hpp> 53 class scivector_slice;
54 class scimatrix_slice;
65 std::vector<cinterval> x;
76 explicit scivector(
const int s) : lb(1), ub(s), n(s) {
77 p.reserve((
int)(s*0.1));
78 x.reserve((
int)(s*0.1));
82 scivector(
const int s,
const int b) : lb(1), ub(s), n(s) {
89 for(
int i=lb ; i<=ub ; i++) {
99 for(
int i=lb ; i<=ub ; i++) {
109 for(
int i=lb ; i<=ub ; i++) {
120 for(
int i=0 ; i<nnz ; i++) {
121 if(values[i+
Lb(values)] != 0.0) {
122 p.push_back(index[i+
Lb(index)]);
123 x.push_back(values[i+
Lb(values)]);
131 for(
int i=0 ; i<nnz ; i++) {
132 if(values[i] != 0.0) {
133 p.push_back(index[i]);
134 x.push_back(values[i]);
142 for(
int i=0 ; i<v.
get_nnz() ; i++)
149 for(
int i=0 ; i<v.
get_nnz() ; i++)
156 for(
int i=0 ; i<v.
get_nnz() ; i++)
211 const std::vector<cinterval>&
values()
const {
222 return (
double)x.size()/n;
227 for(
int i=0 ; i<
get_nnz() ; i++) {
229 x.erase(x.begin()+i);
230 p.erase(p.begin()+i);
241 for(
unsigned int i=0 ; i<v.x.size() ; i++)
252 for(
unsigned int i=0 ; i<v.x.size() ; i++)
263 for(
unsigned int i=0 ; i<v.x.size() ; i++)
270 return sp_vs_assign<scivector,real,cinterval>(*
this,v);
275 return sp_vs_assign<scivector,complex,cinterval>(*
this,v);
280 return sp_vs_assign<scivector,interval,cinterval>(*
this,v);
285 return sp_vs_assign<scivector,cinterval,cinterval>(*
this,v);
290 return spf_vv_assign<scivector,rvector,cinterval>(*
this,v);
295 return spf_vv_assign<scivector,cvector,cinterval>(*
this,v);
300 return spf_vv_assign<scivector,ivector,cinterval>(*
this,v);
305 return spf_vv_assign<scivector,civector,cinterval>(*
this,v);
310 return spf_vv_assign<scivector,rvector_slice,cinterval>(*
this,v);
315 return spf_vv_assign<scivector,cvector_slice,cinterval>(*
this,v);
320 return spf_vv_assign<scivector,ivector_slice,cinterval>(*
this,v);
325 return spf_vv_assign<scivector,civector_slice,cinterval>(*
this,v);
343 #if(CXSC_INDEX_CHECK) 344 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector::operator[](const int)"));
348 for(k=0 ; k<
get_nnz() && p[k]<=i-lb ; k++) {
353 p.insert(p.begin() + k, i-lb);
365 #if(CXSC_INDEX_CHECK) 366 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector::operator[](const int)"));
377 #if(CXSC_INDEX_CHECK) 378 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector::operator()(const int)"));
382 for(
int k=0 ; k<
get_nnz() && p[k]<=i-lb ; k++) {
398 std::map<int,cinterval> work;
399 for(
int i=0 ; i<
get_nnz() ; i++)
400 work.insert(std::make_pair(pinv[
Lb(pinv)+p[i]], x[i]));
402 for(std::map<int,cinterval>::iterator it=work.begin() ; it!=work.end() ; it++) {
403 v.p.push_back(it->first);
404 v.x.push_back(it->second);
429 return sp_vs_multassign(*
this,s);
434 return sp_vs_multassign(*
this,s);
439 return sp_vs_multassign(*
this,s);
444 return sp_vs_multassign(*
this,s);
449 return sp_vs_divassign(*
this,s);
454 return sp_vs_divassign(*
this,s);
459 return sp_vs_divassign(*
this,s);
464 return sp_vs_divassign(*
this,s);
469 return spf_vv_addassign(*
this,v);
474 return spf_vv_addassign(*
this,v);
479 return spf_vv_addassign(*
this,v);
484 return spf_vv_addassign(*
this,v);
489 return spf_vv_addassign(*
this,v);
494 return spf_vv_addassign(*
this,v);
499 return spf_vv_addassign(*
this,v);
504 return spf_vv_addassign(*
this,v);
509 return spsp_vv_addassign(*
this,v);
514 return spsp_vv_addassign(*
this,v);
519 return spsp_vv_addassign(*
this,v);
524 return spsp_vv_addassign(*
this,v);
529 return spf_vv_subassign(*
this,v);
534 return spf_vv_subassign(*
this,v);
539 return spf_vv_subassign(*
this,v);
544 return spf_vv_subassign(*
this,v);
549 return spf_vv_subassign(*
this,v);
554 return spf_vv_subassign(*
this,v);
559 return spf_vv_subassign(*
this,v);
564 return spf_vv_subassign(*
this,v);
569 return spsp_vv_subassign(*
this,v);
574 return spsp_vv_subassign(*
this,v);
579 return spsp_vv_subassign(*
this,v);
584 return spsp_vv_subassign(*
this,v);
589 return spf_vv_hullassign(*
this,v);
594 return spf_vv_hullassign(*
this,v);
599 return spf_vv_hullassign(*
this,v);
604 return spf_vv_hullassign(*
this,v);
609 return spf_vv_hullassign(*
this,v);
614 return spf_vv_hullassign(*
this,v);
619 return spf_vv_hullassign(*
this,v);
624 return spf_vv_hullassign(*
this,v);
629 return spsp_vv_hullassign(*
this,v);
634 return spsp_vv_hullassign(*
this,v);
639 return spsp_vv_hullassign(*
this,v);
644 return spsp_vv_hullassign(*
this,v);
649 return spf_vv_intersectassign(*
this,v);
654 return spf_vv_intersectassign(*
this,v);
659 return spf_vv_intersectassign(*
this,v);
664 return spf_vv_intersectassign(*
this,v);
669 return spsp_vv_intersectassign(*
this,v);
674 return spsp_vv_intersectassign(*
this,v);
733 #include "vector_friend_declarations.inl" 741 for(
int i=0 ; i<v.n ; i++)
743 for(
int i=0 ; i<v.
get_nnz() ; i++)
744 dat[v.p[i]] = v.x[i];
752 for(
int i=0 ; i<v.n ; i++)
754 for(
int i=0 ; i<v.
get_nnz() ; i++)
755 dat[v.p[i]] = v.x[i];
763 for(
int i=0 ; i<v.n ; i++)
765 for(
int i=0 ; i<v.
get_nnz() ; i++)
766 dat[v.p[i]] = v.x[i];
774 for(
int i=0 ; i<v.n ; i++)
776 for(
int i=0 ; i<v.
get_nnz() ; i++)
777 dat[v.p[i]] = v.x[i];
781 return fsp_vv_assign<civector,scivector,cinterval>(*
this,v);
785 return fsl_vv_assign<civector,scivector_slice,cinterval>(*
this,v);
789 return fsp_vv_assign<civector,srvector,cinterval>(*
this,v);
793 return fsl_vv_assign<civector,srvector_slice,cinterval>(*
this,v);
797 return fsp_vv_assign<civector,scvector,cinterval>(*
this,v);
801 return fsl_vv_assign<civector,scvector_slice,cinterval>(*
this,v);
805 return fsp_vv_assign<civector,sivector,cinterval>(*
this,v);
809 return fsl_vv_assign<civector,sivector_slice,cinterval>(*
this,v);
819 v.ub = v.lb + v.n - 1;
828 v.lb = v.ub - v.n + 1;
869 for(
int i=0 ; i<v.
get_nnz() ; i++)
870 res.x.push_back(
abs(v.x[i]));
880 for(
int i=0 ; i<v.
get_nnz() ; i++)
881 res.x.push_back(
conj(v.x[i]));
891 for(
int i=0 ; i<v.
get_nnz() ; i++)
892 res.x.push_back(
mid(v.x[i]));
902 for(
int i=0 ; i<v.
get_nnz() ; i++)
903 res.x.push_back(
diam(v.x[i]));
913 for(
int i=0 ; i<v.
get_nnz() ; i++)
914 res.x[i] =
Re(v.x[i]);
924 for(
int i=0 ; i<v.
get_nnz() ; i++)
925 res.x[i] =
Im(v.x[i]);
935 for(
int i=0 ; i<v.
get_nnz() ; i++)
936 res.x[i] =
Inf(v.x[i]);
946 for(
int i=0 ; i<v.
get_nnz() ; i++)
947 res.x[i] =
Sup(v.x[i]);
957 for(
int i=0 ; i<v.
get_nnz() ; i++)
958 res.x[i] =
InfRe(v.x[i]);
968 for(
int i=0 ; i<v.
get_nnz() ; i++)
969 res.x[i] =
InfIm(v.x[i]);
979 for(
int i=0 ; i<v.
get_nnz() ; i++)
980 res.x[i] =
SupRe(v.x[i]);
990 for(
int i=0 ; i<v.
get_nnz() ; i++)
991 res.x[i] =
SupIm(v.x[i]);
1002 for(
int i=0 ; i<
VecLen(v1) ; i++)
1003 if(!
in(v1(i+
Lb(v1)), v2(i+
Lb(v2))))
return false;
1009 return sp_v_negative(v);
1020 return spf_vv_mult<scivector,cvector,cinterval,sparse_cidot>(v1,v2);
1031 return spf_vv_mult<scivector,rvector,cinterval,sparse_cidot>(v1,v2);
1042 return spf_vv_mult<scivector,ivector,cinterval,sparse_cidot>(v1,v2);
1053 return spf_vv_mult<scivector,civector,cinterval,sparse_cidot>(v1,v2);
1064 return spf_vv_mult<scvector,civector,cinterval,sparse_cidot>(v1,v2);
1075 return spf_vv_mult<srvector,civector,cinterval,sparse_cidot>(v1,v2);
1086 return spf_vv_mult<sivector,civector,cinterval,sparse_cidot>(v1,v2);
1097 return spf_vv_mult<scvector,ivector,cinterval,sparse_cidot>(v1,v2);
1108 return spf_vv_mult<sivector,cvector,cinterval,sparse_cidot>(v1,v2);
1119 return fsp_vv_mult<rvector,scivector,cinterval,sparse_cidot>(v1,v2);
1130 return fsp_vv_mult<cvector,scivector,cinterval,sparse_cidot>(v1,v2);
1141 return fsp_vv_mult<ivector,scivector,cinterval,sparse_cidot>(v1,v2);
1152 return fsp_vv_mult<civector,scivector,cinterval,sparse_cidot>(v1,v2);
1163 return fsp_vv_mult<civector,srvector,cinterval,sparse_cidot>(v1,v2);
1174 return fsp_vv_mult<civector,scvector,cinterval,sparse_cidot>(v1,v2);
1185 return fsp_vv_mult<civector,sivector,cinterval,sparse_cidot>(v1,v2);
1196 return fsp_vv_mult<ivector,scvector,cinterval,sparse_cidot>(v1,v2);
1207 return fsp_vv_mult<cvector,sivector,cinterval,sparse_cidot>(v1,v2);
1218 return spf_vv_mult<scivector,cvector_slice,cinterval,sparse_cidot>(v1,v2);
1229 return spf_vv_mult<scivector,rvector_slice,cinterval,sparse_cidot>(v1,v2);
1240 return spf_vv_mult<scivector,ivector_slice,cinterval,sparse_cidot>(v1,v2);
1251 return spf_vv_mult<scivector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1262 return spf_vv_mult<scvector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1273 return spf_vv_mult<srvector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1284 return spf_vv_mult<sivector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1295 return spf_vv_mult<scvector,ivector_slice,cinterval,sparse_cidot>(v1,v2);
1306 return spf_vv_mult<sivector,cvector_slice,cinterval,sparse_cidot>(v1,v2);
1317 return fsp_vv_mult<rvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1328 return fsp_vv_mult<cvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1339 return fsp_vv_mult<ivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1350 return fsp_vv_mult<civector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1361 return fsp_vv_mult<civector_slice,srvector,cinterval,sparse_cidot>(v1,v2);
1372 return fsp_vv_mult<civector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
1383 return fsp_vv_mult<civector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
1394 return fsp_vv_mult<ivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
1405 return fsp_vv_mult<cvector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
1416 return spsp_vv_mult<scivector,srvector,cinterval,sparse_cidot>(v1,v2);
1427 return spsp_vv_mult<scivector,scvector,cinterval,sparse_cidot>(v1,v2);
1438 return spsp_vv_mult<scivector,sivector,cinterval,sparse_cidot>(v1,v2);
1449 return spsp_vv_mult<scivector,scivector,cinterval,sparse_cidot>(v1,v2);
1460 return spsp_vv_mult<srvector,scivector,cinterval,sparse_cidot>(v1,v2);
1471 return spsp_vv_mult<scvector,scivector,cinterval,sparse_cidot>(v1,v2);
1482 return spsp_vv_mult<sivector,scivector,cinterval,sparse_cidot>(v1,v2);
1493 return spsp_vv_mult<scvector,sivector,cinterval,sparse_cidot>(v1,v2);
1504 return spsp_vv_mult<sivector,scvector,cinterval,sparse_cidot>(v1,v2);
1509 return sp_vs_mult<scivector,real,scivector>(v,s);
1514 return sp_vs_mult<scivector,complex,scivector>(v,s);
1519 return sp_vs_mult<scivector,interval,scivector>(v,s);
1524 return sp_vs_mult<scivector,cinterval,scivector>(v,s);
1529 return sp_vs_mult<scvector,interval,scivector>(v,s);
1534 return sp_vs_mult<sivector,complex,scivector>(v,s);
1539 return sp_vs_div<scivector,real,scivector>(v,s);
1544 return sp_vs_div<scivector,complex,scivector>(v,s);
1549 return sp_vs_div<scivector,interval,scivector>(v,s);
1554 return sp_vs_div<scivector,cinterval,scivector>(v,s);
1559 return sp_vs_div<srvector,cinterval,scivector>(v,s);
1564 return sp_vs_div<scvector,cinterval,scivector>(v,s);
1569 return sp_vs_div<sivector,cinterval,scivector>(v,s);
1574 return sp_vs_div<scvector,interval,scivector>(v,s);
1579 return sp_vs_div<sivector,complex,scivector>(v,s);
1584 return sp_sv_mult<real,scivector,scivector>(s,v);
1589 return sp_sv_mult<complex,scivector,scivector>(s,v);
1594 return sp_sv_mult<interval,scivector,scivector>(s,v);
1599 return sp_sv_mult<cinterval,srvector,scivector>(s,v);
1604 return sp_sv_mult<cinterval,sivector,scivector>(s,v);
1609 return sp_sv_mult<cinterval,scvector,scivector>(s,v);
1614 return sp_sv_mult<cinterval,scivector,scivector>(s,v);
1619 return sp_sv_mult<cinterval,srvector,scivector>(s,v);
1624 return sp_sv_mult<cinterval,sivector,scivector>(s,v);
1629 return sp_sv_mult<cinterval,scvector,scivector>(s,v);
1634 return sp_sv_mult<complex,sivector,scivector>(s,v);
1639 return sp_sv_mult<interval,scvector,scivector>(s,v);
1644 return fsp_vv_add<civector,srvector,civector>(v1,v2);
1649 return fsp_vv_add<civector,scvector,civector>(v1,v2);
1654 return fsp_vv_add<civector,sivector,civector>(v1,v2);
1659 return fsp_vv_add<civector,scivector,civector>(v1,v2);
1664 return fsp_vv_add<rvector,scivector,civector>(v1,v2);
1669 return fsp_vv_add<cvector,scivector,civector>(v1,v2);
1674 return fsp_vv_add<ivector,scivector,civector>(v1,v2);
1679 return fsp_vv_add<cvector,sivector,civector>(v1,v2);
1684 return fsp_vv_add<ivector,scvector,civector>(v1,v2);
1689 return spf_vv_add<scivector,rvector,civector>(v1,v2);
1694 return spf_vv_add<scivector,cvector,civector>(v1,v2);
1699 return spf_vv_add<scivector,ivector,civector>(v1,v2);
1704 return spf_vv_add<scivector,civector,civector>(v1,v2);
1709 return spf_vv_add<srvector,civector,civector>(v1,v2);
1714 return spf_vv_add<scvector,civector,civector>(v1,v2);
1719 return spf_vv_add<sivector,civector,civector>(v1,v2);
1724 return spf_vv_add<scvector,ivector,civector>(v1,v2);
1729 return spf_vv_add<sivector,cvector,civector>(v1,v2);
1734 return fsp_vv_add<civector_slice,srvector,civector>(v1,v2);
1739 return fsp_vv_add<civector_slice,scvector,civector>(v1,v2);
1744 return fsp_vv_add<civector_slice,sivector,civector>(v1,v2);
1749 return fsp_vv_add<civector_slice,scivector,civector>(v1,v2);
1754 return fsp_vv_add<rvector_slice,scivector,civector>(v1,v2);
1759 return fsp_vv_add<cvector_slice,scivector,civector>(v1,v2);
1764 return fsp_vv_add<ivector_slice,scivector,civector>(v1,v2);
1769 return fsp_vv_add<cvector_slice,sivector,civector>(v1,v2);
1774 return fsp_vv_add<ivector_slice,scvector,civector>(v1,v2);
1779 return spf_vv_add<scivector,rvector_slice,civector>(v1,v2);
1784 return spf_vv_add<scivector,cvector_slice,civector>(v1,v2);
1789 return spf_vv_add<scivector,ivector_slice,civector>(v1,v2);
1794 return spf_vv_add<scivector,civector_slice,civector>(v1,v2);
1799 return spf_vv_add<srvector,civector_slice,civector>(v1,v2);
1804 return spf_vv_add<scvector,civector_slice,civector>(v1,v2);
1809 return spf_vv_add<sivector,civector_slice,civector>(v1,v2);
1814 return spf_vv_add<scvector,ivector_slice,civector>(v1,v2);
1819 return spf_vv_add<sivector,cvector_slice,civector>(v1,v2);
1824 return spsp_vv_add<scivector,srvector,scivector,cinterval>(v1,v2);
1829 return spsp_vv_add<scivector,scvector,scivector,cinterval>(v1,v2);
1834 return spsp_vv_add<scivector,sivector,scivector,cinterval>(v1,v2);
1839 return spsp_vv_add<scivector,scivector,scivector,cinterval>(v1,v2);
1844 return spsp_vv_add<srvector,scivector,scivector,cinterval>(v1,v2);
1849 return spsp_vv_add<scvector,scivector,scivector,cinterval>(v1,v2);
1854 return spsp_vv_add<sivector,scivector,scivector,cinterval>(v1,v2);
1859 return spsp_vv_add<scvector,sivector,scivector,cinterval>(v1,v2);
1864 return spsp_vv_add<sivector,scvector,scivector,cinterval>(v1,v2);
1869 return fsp_vv_sub<civector,srvector,civector>(v1,v2);
1874 return fsp_vv_sub<civector,sivector,civector>(v1,v2);
1879 return fsp_vv_sub<civector,scvector,civector>(v1,v2);
1884 return fsp_vv_sub<civector,scivector,civector>(v1,v2);
1889 return fsp_vv_sub<rvector,scivector,civector>(v1,v2);
1894 return fsp_vv_sub<cvector,scivector,civector>(v1,v2);
1899 return fsp_vv_sub<ivector,scivector,civector>(v1,v2);
1904 return fsp_vv_sub<cvector,sivector,civector>(v1,v2);
1909 return fsp_vv_sub<ivector,scvector,civector>(v1,v2);
1914 return spf_vv_sub<scivector,rvector,civector>(v1,v2);
1919 return spf_vv_sub<scivector,cvector,civector>(v1,v2);
1924 return spf_vv_sub<scivector,ivector,civector>(v1,v2);
1929 return spf_vv_sub<scivector,civector,civector>(v1,v2);
1934 return spf_vv_sub<srvector,civector,civector>(v1,v2);
1939 return spf_vv_sub<scvector,civector,civector>(v1,v2);
1944 return spf_vv_sub<sivector,civector,civector>(v1,v2);
1949 return spf_vv_sub<scvector,ivector,civector>(v1,v2);
1954 return spf_vv_sub<sivector,cvector,civector>(v1,v2);
1959 return fsp_vv_sub<civector_slice,srvector,civector>(v1,v2);
1964 return fsp_vv_sub<civector_slice,sivector,civector>(v1,v2);
1969 return fsp_vv_sub<civector_slice,scvector,civector>(v1,v2);
1974 return fsp_vv_sub<civector_slice,scivector,civector>(v1,v2);
1979 return fsp_vv_sub<rvector_slice,scivector,civector>(v1,v2);
1984 return fsp_vv_sub<cvector_slice,scivector,civector>(v1,v2);
1989 return fsp_vv_sub<ivector_slice,scivector,civector>(v1,v2);
1994 return fsp_vv_sub<cvector_slice,sivector,civector>(v1,v2);
1999 return fsp_vv_sub<ivector_slice,scvector,civector>(v1,v2);
2004 return spf_vv_sub<scivector,rvector_slice,civector>(v1,v2);
2009 return spf_vv_sub<scivector,cvector_slice,civector>(v1,v2);
2014 return spf_vv_sub<scivector,ivector_slice,civector>(v1,v2);
2019 return spf_vv_sub<scivector,civector_slice,civector>(v1,v2);
2024 return spf_vv_sub<srvector,civector_slice,civector>(v1,v2);
2029 return spf_vv_sub<scvector,civector_slice,civector>(v1,v2);
2034 return spf_vv_sub<sivector,civector_slice,civector>(v1,v2);
2039 return spf_vv_sub<scvector,ivector_slice,civector>(v1,v2);
2044 return spf_vv_sub<sivector,cvector_slice,civector>(v1,v2);
2049 return spsp_vv_sub<scivector,srvector,scivector,cinterval>(v1,v2);
2054 return spsp_vv_sub<scivector,scvector,scivector,cinterval>(v1,v2);
2059 return spsp_vv_sub<scivector,sivector,scivector,cinterval>(v1,v2);
2064 return spsp_vv_sub<scivector,scivector,scivector,cinterval>(v1,v2);
2069 return spsp_vv_sub<srvector,scivector,scivector,cinterval>(v1,v2);
2074 return spsp_vv_sub<scvector,scivector,scivector,cinterval>(v1,v2);
2079 return spsp_vv_sub<sivector,scivector,scivector,cinterval>(v1,v2);
2084 return spsp_vv_sub<scvector,sivector,scivector,cinterval>(v1,v2);
2089 return spsp_vv_sub<sivector,scvector,scivector,cinterval>(v1,v2);
2094 return fsp_vv_hull<civector,srvector,civector>(v1,v2);
2099 return fsp_vv_hull<civector,scvector,civector>(v1,v2);
2104 return fsp_vv_hull<civector,sivector,civector>(v1,v2);
2109 return fsp_vv_hull<civector,scivector,civector>(v1,v2);
2114 return fsp_vv_hull<rvector,scivector,civector>(v1,v2);
2119 return fsp_vv_hull<cvector,scivector,civector>(v1,v2);
2124 return fsp_vv_hull<ivector,scivector,civector>(v1,v2);
2129 return fsp_vv_hull<cvector,sivector,civector>(v1,v2);
2134 return fsp_vv_hull<ivector,scvector,civector>(v1,v2);
2139 return spf_vv_hull<scivector,rvector,civector>(v1,v2);
2144 return spf_vv_hull<scivector,cvector,civector>(v1,v2);
2149 return spf_vv_hull<scivector,ivector,civector>(v1,v2);
2154 return spf_vv_hull<scivector,civector,civector>(v1,v2);
2159 return spf_vv_hull<srvector,civector,civector>(v1,v2);
2164 return spf_vv_hull<scvector,civector,civector>(v1,v2);
2169 return spf_vv_hull<sivector,civector,civector>(v1,v2);
2174 return spf_vv_hull<scvector,ivector,civector>(v1,v2);
2179 return spf_vv_hull<sivector,cvector,civector>(v1,v2);
2184 return fsp_vv_hull<civector_slice,srvector,civector>(v1,v2);
2189 return fsp_vv_hull<civector_slice,scvector,civector>(v1,v2);
2194 return fsp_vv_hull<civector_slice,sivector,civector>(v1,v2);
2199 return fsp_vv_hull<civector_slice,scivector,civector>(v1,v2);
2204 return fsp_vv_hull<rvector_slice,scivector,civector>(v1,v2);
2209 return fsp_vv_hull<cvector_slice,scivector,civector>(v1,v2);
2214 return fsp_vv_hull<ivector_slice,scivector,civector>(v1,v2);
2219 return fsp_vv_hull<cvector_slice,sivector,civector>(v1,v2);
2224 return fsp_vv_hull<ivector_slice,scvector,civector>(v1,v2);
2229 return spf_vv_hull<scivector,rvector_slice,civector>(v1,v2);
2234 return spf_vv_hull<scivector,cvector_slice,civector>(v1,v2);
2239 return spf_vv_hull<scivector,ivector_slice,civector>(v1,v2);
2244 return spf_vv_hull<scivector,civector_slice,civector>(v1,v2);
2249 return spf_vv_hull<srvector,civector_slice,civector>(v1,v2);
2254 return spf_vv_hull<scvector,civector_slice,civector>(v1,v2);
2259 return spf_vv_hull<sivector,civector_slice,civector>(v1,v2);
2264 return spf_vv_hull<scvector,ivector_slice,civector>(v1,v2);
2269 return spf_vv_hull<sivector,cvector_slice,civector>(v1,v2);
2274 return spsp_vv_hull<scivector,srvector,scivector,cinterval>(v1,v2);
2279 return spsp_vv_hull<scivector,scvector,scivector,cinterval>(v1,v2);
2284 return spsp_vv_hull<scivector,sivector,scivector,cinterval>(v1,v2);
2289 return spsp_vv_hull<scivector,scivector,scivector,cinterval>(v1,v2);
2294 return spsp_vv_hull<srvector,scivector,scivector,cinterval>(v1,v2);
2299 return spsp_vv_hull<scvector,scivector,scivector,cinterval>(v1,v2);
2304 return spsp_vv_hull<sivector,scivector,scivector,cinterval>(v1,v2);
2309 return spsp_vv_hull<scvector,sivector,scivector,cinterval>(v1,v2);
2314 return spsp_vv_hull<sivector,scvector,scivector,cinterval>(v1,v2);
2319 return fsp_vv_hull<cvector,srvector,civector>(v1,v2);
2324 return fsp_vv_hull<rvector,scvector,civector>(v1,v2);
2329 return fsp_vv_hull<cvector,scvector,civector>(v1,v2);
2334 return spf_vv_hull<scvector,rvector,civector>(v1,v2);
2339 return spf_vv_hull<srvector,cvector,civector>(v1,v2);
2344 return spf_vv_hull<scvector,cvector,civector>(v1,v2);
2349 return fsp_vv_hull<cvector_slice,srvector,civector>(v1,v2);
2354 return fsp_vv_hull<rvector_slice,scvector,civector>(v1,v2);
2359 return fsp_vv_hull<cvector_slice,scvector,civector>(v1,v2);
2364 return spf_vv_hull<scvector,rvector_slice,civector>(v1,v2);
2369 return spf_vv_hull<srvector,cvector_slice,civector>(v1,v2);
2374 return spf_vv_hull<scvector,cvector_slice,civector>(v1,v2);
2379 return spsp_vv_hull<scvector,srvector,scivector,cinterval>(v1,v2);
2384 return spsp_vv_hull<srvector,scvector,scivector,cinterval>(v1,v2);
2389 return spsp_vv_hull<scvector,scvector,scivector,cinterval>(v1,v2);
2394 return fsl_vv_hull<cvector,srvector_slice,civector>(v1,v2);
2399 return fsl_vv_hull<rvector,scvector_slice,civector>(v1,v2);
2404 return fsl_vv_hull<cvector,scvector_slice,civector>(v1,v2);
2409 return slf_vv_hull<scvector_slice,rvector,civector>(v1,v2);
2414 return slf_vv_hull<srvector_slice,cvector,civector>(v1,v2);
2419 return slf_vv_hull<scvector_slice,cvector,civector>(v1,v2);
2424 return fsl_vv_hull<cvector_slice,srvector_slice,civector>(v1,v2);
2429 return fsl_vv_hull<rvector_slice,scvector_slice,civector>(v1,v2);
2434 return fsl_vv_hull<cvector_slice,scvector_slice,civector>(v1,v2);
2439 return slf_vv_hull<scvector_slice,rvector_slice,civector>(v1,v2);
2444 return slf_vv_hull<srvector_slice,cvector_slice,civector>(v1,v2);
2449 return slf_vv_hull<scvector_slice,cvector_slice,civector>(v1,v2);
2454 return slsl_vv_hull<scvector_slice,srvector_slice,scivector,cinterval>(v1,v2);
2459 return slsl_vv_hull<srvector_slice,scvector_slice,scivector,cinterval>(v1,v2);
2464 return slsl_vv_hull<scvector_slice,scvector_slice,scivector,cinterval>(v1,v2);
2469 return spsl_vv_hull<scvector,srvector_slice,scivector,cinterval>(v1,v2);
2474 return spsl_vv_hull<srvector,scvector_slice,scivector,cinterval>(v1,v2);
2479 return spsl_vv_hull<scvector,scvector_slice,scivector,cinterval>(v1,v2);
2484 return slsp_vv_hull<scvector_slice,srvector,scivector,cinterval>(v1,v2);
2489 return slsp_vv_hull<srvector_slice,scvector,scivector,cinterval>(v1,v2);
2494 return slsp_vv_hull<scvector_slice,scvector,scivector,cinterval>(v1,v2);
2499 return fsp_vv_intersect<civector,sivector,civector>(v1,v2);
2504 return fsp_vv_intersect<civector,scivector,civector>(v1,v2);
2509 return fsp_vv_intersect<ivector,scivector,civector>(v1,v2);
2514 return spf_vv_intersect<scivector,ivector,civector>(v1,v2);
2519 return spf_vv_intersect<scivector,civector,civector>(v1,v2);
2524 return spf_vv_intersect<sivector,civector,civector>(v1,v2);
2529 return fsp_vv_intersect<civector_slice,sivector,civector>(v1,v2);
2534 return fsp_vv_intersect<civector_slice,scivector,civector>(v1,v2);
2539 return fsp_vv_intersect<ivector_slice,scivector,civector>(v1,v2);
2544 return spf_vv_intersect<scivector,ivector_slice,civector>(v1,v2);
2549 return spf_vv_intersect<scivector,civector_slice,civector>(v1,v2);
2554 return spf_vv_intersect<sivector,civector_slice,civector>(v1,v2);
2559 return spsp_vv_intersect<scivector,sivector,scivector,cinterval>(v1,v2);
2564 return spsp_vv_intersect<scivector,scivector,scivector,cinterval>(v1,v2);
2569 return spsp_vv_intersect<sivector,scivector,scivector,cinterval>(v1,v2);
2573 return fsp_vv_addassign(*
this,v2);
2577 return fsp_vv_addassign(*
this,v2);
2581 return fsp_vv_addassign(*
this,v2);
2585 return fsp_vv_addassign(*
this,v2);
2589 return fsp_vv_addassign(*
this,v2);
2593 return fsp_vv_addassign(*
this,v2);
2597 return fsp_vv_addassign(*
this,v2);
2601 return fsp_vv_addassign(*
this,v2);
2605 return fsp_vv_subassign(*
this,v2);
2609 return fsp_vv_subassign(*
this,v2);
2613 return fsp_vv_subassign(*
this,v2);
2617 return fsp_vv_subassign(*
this,v2);
2621 return fsp_vv_subassign(*
this,v2);
2625 return fsp_vv_subassign(*
this,v2);
2629 return fsp_vv_subassign(*
this,v2);
2633 return fsp_vv_subassign(*
this,v2);
2637 return fsp_vv_hullassign(*
this,v2);
2641 return fsp_vv_hullassign(*
this,v2);
2645 return fsp_vv_hullassign(*
this,v2);
2649 return fsp_vv_hullassign(*
this,v2);
2653 return fsp_vv_hullassign(*
this,v2);
2657 return fsp_vv_hullassign(*
this,v2);
2661 return fsp_vv_hullassign(*
this,v2);
2665 return fsp_vv_hullassign(*
this,v2);
2669 return fsp_vv_intersectassign(*
this,v2);
2673 return fsp_vv_intersectassign(*
this,v2);
2677 return fsp_vv_intersectassign(*
this,v2);
2681 return fsp_vv_intersectassign(*
this,v2);
2689 return spsp_vv_comp(v1,v2);
2697 return spsp_vv_comp(v1,v2);
2705 return spsp_vv_comp(v1,v2);
2713 return spsp_vv_comp(v1,v2);
2721 return spsp_vv_comp(v1,v2);
2729 return spsp_vv_comp(v1,v2);
2737 return spsp_vv_comp(v1,v2);
2745 return spf_vv_comp(v1,v2);
2753 return spf_vv_comp(v1,v2);
2761 return spf_vv_comp(v1,v2);
2769 return spf_vv_comp(v1,v2);
2777 return spf_vv_comp(v1,v2);
2785 return spf_vv_comp(v1,v2);
2793 return spf_vv_comp(v1,v2);
2801 return fsp_vv_comp(v1,v2);
2809 return fsp_vv_comp(v1,v2);
2817 return fsp_vv_comp(v1,v2);
2825 return fsp_vv_comp(v1,v2);
2833 return fsp_vv_comp(v1,v2);
2841 return fsp_vv_comp(v1,v2);
2849 return fsp_vv_comp(v1,v2);
2857 return spf_vv_comp(v1,v2);
2865 return spf_vv_comp(v1,v2);
2873 return spf_vv_comp(v1,v2);
2881 return spf_vv_comp(v1,v2);
2889 return spf_vv_comp(v1,v2);
2897 return spf_vv_comp(v1,v2);
2905 return spf_vv_comp(v1,v2);
2913 return fsp_vv_comp(v1,v2);
2921 return fsp_vv_comp(v1,v2);
2929 return fsp_vv_comp(v1,v2);
2937 return fsp_vv_comp(v1,v2);
2945 return fsp_vv_comp(v1,v2);
2953 return fsp_vv_comp(v1,v2);
2961 return fsp_vv_comp(v1,v2);
2969 return !spsp_vv_comp(v1,v2);
2977 return !spsp_vv_comp(v1,v2);
2985 return !spsp_vv_comp(v1,v2);
2993 return !spsp_vv_comp(v1,v2);
3001 return !spsp_vv_comp(v1,v2);
3009 return !spsp_vv_comp(v1,v2);
3017 return !spsp_vv_comp(v1,v2);
3025 return !spf_vv_comp(v1,v2);
3033 return !spf_vv_comp(v1,v2);
3041 return !spf_vv_comp(v1,v2);
3049 return !spf_vv_comp(v1,v2);
3057 return !spf_vv_comp(v1,v2);
3065 return !spf_vv_comp(v1,v2);
3073 return !spf_vv_comp(v1,v2);
3081 return !fsp_vv_comp(v1,v2);
3089 return !fsp_vv_comp(v1,v2);
3097 return !fsp_vv_comp(v1,v2);
3105 return !fsp_vv_comp(v1,v2);
3113 return !fsp_vv_comp(v1,v2);
3121 return !fsp_vv_comp(v1,v2);
3129 return !spf_vv_comp(v1,v2);
3137 return !spf_vv_comp(v1,v2);
3145 return !spf_vv_comp(v1,v2);
3153 return !spf_vv_comp(v1,v2);
3161 return !spf_vv_comp(v1,v2);
3169 return !spf_vv_comp(v1,v2);
3177 return !spf_vv_comp(v1,v2);
3185 return !fsp_vv_comp(v1,v2);
3193 return !fsp_vv_comp(v1,v2);
3201 return !fsp_vv_comp(v1,v2);
3209 return !fsp_vv_comp(v1,v2);
3217 return !fsp_vv_comp(v1,v2);
3225 return !fsp_vv_comp(v1,v2);
3233 return !fsp_vv_comp(v1,v2);
3241 return spsp_vv_less<scivector,scivector,cinterval>(v1,v2);
3249 return spsp_vv_less<scivector,sivector,cinterval>(v1,v2);
3257 return spsp_vv_less<srvector,scivector,cinterval>(v1,v2);
3265 return spsp_vv_less<scvector,scivector,cinterval>(v1,v2);
3273 return spsp_vv_less<sivector,scivector,cinterval>(v1,v2);
3281 return spf_vv_less<scivector,ivector,cinterval>(v1,v2);
3289 return spf_vv_less<scivector,civector,cinterval>(v1,v2);
3297 return spf_vv_less<srvector,civector,cinterval>(v1,v2);
3305 return spf_vv_less<scvector,civector,cinterval>(v1,v2);
3313 return spf_vv_less<sivector,civector,cinterval>(v1,v2);
3321 return fsp_vv_less<civector,sivector,cinterval>(v1,v2);
3329 return fsp_vv_less<civector,scivector,cinterval>(v1,v2);
3337 return fsp_vv_less<rvector,scivector,cinterval>(v1,v2);
3345 return fsp_vv_less<cvector,scivector,cinterval>(v1,v2);
3353 return fsp_vv_less<ivector,scivector,cinterval>(v1,v2);
3361 return spf_vv_less<scivector,ivector_slice,cinterval>(v1,v2);
3369 return spf_vv_less<srvector,civector_slice,cinterval>(v1,v2);
3377 return spf_vv_less<scvector,civector_slice,cinterval>(v1,v2);
3385 return spf_vv_less<sivector,civector_slice,cinterval>(v1,v2);
3393 return spf_vv_less<scivector,civector_slice,cinterval>(v1,v2);
3401 return fsp_vv_less<civector_slice,sivector,cinterval>(v1,v2);
3409 return fsp_vv_less<rvector_slice,scivector,cinterval>(v1,v2);
3417 return fsp_vv_less<ivector_slice,scivector,cinterval>(v1,v2);
3425 return fsp_vv_less<cvector_slice,scivector,cinterval>(v1,v2);
3433 return fsp_vv_less<civector_slice,scivector,cinterval>(v1,v2);
3441 return spsp_vv_leq<scivector,scivector,cinterval>(v1,v2);
3449 return spsp_vv_leq<scivector,sivector,cinterval>(v1,v2);
3457 return spsp_vv_leq<srvector,scivector,cinterval>(v1,v2);
3465 return spsp_vv_leq<scvector,scivector,cinterval>(v1,v2);
3473 return spsp_vv_leq<sivector,scivector,cinterval>(v1,v2);
3481 return spf_vv_leq<scivector,ivector,cinterval>(v1,v2);
3489 return spf_vv_leq<scivector,civector,cinterval>(v1,v2);
3497 return spf_vv_leq<srvector,civector,cinterval>(v1,v2);
3505 return spf_vv_leq<scvector,civector,cinterval>(v1,v2);
3513 return spf_vv_leq<sivector,civector,cinterval>(v1,v2);
3521 return fsp_vv_leq<civector,sivector,cinterval>(v1,v2);
3529 return fsp_vv_leq<civector,scivector,cinterval>(v1,v2);
3537 return fsp_vv_leq<rvector,scivector,cinterval>(v1,v2);
3545 return fsp_vv_leq<cvector,scivector,cinterval>(v1,v2);
3553 return fsp_vv_leq<ivector,scivector,cinterval>(v1,v2);
3561 return spf_vv_leq<scivector,ivector_slice,cinterval>(v1,v2);
3569 return spf_vv_leq<srvector,civector_slice,cinterval>(v1,v2);
3577 return spf_vv_leq<scvector,civector_slice,cinterval>(v1,v2);
3585 return spf_vv_leq<sivector,civector_slice,cinterval>(v1,v2);
3593 return spf_vv_leq<scivector,civector_slice,cinterval>(v1,v2);
3601 return fsp_vv_leq<civector_slice,sivector,cinterval>(v1,v2);
3609 return fsp_vv_leq<rvector_slice,scivector,cinterval>(v1,v2);
3617 return fsp_vv_leq<ivector_slice,scivector,cinterval>(v1,v2);
3625 return fsp_vv_leq<cvector_slice,scivector,cinterval>(v1,v2);
3633 return fsp_vv_leq<civector_slice,scivector,cinterval>(v1,v2);
3641 return spsp_vv_greater<scivector,scivector,cinterval>(v1,v2);
3649 return spsp_vv_greater<scivector,srvector,cinterval>(v1,v2);
3657 return spsp_vv_greater<scivector,sivector,cinterval>(v1,v2);
3665 return spsp_vv_greater<scivector,scvector,cinterval>(v1,v2);
3673 return spsp_vv_greater<sivector,scivector,cinterval>(v1,v2);
3681 return spf_vv_greater<scivector,rvector,cinterval>(v1,v2);
3689 return spf_vv_greater<scivector,cvector,cinterval>(v1,v2);
3697 return spf_vv_greater<scivector,ivector,cinterval>(v1,v2);
3705 return spf_vv_greater<scivector,civector,cinterval>(v1,v2);
3713 return spf_vv_greater<sivector,civector,cinterval>(v1,v2);
3721 return fsp_vv_greater<civector,srvector,cinterval>(v1,v2);
3729 return fsp_vv_greater<civector,scvector,cinterval>(v1,v2);
3737 return fsp_vv_greater<civector,sivector,cinterval>(v1,v2);
3745 return fsp_vv_greater<civector,scivector,cinterval>(v1,v2);
3753 return fsp_vv_greater<ivector,scivector,cinterval>(v1,v2);
3761 return spf_vv_greater<scivector,rvector_slice,cinterval>(v1,v2);
3769 return spf_vv_greater<scivector,ivector_slice,cinterval>(v1,v2);
3777 return spf_vv_greater<scivector,cvector_slice,cinterval>(v1,v2);
3785 return spf_vv_greater<sivector,civector_slice,cinterval>(v1,v2);
3793 return spf_vv_greater<scivector,civector_slice,cinterval>(v1,v2);
3801 return fsp_vv_greater<civector_slice,srvector,cinterval>(v1,v2);
3809 return fsp_vv_greater<civector_slice,sivector,cinterval>(v1,v2);
3817 return fsp_vv_greater<civector_slice,scvector,cinterval>(v1,v2);
3825 return fsp_vv_greater<ivector_slice,scivector,cinterval>(v1,v2);
3833 return fsp_vv_greater<civector_slice,scivector,cinterval>(v1,v2);
3841 return spsp_vv_geq<scivector,scivector,cinterval>(v1,v2);
3849 return spsp_vv_geq<scivector,srvector,cinterval>(v1,v2);
3857 return spsp_vv_geq<scivector,sivector,cinterval>(v1,v2);
3865 return spsp_vv_geq<scivector,scvector,cinterval>(v1,v2);
3873 return spsp_vv_geq<sivector,scivector,cinterval>(v1,v2);
3881 return spf_vv_geq<scivector,rvector,cinterval>(v1,v2);
3889 return spf_vv_geq<scivector,cvector,cinterval>(v1,v2);
3897 return spf_vv_geq<scivector,ivector,cinterval>(v1,v2);
3905 return spf_vv_geq<scivector,civector,cinterval>(v1,v2);
3913 return spf_vv_geq<sivector,civector,cinterval>(v1,v2);
3921 return fsp_vv_geq<civector,srvector,cinterval>(v1,v2);
3929 return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
3937 return fsp_vv_geq<civector,sivector,cinterval>(v1,v2);
3945 return fsp_vv_geq<civector,scivector,cinterval>(v1,v2);
3953 return fsp_vv_geq<ivector,scivector,cinterval>(v1,v2);
3961 return spf_vv_geq<scivector,rvector_slice,cinterval>(v1,v2);
3969 return spf_vv_geq<scivector,ivector_slice,cinterval>(v1,v2);
3977 return spf_vv_geq<scivector,cvector_slice,cinterval>(v1,v2);
3985 return spf_vv_geq<sivector,civector_slice,cinterval>(v1,v2);
3993 return spf_vv_geq<scivector,civector_slice,cinterval>(v1,v2);
4001 return fsp_vv_geq<civector_slice,srvector,cinterval>(v1,v2);
4009 return fsp_vv_geq<civector_slice,sivector,cinterval>(v1,v2);
4017 return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
4025 return fsp_vv_geq<ivector_slice,scivector,cinterval>(v1,v2);
4033 return fsp_vv_geq<civector_slice,scivector,cinterval>(v1,v2);
4042 inline std::ostream& operator<<(std::ostream& os,
const scivector& v) {
4043 return sp_v_output<scivector,cinterval>(os,v);
4052 inline std::istream& operator>>(std::istream& is,
scivector& v) {
4053 return sp_v_input<scivector,cinterval>(is,v);
4065 std::vector<int>& p;
4066 std::vector<cinterval>& x;
4083 for(i=0 ; i<v.
get_nnz() && p[i]<lb-v.lb ; i++);
4087 for(i=start ; i<v.
get_nnz() && p[i]<=ub-v.lb ; i++);
4104 return (
double)nnz/n;
4113 #if(CXSC_INDEX_CHECK) 4114 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector_slice::operator[](const int)"));
4118 for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
4119 if(p[k]-offset == i-lb)
4123 p.insert(p.begin() + k, i-lb);
4124 x.insert(x.begin() + k,
cinterval(0.0));
4136 #if(CXSC_INDEX_CHECK) 4137 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector_slice::operator[](const int)"));
4148 #if(CXSC_INDEX_CHECK) 4149 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector_slice::operator()(const int)"));
4153 for(
int k=start ; k<end && p[k]-start<=i-lb ; k++) {
4154 if(p[k]-start == i-lb)
4163 return sl_vs_assign<scivector_slice,real,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4168 return sl_vs_assign<scivector_slice,complex,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4173 return sl_vs_assign<scivector_slice,interval,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4178 return sl_vs_assign<scivector_slice,cinterval,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4183 return slsl_vv_assign<scivector_slice,srvector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4188 return slsl_vv_assign<scivector_slice,scvector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4193 return slsl_vv_assign<scivector_slice,sivector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4198 return slsl_vv_assign<scivector_slice,scivector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4203 return slsp_vv_assign<scivector_slice,srvector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4208 return slsp_vv_assign<scivector_slice,scvector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4213 return slsp_vv_assign<scivector_slice,sivector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4218 return slsp_vv_assign<scivector_slice,scivector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4223 return slf_vv_assign<scivector_slice,rvector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4228 return slf_vv_assign<scivector_slice,cvector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4233 return slf_vv_assign<scivector_slice,ivector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4238 return slf_vv_assign<scivector_slice,civector,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4243 return slf_vv_assign<scivector_slice,rvector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4248 return slf_vv_assign<scivector_slice,cvector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4253 return slf_vv_assign<scivector_slice,ivector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4258 return slf_vv_assign<scivector_slice,civector_slice,cinterval,std::vector<cinterval>::iterator>(*
this,v);
4263 return sl_vs_multassign(*
this,s);
4268 return sl_vs_multassign(*
this,s);
4273 return sl_vs_multassign(*
this,s);
4278 return sl_vs_multassign(*
this,s);
4283 return sl_vs_divassign(*
this,s);
4288 return sl_vs_divassign(*
this,s);
4292 return sl_vs_divassign(*
this,s);
4297 return sl_vs_divassign(*
this,s);
4302 return slf_vv_addassign<scivector_slice,rvector,cinterval>(*
this,v);
4307 return slf_vv_addassign<scivector_slice,ivector,cinterval>(*
this,v);
4312 return slf_vv_addassign<scivector_slice,cvector,cinterval>(*
this,v);
4317 return slf_vv_addassign<scivector_slice,civector,cinterval>(*
this,v);
4322 return slf_vv_addassign<scivector_slice,rvector_slice,cinterval>(*
this,v);
4327 return slf_vv_addassign<scivector_slice,cvector_slice,cinterval>(*
this,v);
4332 return slf_vv_addassign<scivector_slice,ivector_slice,cinterval>(*
this,v);
4337 return slf_vv_addassign<scivector_slice,civector_slice,cinterval>(*
this,v);
4342 return slsp_vv_addassign(*
this,v);
4347 return slsp_vv_addassign(*
this,v);
4352 return slsp_vv_addassign(*
this,v);
4357 return slsp_vv_addassign(*
this,v);
4362 return slsl_vv_addassign(*
this,v);
4367 return slsl_vv_addassign(*
this,v);
4372 return slsl_vv_addassign(*
this,v);
4377 return slsl_vv_addassign(*
this,v);
4382 return slf_vv_subassign<scivector_slice,rvector,cinterval>(*
this,v);
4387 return slf_vv_subassign<scivector_slice,ivector,cinterval>(*
this,v);
4392 return slf_vv_subassign<scivector_slice,cvector,cinterval>(*
this,v);
4397 return slf_vv_subassign<scivector_slice,civector,cinterval>(*
this,v);
4402 return slf_vv_subassign<scivector_slice,rvector_slice,cinterval>(*
this,v);
4407 return slf_vv_subassign<scivector_slice,cvector_slice,cinterval>(*
this,v);
4412 return slf_vv_subassign<scivector_slice,ivector_slice,cinterval>(*
this,v);
4417 return slf_vv_subassign<scivector_slice,civector_slice,cinterval>(*
this,v);
4422 return slsp_vv_subassign(*
this,v);
4427 return slsp_vv_subassign(*
this,v);
4432 return slsp_vv_subassign(*
this,v);
4437 return slsp_vv_subassign(*
this,v);
4442 return slsl_vv_subassign(*
this,v);
4447 return slsl_vv_subassign(*
this,v);
4452 return slsl_vv_subassign(*
this,v);
4457 return slsl_vv_subassign(*
this,v);
4462 return slf_vv_hullassign<scivector_slice,rvector,cinterval>(*
this,v);
4467 return slf_vv_hullassign<scivector_slice,ivector,cinterval>(*
this,v);
4472 return slf_vv_hullassign<scivector_slice,cvector,cinterval>(*
this,v);
4477 return slf_vv_hullassign<scivector_slice,civector,cinterval>(*
this,v);
4482 return slf_vv_hullassign<scivector_slice,rvector_slice,cinterval>(*
this,v);
4487 return slf_vv_hullassign<scivector_slice,cvector_slice,cinterval>(*
this,v);
4492 return slf_vv_hullassign<scivector_slice,ivector_slice,cinterval>(*
this,v);
4497 return slf_vv_hullassign<scivector_slice,civector_slice,cinterval>(*
this,v);
4502 return slsp_vv_hullassign(*
this,v);
4507 return slsp_vv_hullassign(*
this,v);
4512 return slsp_vv_hullassign(*
this,v);
4517 return slsp_vv_hullassign(*
this,v);
4522 return slsl_vv_hullassign(*
this,v);
4527 return slsl_vv_hullassign(*
this,v);
4532 return slsl_vv_hullassign(*
this,v);
4537 return slsl_vv_hullassign(*
this,v);
4542 return slf_vv_intersectassign<scivector_slice,ivector,cinterval>(*
this,v);
4547 return slf_vv_intersectassign<scivector_slice,civector,cinterval>(*
this,v);
4552 return slf_vv_intersectassign<scivector_slice,ivector_slice,cinterval>(*
this,v);
4557 return slf_vv_intersectassign<scivector_slice,civector_slice,cinterval>(*
this,v);
4562 return slsp_vv_intersectassign(*
this,v);
4567 return slsp_vv_intersectassign(*
this,v);
4572 return slsl_vv_intersectassign(*
this,v);
4577 return slsl_vv_intersectassign(*
this,v);
4606 #include "vector_friend_declarations.inl" 4614 for(
int i=0 ; i<v.n ; i++)
4616 for(
int i=v.start ; i<=v.end ; i++)
4617 dat[v.p[i]] = v.x[i];
4625 for(
int i=0 ; i<v.n ; i++)
4627 for(
int i=v.start ; i<=v.end ; i++)
4628 dat[v.p[i]] = v.x[i];
4636 for(
int i=0 ; i<v.n ; i++)
4638 for(
int i=v.start ; i<=v.end ; i++)
4639 dat[v.p[i]] = v.x[i];
4647 for(
int i=0 ; i<v.n ; i++)
4649 for(
int i=v.start ; i<=v.end ; i++)
4650 dat[v.p[i]] = v.x[i];
4697 for(
int i=s.start ; i<=s.end ; i++) {
4698 p.push_back(s.p[i]-s.offset);
4708 for(
int i=s.start ; i<=s.end ; i++) {
4709 p.push_back(s.p[i]-s.offset);
4719 for(
int i=s.start ; i<=s.end ; i++) {
4720 p.push_back(s.p[i]-s.offset);
4730 for(
int i=s.start ; i<=s.end ; i++) {
4731 p.push_back(s.p[i]-s.offset);
4732 x.push_back(s.x[i]);
4738 return spsl_vv_assign<scivector,srvector_slice,cinterval>(*
this,v);
4742 return spsl_vv_assign<scivector,scvector_slice,cinterval>(*
this,v);
4746 return spsl_vv_assign<scivector,sivector_slice,cinterval>(*
this,v);
4750 return spsl_vv_assign<scivector,scivector_slice,cinterval>(*
this,v);
4754 #if(CXSC_INDEX_CHECK) 4755 if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector_slice::operator()(const int, const int)"));
4762 return sl_v_negative<scivector_slice,scivector>(v);
4821 for(
int i=v.start ; i<=v.end ; i++)
4822 res.x.push_back(
conj(v.x[i]));
4832 for(
int i=v.start ; i<=v.end ; i++)
4833 res.x.push_back(
abs(v.x[i]));
4843 for(
int i=v.start ; i<=v.end ; i++)
4844 res.x.push_back(
mid(v.x[i]));
4854 for(
int i=v.start ; i<v.end ; i++)
4855 res.x.push_back(
diam(v.x[i]));
4872 return slf_vv_mult<scivector_slice,rvector,cinterval,sparse_cidot>(v1,v2);
4883 return slf_vv_mult<scivector_slice,cvector,cinterval,sparse_cidot>(v1,v2);
4894 return slf_vv_mult<scivector_slice,ivector,cinterval,sparse_cidot>(v1,v2);
4905 return slf_vv_mult<scivector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4916 return slf_vv_mult<srvector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4927 return slf_vv_mult<sivector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4938 return slf_vv_mult<scvector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4949 return slf_vv_mult<scvector_slice,ivector,cinterval,sparse_cidot>(v1,v2);
4960 return slf_vv_mult<sivector_slice,cvector,cinterval,sparse_cidot>(v1,v2);
4971 return fsl_vv_mult<civector,srvector_slice,cinterval,sparse_cidot>(v1,v2);
4982 return fsl_vv_mult<civector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
4993 return fsl_vv_mult<civector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5004 return fsl_vv_mult<civector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5015 return fsl_vv_mult<rvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5026 return fsl_vv_mult<cvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5037 return fsl_vv_mult<ivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5048 return fsl_vv_mult<cvector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5059 return fsl_vv_mult<ivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5070 return slf_vv_mult<scivector_slice,rvector_slice,cinterval,sparse_cidot>(v1,v2);
5081 return slf_vv_mult<scivector_slice,ivector_slice,cinterval,sparse_cidot>(v1,v2);
5092 return slf_vv_mult<scivector_slice,cvector_slice,cinterval,sparse_cidot>(v1,v2);
5103 return slf_vv_mult<scivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5114 return slf_vv_mult<srvector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5125 return slf_vv_mult<scvector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5136 return slf_vv_mult<sivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5147 return slf_vv_mult<scvector_slice,ivector_slice,cinterval,sparse_cidot>(v1,v2);
5158 return slf_vv_mult<sivector_slice,cvector_slice,cinterval,sparse_cidot>(v1,v2);
5169 return fsl_vv_mult<civector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5180 return fsl_vv_mult<civector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5191 return fsl_vv_mult<civector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5202 return fsl_vv_mult<civector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5213 return fsl_vv_mult<rvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5224 return fsl_vv_mult<ivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5235 return fsl_vv_mult<cvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5246 return fsl_vv_mult<cvector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5257 return fsl_vv_mult<ivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5268 return spsl_vv_mult<scivector,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5279 return spsl_vv_mult<scivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5290 return spsl_vv_mult<scivector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5301 return spsl_vv_mult<scivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5312 return spsl_vv_mult<srvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5323 return spsl_vv_mult<scvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5334 return spsl_vv_mult<sivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5345 return spsl_vv_mult<scvector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5356 return spsl_vv_mult<sivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5367 return slsp_vv_mult<scivector_slice,srvector,cinterval,sparse_cidot>(v1,v2);
5378 return slsp_vv_mult<scivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
5389 return slsp_vv_mult<scivector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
5400 return slsp_vv_mult<scivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5411 return slsp_vv_mult<srvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5422 return slsp_vv_mult<sivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5433 return slsp_vv_mult<scvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5444 return slsp_vv_mult<scvector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
5455 return slsp_vv_mult<sivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
5466 return slsl_vv_mult<scivector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5477 return slsl_vv_mult<scivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5488 return slsl_vv_mult<scivector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5499 return slsl_vv_mult<scivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5510 return slsl_vv_mult<srvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5521 return slsl_vv_mult<scvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5532 return slsl_vv_mult<sivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5543 return slsl_vv_mult<sivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5554 return slsl_vv_mult<scvector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5559 return sp_vs_mult<scivector_slice,real,scivector>(v,s);
5564 return sp_vs_mult<scivector_slice,complex,scivector>(v,s);
5569 return sp_vs_mult<scivector_slice,interval,scivector>(v,s);
5574 return sp_vs_mult<scivector_slice,cinterval,scivector>(v,s);
5579 return sp_vs_mult<srvector_slice,cinterval,scivector>(v,s);
5584 return sp_vs_mult<scvector_slice,cinterval,scivector>(v,s);
5589 return sp_vs_mult<sivector_slice,cinterval,scivector>(v,s);
5594 return sp_vs_mult<scvector_slice,interval,scivector>(v,s);
5599 return sp_vs_mult<sivector_slice,complex,scivector>(v,s);
5604 return sp_vs_div<scivector_slice,real,scivector>(v,s);
5609 return sp_vs_div<scivector_slice,complex,scivector>(v,s);
5614 return sp_vs_div<scivector_slice,interval,scivector>(v,s);
5619 return sp_vs_div<scivector_slice,cinterval,scivector>(v,s);
5624 return sp_vs_div<srvector_slice,cinterval,scivector>(v,s);
5629 return sp_vs_div<scvector_slice,cinterval,scivector>(v,s);
5634 return sp_vs_div<sivector_slice,cinterval,scivector>(v,s);
5639 return sp_vs_div<scvector_slice,interval,scivector>(v,s);
5644 return sp_vs_div<sivector_slice,complex,scivector>(v,s);
5649 return sp_sv_mult<real,scivector_slice,scivector>(s,v);
5654 return sp_sv_mult<complex,scivector_slice,scivector>(s,v);
5659 return sp_sv_mult<interval,scivector_slice,scivector>(s,v);
5664 return sp_sv_mult<cinterval,scivector_slice,scivector>(s,v);
5669 return sp_sv_mult<cinterval,srvector_slice,scivector>(s,v);
5674 return sp_sv_mult<cinterval,scvector_slice,scivector>(s,v);
5679 return sp_sv_mult<cinterval,sivector_slice,scivector>(s,v);
5684 return sp_sv_mult<complex,sivector_slice,scivector>(s,v);
5689 return sp_sv_mult<interval,scvector_slice,scivector>(s,v);
5694 return fsl_vv_add<civector,srvector_slice,civector>(v1,v2);
5699 return fsl_vv_add<civector,scvector_slice,civector>(v1,v2);
5704 return fsl_vv_add<civector,sivector_slice,civector>(v1,v2);
5709 return fsl_vv_add<civector,scivector_slice,civector>(v1,v2);
5714 return fsl_vv_add<rvector,scivector_slice,civector>(v1,v2);
5719 return fsl_vv_add<cvector,scivector_slice,civector>(v1,v2);
5724 return fsl_vv_add<ivector,scivector_slice,civector>(v1,v2);
5729 return fsl_vv_add<cvector,sivector_slice,civector>(v1,v2);
5734 return fsl_vv_add<ivector,scvector_slice,civector>(v1,v2);
5739 return slf_vv_add<scivector_slice,rvector,civector>(v1,v2);
5744 return slf_vv_add<scivector_slice,cvector,civector>(v1,v2);
5749 return slf_vv_add<scivector_slice,ivector,civector>(v1,v2);
5754 return slf_vv_add<scivector_slice,civector,civector>(v1,v2);
5759 return slf_vv_add<srvector_slice,civector,civector>(v1,v2);
5764 return slf_vv_add<scvector_slice,civector,civector>(v1,v2);
5769 return slf_vv_add<sivector_slice,civector,civector>(v1,v2);
5774 return slf_vv_add<scvector_slice,ivector,civector>(v1,v2);
5779 return slf_vv_add<sivector_slice,cvector,civector>(v1,v2);
5784 return fsl_vv_add<civector_slice,srvector_slice,civector>(v1,v2);
5789 return fsl_vv_add<civector_slice,scvector_slice,civector>(v1,v2);
5794 return fsl_vv_add<civector_slice,sivector_slice,civector>(v1,v2);
5799 return fsl_vv_add<civector_slice,scivector_slice,civector>(v1,v2);
5804 return fsl_vv_add<rvector_slice,scivector_slice,civector>(v1,v2);
5809 return fsl_vv_add<cvector_slice,scivector_slice,civector>(v1,v2);
5814 return fsl_vv_add<ivector_slice,scivector_slice,civector>(v1,v2);
5819 return fsl_vv_add<ivector_slice,scvector_slice,civector>(v1,v2);
5824 return fsl_vv_add<cvector_slice,sivector_slice,civector>(v1,v2);
5829 return slf_vv_add<scivector_slice,rvector_slice,civector>(v1,v2);
5834 return slf_vv_add<scivector_slice,ivector_slice,civector>(v1,v2);
5839 return slf_vv_add<scivector_slice,cvector_slice,civector>(v1,v2);
5844 return slf_vv_add<scivector_slice,civector_slice,civector>(v1,v2);
5849 return slf_vv_add<srvector_slice,civector_slice,civector>(v1,v2);
5854 return slf_vv_add<sivector_slice,civector_slice,civector>(v1,v2);
5859 return slf_vv_add<scvector_slice,civector_slice,civector>(v1,v2);
5864 return slf_vv_add<scvector_slice,ivector_slice,civector>(v1,v2);
5869 return slf_vv_add<sivector_slice,cvector_slice,civector>(v1,v2);
5874 return slsl_vv_add<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
5879 return slsl_vv_add<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
5884 return slsl_vv_add<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
5889 return slsl_vv_add<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5894 return slsl_vv_add<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5899 return slsl_vv_add<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5904 return slsl_vv_add<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5909 return slsl_vv_add<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
5914 return slsl_vv_add<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
5919 return spsl_vv_add<scivector,srvector_slice,scivector,cinterval>(v1,v2);
5924 return spsl_vv_add<scivector,scvector_slice,scivector,cinterval>(v1,v2);
5929 return spsl_vv_add<scivector,sivector_slice,scivector,cinterval>(v1,v2);
5934 return spsl_vv_add<scivector,scivector_slice,scivector,cinterval>(v1,v2);
5939 return spsl_vv_add<srvector,scivector_slice,scivector,cinterval>(v1,v2);
5944 return spsl_vv_add<scvector,scivector_slice,scivector,cinterval>(v1,v2);
5949 return spsl_vv_add<sivector,scivector_slice,scivector,cinterval>(v1,v2);
5954 return spsl_vv_add<scvector,sivector_slice,scivector,cinterval>(v1,v2);
5959 return spsl_vv_add<sivector,scvector_slice,scivector,cinterval>(v1,v2);
5964 return slsp_vv_add<scivector_slice,srvector,scivector,cinterval>(v1,v2);
5969 return slsp_vv_add<scivector_slice,scvector,scivector,cinterval>(v1,v2);
5974 return slsp_vv_add<scivector_slice,sivector,scivector,cinterval>(v1,v2);
5979 return slsp_vv_add<scivector_slice,scivector,scivector,cinterval>(v1,v2);
5984 return slsp_vv_add<srvector_slice,scivector,scivector,cinterval>(v1,v2);
5989 return slsp_vv_add<scvector_slice,scivector,scivector,cinterval>(v1,v2);
5994 return slsp_vv_add<sivector_slice,scivector,scivector,cinterval>(v1,v2);
5999 return slsp_vv_add<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6004 return slsp_vv_add<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6009 return fsl_vv_sub<civector,srvector_slice,civector>(v1,v2);
6014 return fsl_vv_sub<civector,scvector_slice,civector>(v1,v2);
6019 return fsl_vv_sub<civector,sivector_slice,civector>(v1,v2);
6024 return fsl_vv_sub<civector,scivector_slice,civector>(v1,v2);
6029 return fsl_vv_sub<rvector,scivector_slice,civector>(v1,v2);
6034 return fsl_vv_sub<cvector,scivector_slice,civector>(v1,v2);
6039 return fsl_vv_sub<ivector,scivector_slice,civector>(v1,v2);
6044 return fsl_vv_sub<cvector,sivector_slice,civector>(v1,v2);
6049 return fsl_vv_sub<ivector,scvector_slice,civector>(v1,v2);
6054 return slf_vv_sub<scivector_slice,rvector,civector>(v1,v2);
6059 return slf_vv_sub<scivector_slice,cvector,civector>(v1,v2);
6064 return slf_vv_sub<scivector_slice,ivector,civector>(v1,v2);
6069 return slf_vv_sub<scivector_slice,civector,civector>(v1,v2);
6074 return slf_vv_sub<srvector_slice,civector,civector>(v1,v2);
6079 return slf_vv_sub<scvector_slice,civector,civector>(v1,v2);
6084 return slf_vv_sub<sivector_slice,civector,civector>(v1,v2);
6089 return slf_vv_sub<scvector_slice,ivector,civector>(v1,v2);
6094 return slf_vv_sub<sivector_slice,cvector,civector>(v1,v2);
6099 return fsl_vv_sub<civector_slice,srvector_slice,civector>(v1,v2);
6104 return fsl_vv_sub<civector_slice,scvector_slice,civector>(v1,v2);
6109 return fsl_vv_sub<civector_slice,sivector_slice,civector>(v1,v2);
6114 return fsl_vv_sub<civector_slice,scivector_slice,civector>(v1,v2);
6119 return fsl_vv_sub<rvector_slice,scivector_slice,civector>(v1,v2);
6124 return fsl_vv_sub<cvector_slice,scivector_slice,civector>(v1,v2);
6129 return fsl_vv_sub<ivector_slice,scivector_slice,civector>(v1,v2);
6134 return fsl_vv_sub<ivector_slice,scvector_slice,civector>(v1,v2);
6139 return fsl_vv_sub<cvector_slice,sivector_slice,civector>(v1,v2);
6144 return slf_vv_sub<scivector_slice,rvector_slice,civector>(v1,v2);
6149 return slf_vv_sub<scivector_slice,ivector_slice,civector>(v1,v2);
6154 return slf_vv_sub<scivector_slice,cvector_slice,civector>(v1,v2);
6159 return slf_vv_sub<scivector_slice,civector_slice,civector>(v1,v2);
6164 return slf_vv_sub<srvector_slice,civector_slice,civector>(v1,v2);
6169 return slf_vv_sub<sivector_slice,civector_slice,civector>(v1,v2);
6174 return slf_vv_sub<scvector_slice,civector_slice,civector>(v1,v2);
6179 return slf_vv_sub<scvector_slice,ivector_slice,civector>(v1,v2);
6184 return slf_vv_sub<sivector_slice,cvector_slice,civector>(v1,v2);
6189 return slsl_vv_sub<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
6194 return slsl_vv_sub<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6199 return slsl_vv_sub<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6204 return slsl_vv_sub<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6209 return slsl_vv_sub<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6214 return slsl_vv_sub<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6219 return slsl_vv_sub<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6224 return slsl_vv_sub<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6229 return slsl_vv_sub<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6234 return spsl_vv_sub<scivector,srvector_slice,scivector,cinterval>(v1,v2);
6239 return spsl_vv_sub<scivector,scvector_slice,scivector,cinterval>(v1,v2);
6244 return spsl_vv_sub<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6249 return spsl_vv_sub<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6254 return spsl_vv_sub<srvector,scivector_slice,scivector,cinterval>(v1,v2);
6259 return spsl_vv_sub<scvector,scivector_slice,scivector,cinterval>(v1,v2);
6264 return spsl_vv_sub<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6269 return spsl_vv_sub<scvector,sivector_slice,scivector,cinterval>(v1,v2);
6274 return spsl_vv_sub<sivector,scvector_slice,scivector,cinterval>(v1,v2);
6279 return slsp_vv_sub<scivector_slice,srvector,scivector,cinterval>(v1,v2);
6284 return slsp_vv_sub<scivector_slice,scvector,scivector,cinterval>(v1,v2);
6289 return slsp_vv_sub<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6294 return slsp_vv_sub<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6299 return slsp_vv_sub<srvector_slice,scivector,scivector,cinterval>(v1,v2);
6304 return slsp_vv_sub<scvector_slice,scivector,scivector,cinterval>(v1,v2);
6309 return slsp_vv_sub<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6314 return slsp_vv_sub<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6319 return slsp_vv_sub<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6324 return fsl_vv_hull<civector,srvector_slice,civector>(v1,v2);
6329 return fsl_vv_hull<civector,scvector_slice,civector>(v1,v2);
6334 return fsl_vv_hull<civector,sivector_slice,civector>(v1,v2);
6339 return fsl_vv_hull<civector,scivector_slice,civector>(v1,v2);
6344 return fsl_vv_hull<rvector,scivector_slice,civector>(v1,v2);
6349 return fsl_vv_hull<cvector,scivector_slice,civector>(v1,v2);
6354 return fsl_vv_hull<ivector,scivector_slice,civector>(v1,v2);
6359 return fsl_vv_hull<cvector,sivector_slice,civector>(v1,v2);
6364 return fsl_vv_hull<ivector,scvector_slice,civector>(v1,v2);
6369 return slf_vv_hull<scivector_slice,rvector,civector>(v1,v2);
6374 return slf_vv_hull<scivector_slice,cvector,civector>(v1,v2);
6379 return slf_vv_hull<scivector_slice,ivector,civector>(v1,v2);
6384 return slf_vv_hull<scivector_slice,civector,civector>(v1,v2);
6389 return slf_vv_hull<srvector_slice,civector,civector>(v1,v2);
6394 return slf_vv_hull<scvector_slice,civector,civector>(v1,v2);
6399 return slf_vv_hull<sivector_slice,civector,civector>(v1,v2);
6404 return slf_vv_hull<scvector_slice,ivector,civector>(v1,v2);
6409 return slf_vv_hull<sivector_slice,cvector,civector>(v1,v2);
6414 return fsl_vv_hull<civector_slice,srvector_slice,civector>(v1,v2);
6419 return fsl_vv_hull<civector_slice,scvector_slice,civector>(v1,v2);
6424 return fsl_vv_hull<civector_slice,sivector_slice,civector>(v1,v2);
6429 return fsl_vv_hull<civector_slice,scivector_slice,civector>(v1,v2);
6434 return fsl_vv_hull<rvector_slice,scivector_slice,civector>(v1,v2);
6439 return fsl_vv_hull<cvector_slice,scivector_slice,civector>(v1,v2);
6444 return fsl_vv_hull<ivector_slice,scivector_slice,civector>(v1,v2);
6449 return fsl_vv_hull<ivector_slice,scvector_slice,civector>(v1,v2);
6454 return fsl_vv_hull<cvector_slice,sivector_slice,civector>(v1,v2);
6459 return slf_vv_hull<scivector_slice,rvector_slice,civector>(v1,v2);
6464 return slf_vv_hull<scivector_slice,ivector_slice,civector>(v1,v2);
6469 return slf_vv_hull<scivector_slice,cvector_slice,civector>(v1,v2);
6474 return slf_vv_hull<scivector_slice,civector_slice,civector>(v1,v2);
6479 return slf_vv_hull<srvector_slice,civector_slice,civector>(v1,v2);
6484 return slf_vv_hull<sivector_slice,civector_slice,civector>(v1,v2);
6489 return slf_vv_hull<scvector_slice,civector_slice,civector>(v1,v2);
6494 return slf_vv_hull<scvector_slice,ivector_slice,civector>(v1,v2);
6499 return slf_vv_hull<sivector_slice,cvector_slice,civector>(v1,v2);
6504 return slsl_vv_hull<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
6509 return slsl_vv_hull<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6514 return slsl_vv_hull<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6519 return slsl_vv_hull<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6524 return slsl_vv_hull<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6529 return slsl_vv_hull<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6534 return slsl_vv_hull<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6539 return slsl_vv_hull<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6544 return slsl_vv_hull<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6549 return spsl_vv_hull<scivector,srvector_slice,scivector,cinterval>(v1,v2);
6554 return spsl_vv_hull<scivector,scvector_slice,scivector,cinterval>(v1,v2);
6559 return spsl_vv_hull<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6564 return spsl_vv_hull<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6569 return spsl_vv_hull<srvector,scivector_slice,scivector,cinterval>(v1,v2);
6574 return spsl_vv_hull<scvector,scivector_slice,scivector,cinterval>(v1,v2);
6579 return spsl_vv_hull<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6584 return spsl_vv_hull<scvector,sivector_slice,scivector,cinterval>(v1,v2);
6589 return spsl_vv_hull<sivector,scvector_slice,scivector,cinterval>(v1,v2);
6594 return slsp_vv_hull<scivector_slice,srvector,scivector,cinterval>(v1,v2);
6599 return slsp_vv_hull<scivector_slice,scvector,scivector,cinterval>(v1,v2);
6604 return slsp_vv_hull<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6609 return slsp_vv_hull<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6614 return slsp_vv_hull<srvector_slice,scivector,scivector,cinterval>(v1,v2);
6619 return slsp_vv_hull<scvector_slice,scivector,scivector,cinterval>(v1,v2);
6624 return slsp_vv_hull<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6629 return slsp_vv_hull<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6634 return slsp_vv_hull<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6639 return fsl_vv_intersect<civector,sivector_slice,civector>(v1,v2);
6644 return fsl_vv_intersect<civector,scivector_slice,civector>(v1,v2);
6649 return fsl_vv_intersect<ivector,scivector_slice,civector>(v1,v2);
6654 return slf_vv_intersect<scivector_slice,ivector,civector>(v1,v2);
6659 return slf_vv_intersect<scivector_slice,civector,civector>(v1,v2);
6664 return slf_vv_intersect<sivector_slice,civector,civector>(v1,v2);
6669 return fsl_vv_intersect<civector_slice,sivector_slice,civector>(v1,v2);
6674 return fsl_vv_intersect<civector_slice,scivector_slice,civector>(v1,v2);
6679 return fsl_vv_intersect<ivector_slice,scivector_slice,civector>(v1,v2);
6684 return slf_vv_intersect<scivector_slice,ivector_slice,civector>(v1,v2);
6689 return slf_vv_intersect<scivector_slice,civector_slice,civector>(v1,v2);
6694 return slf_vv_intersect<sivector_slice,civector_slice,civector>(v1,v2);
6699 return slsl_vv_intersect<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6704 return slsl_vv_intersect<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6709 return slsl_vv_intersect<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6714 return spsl_vv_intersect<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6719 return spsl_vv_intersect<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6724 return spsl_vv_intersect<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6729 return slsp_vv_intersect<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6734 return slsp_vv_intersect<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6739 return slsp_vv_intersect<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6743 return fsl_vv_addassign(*
this,v2);
6747 return fsl_vv_addassign(*
this,v2);
6751 return fsl_vv_addassign(*
this,v2);
6755 return fsl_vv_addassign(*
this,v2);
6759 return fsl_vv_addassign(*
this,v2);
6763 return fsl_vv_addassign(*
this,v2);
6767 return fsl_vv_addassign(*
this,v2);
6771 return fsl_vv_addassign(*
this,v2);
6775 return spsl_vv_addassign(*
this,v2);
6779 return spsl_vv_addassign(*
this,v2);
6783 return spsl_vv_addassign(*
this,v2);
6787 return spsl_vv_addassign(*
this,v2);
6791 return fsl_vv_subassign(*
this,v2);
6795 return fsl_vv_subassign(*
this,v2);
6799 return fsl_vv_subassign(*
this,v2);
6803 return fsl_vv_subassign(*
this,v2);
6807 return fsl_vv_subassign(*
this,v2);
6811 return fsl_vv_subassign(*
this,v2);
6815 return fsl_vv_subassign(*
this,v2);
6819 return fsl_vv_subassign(*
this,v2);
6823 return spsl_vv_subassign(*
this,v2);
6827 return spsl_vv_subassign(*
this,v2);
6831 return spsl_vv_subassign(*
this,v2);
6835 return spsl_vv_subassign(*
this,v2);
6839 return fsl_vv_hullassign(*
this,v2);
6843 return fsl_vv_hullassign(*
this,v2);
6847 return fsl_vv_hullassign(*
this,v2);
6851 return fsl_vv_hullassign(*
this,v2);
6855 return fsl_vv_hullassign(*
this,v2);
6859 return fsl_vv_hullassign(*
this,v2);
6863 return fsl_vv_hullassign(*
this,v2);
6867 return fsl_vv_hullassign(*
this,v2);
6871 return spsl_vv_hullassign(*
this,v2);
6875 return spsl_vv_hullassign(*
this,v2);
6879 return spsl_vv_hullassign(*
this,v2);
6883 return spsl_vv_hullassign(*
this,v2);
6887 return fsl_vv_intersectassign(*
this,v2);
6891 return fsl_vv_intersectassign(*
this,v2);
6895 return fsl_vv_intersectassign(*
this,v2);
6899 return fsl_vv_intersectassign(*
this,v2);
6903 return spsl_vv_intersectassign(*
this,v2);
6907 return spsl_vv_intersectassign(*
this,v2);
6915 return slsl_vv_comp(v1,v2);
6923 return slsl_vv_comp(v1,v2);
6931 return slsl_vv_comp(v1,v2);
6939 return slsl_vv_comp(v1,v2);
6947 return slsl_vv_comp(v1,v2);
6955 return slsl_vv_comp(v1,v2);
6963 return slsl_vv_comp(v1,v2);
6971 return slsp_vv_comp(v1,v2);
6979 return slsp_vv_comp(v1,v2);
6987 return slsp_vv_comp(v1,v2);
6995 return slsp_vv_comp(v1,v2);
7003 return slsp_vv_comp(v1,v2);
7011 return slsp_vv_comp(v1,v2);
7019 return slsp_vv_comp(v1,v2);
7027 return spsl_vv_comp(v1,v2);
7035 return spsl_vv_comp(v1,v2);
7043 return spsl_vv_comp(v1,v2);
7051 return spsl_vv_comp(v1,v2);
7059 return spsl_vv_comp(v1,v2);
7067 return spsl_vv_comp(v1,v2);
7075 return spsl_vv_comp(v1,v2);
7083 return slf_vv_comp(v1,v2);
7091 return slf_vv_comp(v1,v2);
7099 return slf_vv_comp(v1,v2);
7107 return slf_vv_comp(v1,v2);
7115 return slf_vv_comp(v1,v2);
7123 return slf_vv_comp(v1,v2);
7131 return slf_vv_comp(v1,v2);
7139 return fsl_vv_comp(v1,v2);
7147 return fsl_vv_comp(v1,v2);
7155 return fsl_vv_comp(v1,v2);
7163 return fsl_vv_comp(v1,v2);
7171 return fsl_vv_comp(v1,v2);
7179 return fsl_vv_comp(v1,v2);
7187 return fsl_vv_comp(v1,v2);
7195 return slf_vv_comp(v1,v2);
7203 return slf_vv_comp(v1,v2);
7211 return slf_vv_comp(v1,v2);
7219 return slf_vv_comp(v1,v2);
7227 return slf_vv_comp(v1,v2);
7235 return slf_vv_comp(v1,v2);
7243 return slf_vv_comp(v1,v2);
7251 return fsl_vv_comp(v1,v2);
7259 return fsl_vv_comp(v1,v2);
7267 return fsl_vv_comp(v1,v2);
7275 return fsl_vv_comp(v1,v2);
7283 return fsl_vv_comp(v1,v2);
7291 return fsl_vv_comp(v1,v2);
7299 return fsl_vv_comp(v1,v2);
7307 return !slsl_vv_comp(v1,v2);
7315 return !slsl_vv_comp(v1,v2);
7323 return !slsl_vv_comp(v1,v2);
7331 return !slsl_vv_comp(v1,v2);
7339 return !slsl_vv_comp(v1,v2);
7347 return !slsl_vv_comp(v1,v2);
7355 return !slsl_vv_comp(v1,v2);
7363 return !slsp_vv_comp(v1,v2);
7371 return !slsp_vv_comp(v1,v2);
7379 return !slsp_vv_comp(v1,v2);
7387 return !slsp_vv_comp(v1,v2);
7395 return !slsp_vv_comp(v1,v2);
7403 return !slsp_vv_comp(v1,v2);
7411 return !slsp_vv_comp(v1,v2);
7419 return !spsl_vv_comp(v1,v2);
7427 return !spsl_vv_comp(v1,v2);
7435 return !spsl_vv_comp(v1,v2);
7443 return !spsl_vv_comp(v1,v2);
7451 return !spsl_vv_comp(v1,v2);
7459 return !spsl_vv_comp(v1,v2);
7467 return !spsl_vv_comp(v1,v2);
7475 return !slf_vv_comp(v1,v2);
7483 return !slf_vv_comp(v1,v2);
7491 return !slf_vv_comp(v1,v2);
7499 return !slf_vv_comp(v1,v2);
7507 return !slf_vv_comp(v1,v2);
7515 return !slf_vv_comp(v1,v2);
7523 return !slf_vv_comp(v1,v2);
7531 return !fsl_vv_comp(v1,v2);
7539 return !fsl_vv_comp(v1,v2);
7547 return !fsl_vv_comp(v1,v2);
7555 return !fsl_vv_comp(v1,v2);
7563 return !fsl_vv_comp(v1,v2);
7571 return !fsl_vv_comp(v1,v2);
7579 return !fsl_vv_comp(v1,v2);
7587 return !slf_vv_comp(v1,v2);
7595 return !slf_vv_comp(v1,v2);
7603 return !slf_vv_comp(v1,v2);
7611 return !slf_vv_comp(v1,v2);
7619 return !slf_vv_comp(v1,v2);
7627 return !slf_vv_comp(v1,v2);
7635 return !slf_vv_comp(v1,v2);
7643 return !fsl_vv_comp(v1,v2);
7651 return !fsl_vv_comp(v1,v2);
7659 return !fsl_vv_comp(v1,v2);
7667 return !fsl_vv_comp(v1,v2);
7675 return !fsl_vv_comp(v1,v2);
7683 return !fsl_vv_comp(v1,v2);
7691 return !fsl_vv_comp(v1,v2);
7699 return slsl_vv_less<scivector_slice,sivector_slice,cinterval>(v1,v2);
7707 return slsl_vv_less<scivector_slice,scivector_slice,cinterval>(v1,v2);
7715 return slsl_vv_less<srvector_slice,scivector_slice,cinterval>(v1,v2);
7723 return slsl_vv_less<scvector_slice,scivector_slice,cinterval>(v1,v2);
7731 return slsl_vv_less<sivector_slice,scivector_slice,cinterval>(v1,v2);
7739 return slsp_vv_less<scivector_slice,sivector,cinterval>(v1,v2);
7747 return slsp_vv_less<scivector_slice,scivector,cinterval>(v1,v2);
7755 return slsp_vv_less<srvector_slice,scivector,cinterval>(v1,v2);
7763 return slsp_vv_less<scvector_slice,scivector,cinterval>(v1,v2);
7771 return slsp_vv_less<sivector_slice,scivector,cinterval>(v1,v2);
7779 return spsl_vv_less<scivector,sivector_slice,cinterval>(v1,v2);
7787 return spsl_vv_less<scivector,scivector_slice,cinterval>(v1,v2);
7795 return spsl_vv_less<srvector,scivector_slice,cinterval>(v1,v2);
7803 return spsl_vv_less<scvector,scivector_slice,cinterval>(v1,v2);
7811 return spsl_vv_less<sivector,scivector_slice,cinterval>(v1,v2);
7819 return slf_vv_less<scivector_slice,ivector,cinterval>(v1,v2);
7827 return slf_vv_less<scivector_slice,civector,cinterval>(v1,v2);
7835 return slf_vv_less<srvector_slice,civector,cinterval>(v1,v2);
7843 return slf_vv_less<sivector_slice,civector,cinterval>(v1,v2);
7851 return slf_vv_less<scvector_slice,civector,cinterval>(v1,v2);
7859 return fsl_vv_less<civector,sivector_slice,cinterval>(v1,v2);
7867 return fsl_vv_less<civector,scivector_slice,cinterval>(v1,v2);
7875 return fsl_vv_less<rvector,scivector_slice,cinterval>(v1,v2);
7883 return fsl_vv_less<cvector,scivector_slice,cinterval>(v1,v2);
7891 return fsl_vv_less<ivector,scivector_slice,cinterval>(v1,v2);
7899 return slsl_vv_leq<scivector_slice,sivector_slice,cinterval>(v1,v2);
7907 return slsl_vv_leq<scivector_slice,scivector_slice,cinterval>(v1,v2);
7915 return slsl_vv_leq<srvector_slice,scivector_slice,cinterval>(v1,v2);
7923 return slsl_vv_leq<scvector_slice,scivector_slice,cinterval>(v1,v2);
7931 return slsl_vv_leq<sivector_slice,scivector_slice,cinterval>(v1,v2);
7939 return slsp_vv_leq<scivector_slice,sivector,cinterval>(v1,v2);
7947 return slsp_vv_leq<scivector_slice,scivector,cinterval>(v1,v2);
7955 return slsp_vv_leq<srvector_slice,scivector,cinterval>(v1,v2);
7963 return slsp_vv_leq<scvector_slice,scivector,cinterval>(v1,v2);
7971 return slsp_vv_leq<sivector_slice,scivector,cinterval>(v1,v2);
7979 return spsl_vv_leq<scivector,sivector_slice,cinterval>(v1,v2);
7987 return spsl_vv_leq<scivector,scivector_slice,cinterval>(v1,v2);
7995 return spsl_vv_leq<srvector,scivector_slice,cinterval>(v1,v2);
8003 return spsl_vv_leq<scvector,scivector_slice,cinterval>(v1,v2);
8011 return spsl_vv_leq<sivector,scivector_slice,cinterval>(v1,v2);
8019 return slf_vv_leq<scivector_slice,ivector,cinterval>(v1,v2);
8027 return slf_vv_leq<scivector_slice,civector,cinterval>(v1,v2);
8035 return slf_vv_leq<srvector_slice,civector,cinterval>(v1,v2);
8043 return slf_vv_leq<sivector_slice,civector,cinterval>(v1,v2);
8051 return slf_vv_leq<scvector_slice,civector,cinterval>(v1,v2);
8059 return fsl_vv_leq<civector,sivector_slice,cinterval>(v1,v2);
8067 return fsl_vv_leq<civector,scivector_slice,cinterval>(v1,v2);
8075 return fsl_vv_leq<rvector,scivector_slice,cinterval>(v1,v2);
8083 return fsl_vv_leq<cvector,scivector_slice,cinterval>(v1,v2);
8091 return fsl_vv_leq<ivector,scivector_slice,cinterval>(v1,v2);
8099 return slsl_vv_greater<scivector_slice,srvector_slice,cinterval>(v1,v2);
8107 return slsl_vv_greater<scivector_slice,scvector_slice,cinterval>(v1,v2);
8115 return slsl_vv_greater<scivector_slice,sivector_slice,cinterval>(v1,v2);
8123 return slsl_vv_greater<scivector_slice,scivector_slice,cinterval>(v1,v2);
8131 return slsl_vv_greater<sivector_slice,scivector_slice,cinterval>(v1,v2);
8139 return slsp_vv_greater<scivector_slice,srvector,cinterval>(v1,v2);
8147 return slsp_vv_greater<scivector_slice,scvector,cinterval>(v1,v2);
8155 return slsp_vv_greater<scivector_slice,sivector,cinterval>(v1,v2);
8163 return slsp_vv_greater<scivector_slice,scivector,cinterval>(v1,v2);
8171 return slsp_vv_greater<sivector_slice,scivector,cinterval>(v1,v2);
8179 return spsl_vv_greater<scivector,srvector_slice,cinterval>(v1,v2);
8187 return spsl_vv_greater<scivector,scvector_slice,cinterval>(v1,v2);
8195 return spsl_vv_greater<scivector,sivector_slice,cinterval>(v1,v2);
8203 return spsl_vv_greater<scivector,scivector_slice,cinterval>(v1,v2);
8211 return spsl_vv_greater<sivector,scivector_slice,cinterval>(v1,v2);
8219 return slf_vv_greater<scivector_slice,rvector,cinterval>(v1,v2);
8227 return slf_vv_greater<scivector_slice,cvector,cinterval>(v1,v2);
8235 return slf_vv_greater<scivector_slice,ivector,cinterval>(v1,v2);
8243 return slf_vv_greater<scivector_slice,civector,cinterval>(v1,v2);
8251 return slf_vv_greater<sivector_slice,civector,cinterval>(v1,v2);
8259 return fsl_vv_greater<civector,srvector_slice,cinterval>(v1,v2);
8267 return fsl_vv_greater<civector,scvector_slice,cinterval>(v1,v2);
8275 return fsl_vv_greater<civector,sivector_slice,cinterval>(v1,v2);
8283 return fsl_vv_greater<civector,scivector_slice,cinterval>(v1,v2);
8291 return fsl_vv_greater<ivector,scivector_slice,cinterval>(v1,v2);
8299 return slf_vv_greater<scivector_slice,rvector_slice,cinterval>(v1,v2);
8307 return slf_vv_greater<scivector_slice,ivector_slice,cinterval>(v1,v2);
8315 return slf_vv_greater<scivector_slice,cvector_slice,cinterval>(v1,v2);
8323 return slf_vv_greater<scivector_slice,civector_slice,cinterval>(v1,v2);
8331 return slf_vv_greater<sivector_slice,civector_slice,cinterval>(v1,v2);
8339 return fsl_vv_greater<civector_slice,srvector_slice,cinterval>(v1,v2);
8347 return fsl_vv_greater<civector_slice,scvector_slice,cinterval>(v1,v2);
8355 return fsl_vv_greater<civector_slice,sivector_slice,cinterval>(v1,v2);
8363 return fsl_vv_greater<civector_slice,scivector_slice,cinterval>(v1,v2);
8371 return fsl_vv_greater<ivector_slice,scivector_slice,cinterval>(v1,v2);
8379 return slsl_vv_geq<scivector_slice,srvector_slice,cinterval>(v1,v2);
8387 return slsl_vv_geq<scivector_slice,scvector_slice,cinterval>(v1,v2);
8395 return slsl_vv_geq<scivector_slice,sivector_slice,cinterval>(v1,v2);
8403 return slsl_vv_geq<scivector_slice,scivector_slice,cinterval>(v1,v2);
8411 return slsl_vv_geq<sivector_slice,scivector_slice,cinterval>(v1,v2);
8419 return slsp_vv_geq<scivector_slice,srvector,cinterval>(v1,v2);
8427 return slsp_vv_geq<scivector_slice,scvector,cinterval>(v1,v2);
8435 return slsp_vv_geq<scivector_slice,sivector,cinterval>(v1,v2);
8443 return slsp_vv_geq<scivector_slice,scivector,cinterval>(v1,v2);
8451 return slsp_vv_geq<sivector_slice,scivector,cinterval>(v1,v2);
8459 return spsl_vv_geq<scivector,srvector_slice,cinterval>(v1,v2);
8467 return spsl_vv_geq<scivector,scvector_slice,cinterval>(v1,v2);
8475 return spsl_vv_geq<scivector,sivector_slice,cinterval>(v1,v2);
8483 return spsl_vv_geq<scivector,scivector_slice,cinterval>(v1,v2);
8491 return spsl_vv_geq<sivector,scivector_slice,cinterval>(v1,v2);
8499 return slf_vv_geq<scivector_slice,rvector,cinterval>(v1,v2);
8507 return slf_vv_geq<scivector_slice,cvector,cinterval>(v1,v2);
8515 return slf_vv_geq<scivector_slice,ivector,cinterval>(v1,v2);
8523 return slf_vv_geq<scivector_slice,civector,cinterval>(v1,v2);
8531 return slf_vv_geq<sivector_slice,civector,cinterval>(v1,v2);
8539 return fsl_vv_geq<civector,srvector_slice,cinterval>(v1,v2);
8547 return fsl_vv_geq<civector,scvector_slice,cinterval>(v1,v2);
8555 return fsl_vv_geq<civector,sivector_slice,cinterval>(v1,v2);
8563 return fsl_vv_geq<civector,scivector_slice,cinterval>(v1,v2);
8571 return fsl_vv_geq<ivector,scivector_slice,cinterval>(v1,v2);
8579 return slf_vv_geq<scivector_slice,rvector_slice,cinterval>(v1,v2);
8587 return slf_vv_geq<scivector_slice,ivector_slice,cinterval>(v1,v2);
8595 return slf_vv_geq<scivector_slice,cvector_slice,cinterval>(v1,v2);
8603 return slf_vv_geq<scivector_slice,civector_slice,cinterval>(v1,v2);
8611 return slf_vv_geq<sivector_slice,civector_slice,cinterval>(v1,v2);
8619 return fsl_vv_geq<civector_slice,srvector_slice,cinterval>(v1,v2);
8627 return fsl_vv_geq<civector_slice,scvector_slice,cinterval>(v1,v2);
8635 return fsl_vv_geq<civector_slice,sivector_slice,cinterval>(v1,v2);
8643 return fsl_vv_geq<civector_slice,scivector_slice,cinterval>(v1,v2);
8651 return fsl_vv_geq<ivector_slice,scivector_slice,cinterval>(v1,v2);
8661 return sl_v_output<scivector_slice,cinterval>(os,v);
8671 return sl_v_input<scivector_slice,cinterval>(is,v);
8679 slf_vv_accu<cidotprecision,scivector_slice,rvector,sparse_cidot>(dot,v1,v2);
8687 slf_vv_accu<cidotprecision,scivector_slice,cvector,sparse_cidot>(dot,v1,v2);
8695 slf_vv_accu<cidotprecision,scivector_slice,ivector,sparse_cidot>(dot,v1,v2);
8703 slf_vv_accu<cidotprecision,scivector_slice,civector,sparse_cidot>(dot,v1,v2);
8711 slf_vv_accu<cidotprecision,srvector_slice,civector,sparse_cidot>(dot,v1,v2);
8719 slf_vv_accu<cidotprecision,sivector_slice,civector,sparse_cidot>(dot,v1,v2);
8727 slf_vv_accu<cidotprecision,scvector_slice,civector,sparse_cidot>(dot,v1,v2);
8735 slf_vv_accu<cidotprecision,scvector_slice,ivector,sparse_cidot>(dot,v1,v2);
8743 slf_vv_accu<cidotprecision,sivector_slice,cvector,sparse_cidot>(dot,v1,v2);
8751 fsl_vv_accu<cidotprecision,civector,srvector_slice,sparse_cidot>(dot,v1,v2);
8759 fsl_vv_accu<cidotprecision,civector,scvector_slice,sparse_cidot>(dot,v1,v2);
8767 fsl_vv_accu<cidotprecision,civector,sivector_slice,sparse_cidot>(dot,v1,v2);
8775 fsl_vv_accu<cidotprecision,civector,scivector_slice,sparse_cidot>(dot,v1,v2);
8783 fsl_vv_accu<cidotprecision,rvector,scivector_slice,sparse_cidot>(dot,v1,v2);
8791 fsl_vv_accu<cidotprecision,cvector,scivector_slice,sparse_cidot>(dot,v1,v2);
8799 fsl_vv_accu<cidotprecision,ivector,scivector_slice,sparse_cidot>(dot,v1,v2);
8807 fsl_vv_accu<cidotprecision,cvector,sivector_slice,sparse_cidot>(dot,v1,v2);
8815 fsl_vv_accu<cidotprecision,ivector,scvector_slice,sparse_cidot>(dot,v1,v2);
8823 slf_vv_accu<cidotprecision,scivector_slice,rvector_slice,sparse_cidot>(dot,v1,v2);
8831 slf_vv_accu<cidotprecision,scivector_slice,ivector_slice,sparse_cidot>(dot,v1,v2);
8839 slf_vv_accu<cidotprecision,scivector_slice,cvector_slice,sparse_cidot>(dot,v1,v2);
8847 slf_vv_accu<cidotprecision,scivector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8855 slf_vv_accu<cidotprecision,srvector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8863 slf_vv_accu<cidotprecision,scvector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8871 slf_vv_accu<cidotprecision,sivector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8879 slf_vv_accu<cidotprecision,scvector_slice,ivector_slice,sparse_cidot>(dot,v1,v2);
8887 slf_vv_accu<cidotprecision,sivector_slice,cvector_slice,sparse_cidot>(dot,v1,v2);
8895 fsl_vv_accu<cidotprecision,civector_slice,srvector_slice,sparse_cidot>(dot,v1,v2);
8903 fsl_vv_accu<cidotprecision,civector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
8911 fsl_vv_accu<cidotprecision,civector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
8919 fsl_vv_accu<cidotprecision,civector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8927 fsl_vv_accu<cidotprecision,rvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8935 fsl_vv_accu<cidotprecision,ivector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8943 fsl_vv_accu<cidotprecision,cvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8951 fsl_vv_accu<cidotprecision,cvector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
8959 fsl_vv_accu<cidotprecision,ivector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
8967 spsl_vv_accu<cidotprecision,scivector,srvector_slice,sparse_cidot>(dot,v1,v2);
8975 spsl_vv_accu<cidotprecision,scivector,scvector_slice,sparse_cidot>(dot,v1,v2);
8983 spsl_vv_accu<cidotprecision,scivector,sivector_slice,sparse_cidot>(dot,v1,v2);
8991 spsl_vv_accu<cidotprecision,scivector,scivector_slice,sparse_cidot>(dot,v1,v2);
8999 spsl_vv_accu<cidotprecision,srvector,scivector_slice,sparse_cidot>(dot,v1,v2);
9007 spsl_vv_accu<cidotprecision,scvector,scivector_slice,sparse_cidot>(dot,v1,v2);
9015 spsl_vv_accu<cidotprecision,sivector,scivector_slice,sparse_cidot>(dot,v1,v2);
9023 spsl_vv_accu<cidotprecision,scvector,sivector_slice,sparse_cidot>(dot,v1,v2);
9031 spsl_vv_accu<cidotprecision,sivector,scvector_slice,sparse_cidot>(dot,v1,v2);
9039 slsp_vv_accu<cidotprecision,scivector_slice,srvector,sparse_cidot>(dot,v1,v2);
9047 slsp_vv_accu<cidotprecision,scivector_slice,scvector,sparse_cidot>(dot,v1,v2);
9055 slsp_vv_accu<cidotprecision,scivector_slice,sivector,sparse_cidot>(dot,v1,v2);
9063 slsp_vv_accu<cidotprecision,scivector_slice,scivector,sparse_cidot>(dot,v1,v2);
9071 slsp_vv_accu<cidotprecision,srvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9079 slsp_vv_accu<cidotprecision,sivector_slice,scivector,sparse_cidot>(dot,v1,v2);
9087 slsp_vv_accu<cidotprecision,scvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9095 slsp_vv_accu<cidotprecision,scvector_slice,sivector,sparse_cidot>(dot,v1,v2);
9103 slsp_vv_accu<cidotprecision,sivector_slice,scvector,sparse_cidot>(dot,v1,v2);
9111 slsl_vv_accu<cidotprecision,scivector_slice,srvector_slice,sparse_cidot>(dot,v1,v2);
9119 slsl_vv_accu<cidotprecision,scivector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
9127 slsl_vv_accu<cidotprecision,scivector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
9135 slsl_vv_accu<cidotprecision,scivector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9143 slsl_vv_accu<cidotprecision,srvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9151 slsl_vv_accu<cidotprecision,scvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9159 slsl_vv_accu<cidotprecision,sivector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9167 slsl_vv_accu<cidotprecision,sivector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
9175 slsl_vv_accu<cidotprecision,scvector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
9183 spf_vv_accu<cidotprecision,scivector,cvector,sparse_cidot>(dot,v1,v2);
9191 spf_vv_accu<cidotprecision,scivector,rvector,sparse_cidot>(dot,v1,v2);
9199 spf_vv_accu<cidotprecision,scivector,ivector,sparse_cidot>(dot,v1,v2);
9207 spf_vv_accu<cidotprecision,scivector,civector,sparse_cidot>(dot,v1,v2);
9215 spf_vv_accu<cidotprecision,scvector,civector,sparse_cidot>(dot,v1,v2);
9223 spf_vv_accu<cidotprecision,srvector,civector,sparse_cidot>(dot,v1,v2);
9231 spf_vv_accu<cidotprecision,sivector,civector,sparse_cidot>(dot,v1,v2);
9239 spf_vv_accu<cidotprecision,scvector,ivector,sparse_cidot>(dot,v1,v2);
9247 spf_vv_accu<cidotprecision,sivector,cvector,sparse_cidot>(dot,v1,v2);
9255 fsp_vv_accu<cidotprecision,rvector,scivector,sparse_cidot>(dot,v1,v2);
9263 fsp_vv_accu<cidotprecision,cvector,scivector,sparse_cidot>(dot,v1,v2);
9271 fsp_vv_accu<cidotprecision,ivector,scivector,sparse_cidot>(dot,v1,v2);
9279 fsp_vv_accu<cidotprecision,civector,scivector,sparse_cidot>(dot,v1,v2);
9287 fsp_vv_accu<cidotprecision,civector,srvector,sparse_cidot>(dot,v1,v2);
9295 fsp_vv_accu<cidotprecision,civector,scvector,sparse_cidot>(dot,v1,v2);
9303 fsp_vv_accu<cidotprecision,civector,sivector,sparse_cidot>(dot,v1,v2);
9311 fsp_vv_accu<cidotprecision,ivector,scvector,sparse_cidot>(dot,v1,v2);
9319 fsp_vv_accu<cidotprecision,cvector,sivector,sparse_cidot>(dot,v1,v2);
9327 spf_vv_accu<cidotprecision,scivector,cvector_slice,sparse_cidot>(dot,v1,v2);
9335 spf_vv_accu<cidotprecision,scivector,rvector_slice,sparse_cidot>(dot,v1,v2);
9343 spf_vv_accu<cidotprecision,scivector,ivector_slice,sparse_cidot>(dot,v1,v2);
9351 spf_vv_accu<cidotprecision,scivector,civector_slice,sparse_cidot>(dot,v1,v2);
9359 spf_vv_accu<cidotprecision,scvector,civector_slice,sparse_cidot>(dot,v1,v2);
9367 spf_vv_accu<cidotprecision,srvector,civector_slice,sparse_cidot>(dot,v1,v2);
9375 spf_vv_accu<cidotprecision,sivector,civector_slice,sparse_cidot>(dot,v1,v2);
9383 spf_vv_accu<cidotprecision,scvector,ivector_slice,sparse_cidot>(dot,v1,v2);
9391 spf_vv_accu<cidotprecision,sivector,cvector_slice,sparse_cidot>(dot,v1,v2);
9399 fsp_vv_accu<cidotprecision,rvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9407 fsp_vv_accu<cidotprecision,cvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9415 fsp_vv_accu<cidotprecision,ivector_slice,scivector,sparse_cidot>(dot,v1,v2);
9423 fsp_vv_accu<cidotprecision,civector_slice,scivector,sparse_cidot>(dot,v1,v2);
9431 fsp_vv_accu<cidotprecision,civector_slice,srvector,sparse_cidot>(dot,v1,v2);
9439 fsp_vv_accu<cidotprecision,civector_slice,scvector,sparse_cidot>(dot,v1,v2);
9447 fsp_vv_accu<cidotprecision,civector_slice,sivector,sparse_cidot>(dot,v1,v2);
9455 fsp_vv_accu<cidotprecision,ivector_slice,scvector,sparse_cidot>(dot,v1,v2);
9463 fsp_vv_accu<cidotprecision,cvector_slice,sivector,sparse_cidot>(dot,v1,v2);
9471 spsp_vv_accu<cidotprecision,scivector,srvector,sparse_cidot>(dot,v1,v2);
9479 spsp_vv_accu<cidotprecision,scivector,scvector,sparse_cidot>(dot,v1,v2);
9487 spsp_vv_accu<cidotprecision,scivector,sivector,sparse_cidot>(dot,v1,v2);
9495 spsp_vv_accu<cidotprecision,scivector,scivector,sparse_cidot>(dot,v1,v2);
9503 spsp_vv_accu<cidotprecision,srvector,scivector,sparse_cidot>(dot,v1,v2);
9511 spsp_vv_accu<cidotprecision,scvector,scivector,sparse_cidot>(dot,v1,v2);
9519 spsp_vv_accu<cidotprecision,sivector,scivector,sparse_cidot>(dot,v1,v2);
9527 spsp_vv_accu<cidotprecision,scvector,sivector,sparse_cidot>(dot,v1,v2);
9535 spsp_vv_accu<cidotprecision,sivector,scvector,sparse_cidot>(dot,v1,v2);
9540 #include "sparsevector.inl" scivector & operator=(const rvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used...
scivector_slice & operator-=(const scivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector_slice & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator|=(const ivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator|=(const civector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const civector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
scivector_slice & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector & operator=(const srvector &v)
Assign a sparse real vector to a sparse complex interval vector.
scivector & operator|=(const civector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
friend sivector abs(const scivector &)
Computes the component-wise absolute values as the interval hull of for a vector v...
scivector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
civector_slice & operator-=(const civector &rv)
Implementation of subtraction and allocation operation.
scivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
scivector(const civector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Helper class for slices of sparse vectors.
scivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
scivector_slice & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
scivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector & operator=(const cinterval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
scivector(const srvector &v)
Creates a sparse complex interval vector out of a sparse real vector.
scivector & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
friend scvector Sup(const scivector &)
Returns the supremum of the complex interval vector as a new sparse point vector. ...
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
scivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector & operator=(const cvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used...
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
scivector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector & operator=(const scvector &v)
Assign a sparse complex vector to a sparse complex interval vector.
Represents a row or column vector of a sparse matrix.
scivector & operator|=(const scivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector & operator/=(const complex &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector...
scivector_slice & operator-=(const scvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector & operator=(const civector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used...
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
scivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
scivector_slice & operator|=(const scvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
The namespace cxsc, providing all functionality of the class library C-XSC.
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)...
friend int Lb(const scivector &)
Returns the lower index bound of the vector v.
scivector_slice & operator+=(const scivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
scivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
scivector()
Default constructor, creates an empty vector of size 0.
The Scalar Type interval.
scivector_slice & operator|=(const scivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
std::vector< cinterval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
A sparse interval vector.
civector_slice & operator+=(const civector &rv)
Implementation of addition and allocation operation.
scivector & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
friend int VecLen(const scivector &)
Returns the length of the vector (the dimension)
scivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator=(const ivector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used...
scivector & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator=(const interval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
friend void SetUb(scivector &, const int)
Sets the upper index bound of the vector v to i.
scivector(const int s)
Constructor for creating an empty vector of size s.
scivector & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector(const sivector &v)
Creates a sparse complex interval vector out of a sparse interval vector.
scivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector & operator=(const ivector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used...
scivector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector_slice & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
scivector(const scvector &v)
Creates a sparse complex interval vector out of a sparse complex vector.
scivector & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator|=(const scvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
A sparse complex interval vector.
scivector & operator/=(const interval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
The Data Type ivector_slice.
scivector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector_slice & operator=(const scivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
The Data Type cidotprecision.
scivector & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
The Data Type rvector_slice.
scivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector & operator=(const civector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used...
scivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
scivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector_slice & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector & operator|=(const civector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator+=(const sivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const scivector &v)
Overwrite the vector slice with the elements of v.
scivector & operator=(const sivector &v)
Assign a sparse interval vector to a sparse complex interval vector.
scivector & operator &=(const ivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector...
scivector & operator|=(const srvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator|=(const scvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
friend scivector conj(const scivector &)
Returns the complex conjugate of v.
scivector(const cvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
scivector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used...
scivector_slice & operator*=(const cinterval &s)
Operator for multiplication with a complex interval, result is assigned to the vector slice...
scivector_slice & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
friend scvector diam(const scivector &)
Computes the diameter of v.
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
scivector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
The Scalar Type cinterval.
scivector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector...
scivector_slice & operator|=(const cvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
void Resize(cimatrix &A)
Resizes the matrix.
scivector_slice & operator=(const civector &v)
Overwrite the vector slice with the elements of v.
scivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Helper class for slices of sparse vectors.
scivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector_slice & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Represents a row or column vector of a sparse matrix.
The Data Type civector_slice.
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector...
scivector_slice & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector_slice & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice...
scivector_slice & operator/=(const interval &s)
Operator for division of each element of the vector slice with an interval, result is assigned to the...
scivector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
scivector & operator|=(const cvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator/=(const real &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
scivector(const int n, const int nnz, const int *index, const cinterval *values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
scivector_slice & operator=(const cinterval &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector & operator/=(const cinterval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
scivector & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
scivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
friend srvector SupRe(const scivector &)
Returns the supremum of the real part of the complex interval vector as a new sparse point vector...
scivector_slice & operator|=(const civector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector...
civector_slice & operator&=(const civector &rv)
Allocates the intersection of the arguments to the first argument.
friend srvector SupIm(const scivector &)
Returns the supremum of the imaginary part of the complex interval vector as a new sparse point vecto...
scivector & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
friend int Ub(const scivector &)
Returns the upper index bound of the vector v.
friend sivector Re(const scivector &)
Returns the real part of the vector v.
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector...
scivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
Helper class for slices of sparse vectors.
civector()
Constructor of class civector.
scivector & operator=(const cvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used...
Represents a row or column vector of a sparse matrix.
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice...
scivector_slice & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
scivector_slice & operator|=(const srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
Helper class for slices of sparse vectors.
scivector & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
const std::vector< cinterval > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
scivector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector_slice & operator/=(const cinterval &s)
Operator for division of each element of the vector slice with a complex interval, result is assigned to the vector slice.
scivector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Represents a row or column vector of a sparse matrix.
scivector & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector.
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
friend srvector InfRe(const scivector &)
Returns the infimum of the real part of the complex interval vector as a new sparse point vector...
scivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
scivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector...
The Data Type cvector_slice.
scivector_slice & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
civector & operator=(const civector &rv)
Implementation of standard assigning operator.
scivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
friend srvector InfIm(const scivector &)
Returns the infimum of the imaginary part of the complex interval vector as a new sparse point vector...
scivector & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector_slice & operator|=(const scivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
friend void SetLb(scivector &, const int)
Sets the lower index bound of the vector v to i.
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
scivector_slice & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
civector_slice & operator|=(const civector &rv)
Allocates the convex hull of the arguments to the first argument.
scivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector.
scivector_slice & operator|=(const rvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
void dropzeros()
Erases explicitly stored zeros from the data structure.
scivector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice...
scivector(const int n, const int nnz, const intvector &index, const civector &values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
scivector & operator*=(const cinterval &s)
Operator for multiplication with an interval, result is assigned to the vector.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
scivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
scivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector_slice & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice...
scivector_slice & operator/=(const complex &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...