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>
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++) {
122 p.push_back(index[i+
Lb(index)]);
131 for(
int i=0 ; i<nnz ; i++) {
133 p.push_back(index[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);
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);
366 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC(
"scivector::operator[](const int)"));
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);
2572inline civector& civector::operator+=(
const srvector& v2) {
2573 return fsp_vv_addassign(*
this,v2);
2576inline civector& civector::operator+=(
const scvector& v2) {
2577 return fsp_vv_addassign(*
this,v2);
2580inline civector& civector::operator+=(
const sivector& v2) {
2581 return fsp_vv_addassign(*
this,v2);
2584inline civector& civector::operator+=(
const scivector& 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);
2604inline civector& civector::operator-=(
const srvector& v2) {
2605 return fsp_vv_subassign(*
this,v2);
2608inline civector& civector::operator-=(
const scvector& v2) {
2609 return fsp_vv_subassign(*
this,v2);
2612inline civector& civector::operator-=(
const sivector& v2) {
2613 return fsp_vv_subassign(*
this,v2);
2616inline civector& civector::operator-=(
const scivector& 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);
2636inline civector& civector::operator|=(
const srvector& v2) {
2637 return fsp_vv_hullassign(*
this,v2);
2640inline civector& civector::operator|=(
const scvector& v2) {
2641 return fsp_vv_hullassign(*
this,v2);
2644inline civector& civector::operator|=(
const sivector& v2) {
2645 return fsp_vv_hullassign(*
this,v2);
2648inline civector& civector::operator|=(
const scivector& 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);
2668inline civector& civector::operator&=(
const sivector& v2) {
2669 return fsp_vv_intersectassign(*
this,v2);
2672inline civector& civector::operator&=(
const scivector& 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);
4042inline std::ostream& operator<<(std::ostream& os,
const scivector& v) {
4043 return sp_v_output<scivector,cinterval>(os,v);
4052inline 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);
6742inline civector& civector::operator+=(
const srvector_slice& v2) {
6743 return fsl_vv_addassign(*
this,v2);
6746inline civector& civector::operator+=(
const scvector_slice& v2) {
6747 return fsl_vv_addassign(*
this,v2);
6750inline civector& civector::operator+=(
const sivector_slice& v2) {
6751 return fsl_vv_addassign(*
this,v2);
6754inline civector& civector::operator+=(
const scivector_slice& 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);
6794inline civector& civector::operator-=(
const scvector_slice& v2) {
6795 return fsl_vv_subassign(*
this,v2);
6798inline civector& civector::operator-=(
const sivector_slice& v2) {
6799 return fsl_vv_subassign(*
this,v2);
6802inline civector& civector::operator-=(
const scivector_slice& 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);
6842inline civector& civector::operator|=(
const scvector_slice& v2) {
6843 return fsl_vv_hullassign(*
this,v2);
6846inline civector& civector::operator|=(
const sivector_slice& v2) {
6847 return fsl_vv_hullassign(*
this,v2);
6850inline civector& civector::operator|=(
const scivector_slice& 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);
6890inline civector& civector::operator&=(
const scivector_slice& 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"
The Data Type cidotprecision.
The Scalar Type cinterval.
The Data Type civector_slice.
civector_slice & operator|=(const civector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
civector_slice & operator&=(const civector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
civector_slice & operator+=(const civector &rv) noexcept
Implementation of addition and allocation operation.
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
civector_slice & operator-=(const civector &rv) noexcept
Implementation of subtraction and allocation operation.
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
civector() noexcept
Constructor of class civector.
The Data Type cvector_slice.
The Scalar Type interval.
The Data Type ivector_slice.
The Data Type rvector_slice.
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
friend sivector abs(const scivector_slice &)
Computes the component-wise absolute values as the interval hull of for a vector v.
scivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
friend srvector SupIm(const scivector_slice &)
Returns the imaginary part of the supremum of the vector slice v.
friend int Lb(const scivector_slice &)
Returns the lower index bound of the vector slice v.
scivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
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 ivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator&=(const scivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
friend scvector Sup(const scivector_slice &)
Returns the supremum of the vector slice v.
scivector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const scivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
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 ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend int VecLen(const scivector_slice &)
Returns the length of the vector slice.
scivector_slice & operator=(const scivector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
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_slice &v)
Overwrite the vector slice with the elements of v.
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_slice &v)
Operator for element-wise intersection 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.
scivector_slice & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to 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_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 real &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
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 srvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction 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 civector_slice &v)
Operator for element-wise convex hull 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 srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
friend scvector diam(const scivector_slice &)
Computes the diameter of v.
scivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
friend scvector Inf(const scivector_slice &)
Returns the infimum vector slice v.
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)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
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 ivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const scvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator&=(const sivector &v)
Operator for element-wise intersection with a vector, result is assigned to 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_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator*=(const cinterval &s)
Operator for multiplication with a complex interval, result is assigned to the vector slice.
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
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 rvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const cinterval &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
friend srvector SupRe(const scivector_slice &)
Returns the real part of the supremum of the vector slice v.
scivector_slice & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to 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...
friend int Ub(const scivector_slice &)
Returns the upper index bound of the vector slice v.
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 ivector &v)
Operator for element-wise addition with a vector, 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_slice & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
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 scivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
friend sivector Re(const scivector_slice &)
Returns the real part of v.
scivector_slice & operator=(const scivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator+=(const srvector &v)
Operator for element-wise addition 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 cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const cvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
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 sivector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const civector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator&=(const civector_slice &v)
Operator for element-wise intersection 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...
friend scivector conj(const scivector_slice &)
Returns the conjugate complex 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 ivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator&=(const civector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const scivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator/=(const cinterval &s)
Operator for division of each element of the vector slice with a complex interval,...
scivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction 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.
scivector_slice & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
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 civector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
friend srvector InfRe(const scivector_slice &)
Returns the real part of the infimum of the vector slice v.
scivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
friend scvector mid(const scivector_slice &)
Computes the midpoint vector of v.
friend sivector Im(const scivector_slice &)
Returns the imaginary part 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...
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
scivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend srvector InfIm(const scivector_slice &)
Returns the imaginary part of the infimum of the vector slice v.
scivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
A sparse complex interval vector.
scivector & operator|=(const srvector &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(const int s)
Constructor for creating an empty vector of size s.
scivector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
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 & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator|=(const cvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
scivector(const srvector &v)
Creates a sparse complex interval vector out of a sparse real vector.
scivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const scvector &v)
Assign a sparse complex vector to a sparse complex interval vector.
scivector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
scivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator=(const civector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
std::vector< cinterval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
scivector()
Default constructor, creates an empty vector of size 0
friend void SetLb(scivector &, const int)
Sets the lower index bound of the vector v to i.
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 real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
scivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
scivector & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector.
scivector(const scvector &v)
Creates a sparse complex interval vector out of a sparse complex vector.
scivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
friend int Lb(const scivector &)
Returns the lower index bound of the vector v.
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
friend scvector diam(const scivector &)
Computes the diameter of v.
scivector & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
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 cinterval &s)
Operator for multiplication with an interval, 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 civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const sivector &v)
Assign a sparse interval vector to a sparse complex interval vector.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
scivector & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with another 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!)
scivector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
scivector & operator|=(const scivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
friend int Ub(const scivector &)
Returns the upper index bound of the vector v.
scivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
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 srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator&=(const civector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
scivector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator|=(const civector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator-=(const civector_slice &v)
Operator for element-wise subtraction 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 & operator-=(const civector &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.
friend srvector SupRe(const scivector &)
Returns the supremum of the real part of the complex interval vector as a new sparse point 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 srvector &v)
Assign a sparse real vector to a sparse complex interval 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 interval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
scivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
scivector & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
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 ivector &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 rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
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.
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 sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
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 & operator-=(const cvector_slice &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 & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const cinterval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
scivector & operator&=(const ivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
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(const civector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
scivector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
scivector & operator&=(const civector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
friend sivector Re(const scivector &)
Returns the real part of the vector v.
friend scivector conj(const scivector &)
Returns the complex conjugate of v.
scivector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
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 cvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
scivector & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
friend void SetUb(scivector &, const int)
Sets the upper index bound of the vector v to i.
void dropzeros()
Erases explicitly stored zeros from the data structure.
scivector & operator&=(const ivector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
scivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector
scivector & operator=(const cvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
scivector & operator&=(const sivector &v)
Operator for element-wise intersection 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.
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 real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
scivector & operator|=(const civector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator&=(const scivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
A sparse interval vector.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
The namespace cxsc, providing all functionality of the class library C-XSC.
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.