C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
scivector.hpp
1/*
2** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3**
4** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5** Universitaet Karlsruhe, Germany
6** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7** Universitaet Wuppertal, Germany
8**
9** This library is free software; you can redistribute it and/or
10** modify it under the terms of the GNU Library General Public
11** License as published by the Free Software Foundation; either
12** version 2 of the License, or (at your option) any later version.
13**
14** This library is distributed in the hope that it will be useful,
15** but WITHOUT ANY WARRANTY; without even the implied warranty of
16** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17** Library General Public License for more details.
18**
19** You should have received a copy of the GNU Library General Public
20** License along with this library; if not, write to the Free
21** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22*/
23
24/* CVS $Id: scivector.hpp,v 1.15 2014/01/30 17:23:48 cxsc Exp $ */
25
26#ifndef _CXSC_SCIVECTOR_HPP_INCLUDED
27#define _CXSC_SCIVECTOR_HPP_INCLUDED
28
29#include <cinterval.hpp>
30#include <civector.hpp>
31#include <vector>
32#include <iostream>
33#include <srvector.hpp>
34#include <scvector.hpp>
35#include <sivector.hpp>
36#include <sparsecidot.hpp>
37#include <sparsevector.hpp>
38
39namespace cxsc {
40
41class srvector_slice;
42class srmatrix;
43class srmatrix_slice;
44class srmatrix_subv;
45class scvector_slice;
46class scmatrix;
47class scmatrix_slice;
48class scmatrix_subv;
49class sivector_slice;
50class simatrix;
51class simatrix_slice;
52class simatrix_subv;
53class scivector_slice;
54class scimatrix_slice;
55class scimatrix_subv;
56
58
62class scivector {
63 private:
64 std::vector<int> p;
65 std::vector<cinterval> x;
66 int lb;
67 int ub;
68 int n;
69
70 public:
72 scivector() : lb(0), ub(-1) , n(0) {
73 }
74
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));
79 }
80
82 scivector(const int s, const int b) : lb(1), ub(s), n(s) {
83 p.reserve(b);
84 x.reserve(b);
85 }
86
88 scivector(const civector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
89 for(int i=lb ; i<=ub ; i++) {
90 if(v[i] != 0.0) {
91 p.push_back(i-lb);
92 x.push_back(v[i]);
93 }
94 }
95 }
96
98 scivector(const cvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
99 for(int i=lb ; i<=ub ; i++) {
100 if(v[i] != 0.0) {
101 p.push_back(i-lb);
102 x.push_back(cinterval(v[i]));
103 }
104 }
105 }
106
108 scivector(const rvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
109 for(int i=lb ; i<=ub ; i++) {
110 if(v[i] != 0.0) {
111 p.push_back(i-lb);
112 x.push_back(cinterval(v[i]));
113 }
114 }
115 }
116
118 scivector(const int n, const int nnz, const intvector& index, const civector& values) : lb(1), ub(n) {
119 this->n = n;
120 for(int i=0 ; i<nnz ; i++) {
121 if(values[i+Lb(values)] != 0.0) {
122 p.push_back(index[i+Lb(index)]);
123 x.push_back(values[i+Lb(values)]);
124 }
125 }
126 }
127
129 scivector(const int n, const int nnz, const int* index, const cinterval* values) : lb(1), ub(n) {
130 this->n = n;
131 for(int i=0 ; i<nnz ; i++) {
132 if(values[i] != 0.0) {
133 p.push_back(index[i]);
134 x.push_back(values[i]);
135 }
136 }
137 }
138
140 scivector(const srvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
141 x.reserve(v.get_nnz());
142 for(int i=0 ; i<v.get_nnz() ; i++)
143 x.push_back(cinterval(v.x[i]));
144 }
145
147 scivector(const scvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
148 x.reserve(v.get_nnz());
149 for(int i=0 ; i<v.get_nnz() ; i++)
150 x.push_back(cinterval(v.x[i]));
151 }
152
154 scivector(const sivector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
155 x.reserve(v.get_nnz());
156 for(int i=0 ; i<v.get_nnz() ; i++)
157 x.push_back(cinterval(v.x[i]));
158 }
159
169 scivector(const srmatrix_subv& A);
171 scivector(const scmatrix_subv& A);
173 scivector(const simatrix_subv& A);
175 scivector(const scimatrix_subv& A);
176
178
183 std::vector<int>& row_indices() {
184 return p;
185 }
186
188
192 std::vector<cinterval>& values() {
193 return x;
194 }
195
197
202 const std::vector<int>& row_indices() const {
203 return p;
204 }
205
207
211 const std::vector<cinterval>& values() const {
212 return x;
213 }
214
216 int get_nnz() const {
217 return x.size();
218 }
219
221 real density() const {
222 return (double)x.size()/n;
223 }
224
226 void dropzeros() {
227 for(int i=0 ; i<get_nnz() ; i++) {
228 if(x[i] == 0.0) {
229 x.erase(x.begin()+i);
230 p.erase(p.begin()+i);
231 }
232 }
233 }
234
237 n = v.n;
238 p = v.p;
239 x.clear();
240 x.reserve(v.get_nnz());
241 for(unsigned int i=0 ; i<v.x.size() ; i++)
242 x[i] = cinterval(v.x[i]);
243 return *this;
244 }
245
248 n = v.n;
249 p = v.p;
250 x.clear();
251 x.reserve(v.get_nnz());
252 for(unsigned int i=0 ; i<v.x.size() ; i++)
253 x[i] = cinterval(v.x[i]);
254 return *this;
255 }
256
259 n = v.n;
260 p = v.p;
261 x.clear();
262 x.reserve(v.get_nnz());
263 for(unsigned int i=0 ; i<v.x.size() ; i++)
264 x[i] = cinterval(v.x[i]);
265 return *this;
266 }
267
270 return sp_vs_assign<scivector,real,cinterval>(*this,v);
271 }
272
275 return sp_vs_assign<scivector,complex,cinterval>(*this,v);
276 }
277
280 return sp_vs_assign<scivector,interval,cinterval>(*this,v);
281 }
282
285 return sp_vs_assign<scivector,cinterval,cinterval>(*this,v);
286 }
287
290 return spf_vv_assign<scivector,rvector,cinterval>(*this,v);
291 }
292
295 return spf_vv_assign<scivector,cvector,cinterval>(*this,v);
296 }
297
300 return spf_vv_assign<scivector,ivector,cinterval>(*this,v);
301 }
302
305 return spf_vv_assign<scivector,civector,cinterval>(*this,v);
306 }
307
310 return spf_vv_assign<scivector,rvector_slice,cinterval>(*this,v);
311 }
312
315 return spf_vv_assign<scivector,cvector_slice,cinterval>(*this,v);
316 }
317
320 return spf_vv_assign<scivector,ivector_slice,cinterval>(*this,v);
321 }
322
325 return spf_vv_assign<scivector,civector_slice,cinterval>(*this,v);
326 }
327
336
338
342 cinterval& operator[](const int i) {
343#if(CXSC_INDEX_CHECK)
344 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector::operator[](const int)"));
345#endif
346 int k;
347
348 for(k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
349 if(p[k] == i-lb)
350 return x[k];
351 }
352
353 p.insert(p.begin() + k, i-lb);
354 x.insert(x.begin() + k, cinterval(0.0));
355
356 return x[k];
357 }
358
360
364 cinterval operator[](const int i) const {
365#if(CXSC_INDEX_CHECK)
366 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector::operator[](const int)"));
367#endif
368 return (*this)(i);
369 }
370
372
376 const cinterval operator()(const int i) const {
377#if(CXSC_INDEX_CHECK)
378 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector::operator()(const int)"));
379#endif
380 cinterval r(0.0);
381
382 for(int k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
383 if(p[k] == i-lb)
384 r = x[k];
385 }
386
387 return r;
388 }
389
391
395 scivector v(n,get_nnz());
396 intvector pinv = perminv(per);
397
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]));
401
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);
405 }
406
407 return v;
408 }
409
411
418 intvector p = permvec(P);
419 return (*this)(p);
420 }
421
423
425 scivector_slice operator()(const int, const int);
426
429 return sp_vs_multassign(*this,s);
430 }
431
434 return sp_vs_multassign(*this,s);
435 }
436
439 return sp_vs_multassign(*this,s);
440 }
441
444 return sp_vs_multassign(*this,s);
445 }
446
449 return sp_vs_divassign(*this,s);
450 }
451
454 return sp_vs_divassign(*this,s);
455 }
456
459 return sp_vs_divassign(*this,s);
460 }
461
464 return sp_vs_divassign(*this,s);
465 }
466
469 return spf_vv_addassign(*this,v);
470 }
471
474 return spf_vv_addassign(*this,v);
475 }
476
479 return spf_vv_addassign(*this,v);
480 }
481
484 return spf_vv_addassign(*this,v);
485 }
486
489 return spf_vv_addassign(*this,v);
490 }
491
494 return spf_vv_addassign(*this,v);
495 }
496
499 return spf_vv_addassign(*this,v);
500 }
501
504 return spf_vv_addassign(*this,v);
505 }
506
509 return spsp_vv_addassign(*this,v);
510 }
511
514 return spsp_vv_addassign(*this,v);
515 }
516
519 return spsp_vv_addassign(*this,v);
520 }
521
524 return spsp_vv_addassign(*this,v);
525 }
526
529 return spf_vv_subassign(*this,v);
530 }
531
534 return spf_vv_subassign(*this,v);
535 }
536
539 return spf_vv_subassign(*this,v);
540 }
541
544 return spf_vv_subassign(*this,v);
545 }
546
549 return spf_vv_subassign(*this,v);
550 }
551
554 return spf_vv_subassign(*this,v);
555 }
556
559 return spf_vv_subassign(*this,v);
560 }
561
564 return spf_vv_subassign(*this,v);
565 }
566
569 return spsp_vv_subassign(*this,v);
570 }
571
574 return spsp_vv_subassign(*this,v);
575 }
576
579 return spsp_vv_subassign(*this,v);
580 }
581
584 return spsp_vv_subassign(*this,v);
585 }
586
589 return spf_vv_hullassign(*this,v);
590 }
591
594 return spf_vv_hullassign(*this,v);
595 }
596
599 return spf_vv_hullassign(*this,v);
600 }
601
604 return spf_vv_hullassign(*this,v);
605 }
606
609 return spf_vv_hullassign(*this,v);
610 }
611
614 return spf_vv_hullassign(*this,v);
615 }
616
619 return spf_vv_hullassign(*this,v);
620 }
621
624 return spf_vv_hullassign(*this,v);
625 }
626
629 return spsp_vv_hullassign(*this,v);
630 }
631
634 return spsp_vv_hullassign(*this,v);
635 }
636
639 return spsp_vv_hullassign(*this,v);
640 }
641
644 return spsp_vv_hullassign(*this,v);
645 }
646
649 return spf_vv_intersectassign(*this,v);
650 }
651
654 return spf_vv_intersectassign(*this,v);
655 }
656
659 return spf_vv_intersectassign(*this,v);
660 }
661
664 return spf_vv_intersectassign(*this,v);
665 }
666
669 return spsp_vv_intersectassign(*this,v);
670 }
671
674 return spsp_vv_intersectassign(*this,v);
675 }
676
677
706
707 friend void SetLb(scivector&, const int);
708 friend void SetUb(scivector&, const int);
709 friend int Lb(const scivector&);
710 friend int Ub(const scivector&);
711 friend sivector Re(const scivector&);
712 friend sivector Im(const scivector&);
713 friend scvector Inf(const scivector&);
714 friend scvector Sup(const scivector&);
715 friend srvector InfRe(const scivector&);
716 friend srvector InfIm(const scivector&);
717 friend srvector SupRe(const scivector&);
718 friend srvector SupIm(const scivector&);
719 friend scivector conj(const scivector&);
720 friend scivector conj(const scivector_slice&);
721 friend sivector abs(const scivector&);
722 friend scvector mid(const scivector&);
723 friend scvector diam(const scivector&);
724 friend int VecLen(const scivector&);
725
726 friend class srvector_slice;
727 friend class scvector_slice;
728 friend class sivector_slice;
729 friend class scivector_slice;
730 friend class civector;
731 friend class civector_slice;
732
733#include "vector_friend_declarations.inl"
734};
735
736inline civector::civector(const srvector& v) {
737 l = v.lb;
738 u = v.ub;
739 size = v.n;
740 dat = new cinterval[v.n];
741 for(int i=0 ; i<v.n ; i++)
742 dat[i] = 0.0;
743 for(int i=0 ; i<v.get_nnz() ; i++)
744 dat[v.p[i]] = v.x[i];
745}
746
747inline civector::civector(const scvector& v) {
748 l = v.lb;
749 u = v.ub;
750 size = v.n;
751 dat = new cinterval[v.n];
752 for(int i=0 ; i<v.n ; i++)
753 dat[i] = 0.0;
754 for(int i=0 ; i<v.get_nnz() ; i++)
755 dat[v.p[i]] = v.x[i];
756}
757
758inline civector::civector(const sivector& v) {
759 l = v.lb;
760 u = v.ub;
761 size = v.n;
762 dat = new cinterval[v.n];
763 for(int i=0 ; i<v.n ; i++)
764 dat[i] = 0.0;
765 for(int i=0 ; i<v.get_nnz() ; i++)
766 dat[v.p[i]] = v.x[i];
767}
768
770 l = v.lb;
771 u = v.ub;
772 size = v.n;
773 dat = new cinterval[v.n];
774 for(int i=0 ; i<v.n ; i++)
775 dat[i] = 0.0;
776 for(int i=0 ; i<v.get_nnz() ; i++)
777 dat[v.p[i]] = v.x[i];
778}
779
781 return fsp_vv_assign<civector,scivector,cinterval>(*this,v);
782}
783
785 return fsl_vv_assign<civector,scivector_slice,cinterval>(*this,v);
786}
787
789 return fsp_vv_assign<civector,srvector,cinterval>(*this,v);
790}
791
793 return fsl_vv_assign<civector,srvector_slice,cinterval>(*this,v);
794}
795
797 return fsp_vv_assign<civector,scvector,cinterval>(*this,v);
798}
799
801 return fsl_vv_assign<civector,scvector_slice,cinterval>(*this,v);
802}
803
805 return fsp_vv_assign<civector,sivector,cinterval>(*this,v);
806}
807
809 return fsl_vv_assign<civector,sivector_slice,cinterval>(*this,v);
810}
811
812
814
817inline void SetLb(scivector& v, const int i) {
818 v.lb = i;
819 v.ub = v.lb + v.n - 1;
820}
821
823
826inline void SetUb(scivector& v, const int j) {
827 v.ub = j;
828 v.lb = v.ub - v.n + 1;
829}
830
832inline int Lb(const scivector& v) {
833 return v.lb;
834}
835
837inline int Ub(const scivector& v) {
838 return v.ub;
839}
840
842inline void Resize(scivector& v) {
843 sp_v_resize(v);
844}
845
847
850inline void Resize(scivector& v, const int n) {
851 sp_v_resize(v,n);
852}
853
855
859inline void Resize(scivector& v, const int l, const int u) {
860 sp_v_resize(v,l,u);
861}
862
864inline sivector abs(const scivector& v) {
865 sivector res(v.n, v.get_nnz());
866 res.lb = v.lb;
867 res.ub = v.ub;
868 res.p = v.p;
869 for(int i=0 ; i<v.get_nnz() ; i++)
870 res.x.push_back(abs(v.x[i]));
871 return res;
872}
873
875inline scivector conj(const scivector& v) {
876 scivector res(v.n, v.get_nnz());
877 res.lb = v.lb;
878 res.ub = v.ub;
879 res.p = v.p;
880 for(int i=0 ; i<v.get_nnz() ; i++)
881 res.x.push_back(conj(v.x[i]));
882 return res;
883}
884
886inline scvector mid(const scivector& v) {
887 scvector res(v.n, v.get_nnz());
888 res.lb = v.lb;
889 res.ub = v.ub;
890 res.p = v.p;
891 for(int i=0 ; i<v.get_nnz() ; i++)
892 res.x.push_back(mid(v.x[i]));
893 return res;
894}
895
897inline scvector diam(const scivector& v) {
898 scvector res(v.n, v.get_nnz());
899 res.lb = v.lb;
900 res.ub = v.ub;
901 res.p = v.p;
902 for(int i=0 ; i<v.get_nnz() ; i++)
903 res.x.push_back(diam(v.x[i]));
904 return res;
905}
906
908inline sivector Re(const scivector& v) {
909 sivector res(v.n, v.get_nnz());
910 res.lb = v.lb;
911 res.ub = v.ub;
912 res.p = v.p;
913 for(int i=0 ; i<v.get_nnz() ; i++)
914 res.x[i] = Re(v.x[i]);
915 return res;
916}
917
919inline sivector Im(const scivector& v) {
920 sivector res(v.n, v.get_nnz());
921 res.lb = v.lb;
922 res.ub = v.ub;
923 res.p = v.p;
924 for(int i=0 ; i<v.get_nnz() ; i++)
925 res.x[i] = Im(v.x[i]);
926 return res;
927}
928
930inline scvector Inf(const scivector& v) {
931 scvector res(v.n, v.get_nnz());
932 res.lb = v.lb;
933 res.ub = v.ub;
934 res.p = v.p;
935 for(int i=0 ; i<v.get_nnz() ; i++)
936 res.x[i] = Inf(v.x[i]);
937 return res;
938}
939
941inline scvector Sup(const scivector& v) {
942 scvector res(v.n, v.get_nnz());
943 res.lb = v.lb;
944 res.ub = v.ub;
945 res.p = v.p;
946 for(int i=0 ; i<v.get_nnz() ; i++)
947 res.x[i] = Sup(v.x[i]);
948 return res;
949}
950
952inline srvector InfRe(const scivector& v) {
953 srvector res(v.n, v.get_nnz());
954 res.lb = v.lb;
955 res.ub = v.ub;
956 res.p = v.p;
957 for(int i=0 ; i<v.get_nnz() ; i++)
958 res.x[i] = InfRe(v.x[i]);
959 return res;
960}
961
963inline srvector InfIm(const scivector& v) {
964 srvector res(v.n, v.get_nnz());
965 res.lb = v.lb;
966 res.ub = v.ub;
967 res.p = v.p;
968 for(int i=0 ; i<v.get_nnz() ; i++)
969 res.x[i] = InfIm(v.x[i]);
970 return res;
971}
972
974inline srvector SupRe(const scivector& v) {
975 srvector res(v.n, v.get_nnz());
976 res.lb = v.lb;
977 res.ub = v.ub;
978 res.p = v.p;
979 for(int i=0 ; i<v.get_nnz() ; i++)
980 res.x[i] = SupRe(v.x[i]);
981 return res;
982}
983
985inline srvector SupIm(const scivector& v) {
986 srvector res(v.n, v.get_nnz());
987 res.lb = v.lb;
988 res.ub = v.ub;
989 res.p = v.p;
990 for(int i=0 ; i<v.get_nnz() ; i++)
991 res.x[i] = SupIm(v.x[i]);
992 return res;
993}
994
996inline int VecLen(const scivector& v) {
997 return v.n;
998}
999
1001inline bool in (const scivector& v1, const scivector& v2) {
1002 for(int i=0 ; i<VecLen(v1) ; i++)
1003 if(!in(v1(i+Lb(v1)), v2(i+Lb(v2)))) return false;
1004 return true;
1005}
1006
1008inline scivector operator-(const scivector& v) {
1009 return sp_v_negative(v);
1010}
1011
1013
1019inline cinterval operator*(const scivector& v1, const cvector& v2) {
1020 return spf_vv_mult<scivector,cvector,cinterval,sparse_cidot>(v1,v2);
1021}
1022
1024
1030inline cinterval operator*(const scivector& v1, const rvector& v2) {
1031 return spf_vv_mult<scivector,rvector,cinterval,sparse_cidot>(v1,v2);
1032}
1033
1035
1041inline cinterval operator*(const scivector& v1, const ivector& v2) {
1042 return spf_vv_mult<scivector,ivector,cinterval,sparse_cidot>(v1,v2);
1043}
1044
1046
1052inline cinterval operator*(const scivector& v1, const civector& v2) {
1053 return spf_vv_mult<scivector,civector,cinterval,sparse_cidot>(v1,v2);
1054}
1055
1057
1063inline cinterval operator*(const scvector& v1, const civector& v2) {
1064 return spf_vv_mult<scvector,civector,cinterval,sparse_cidot>(v1,v2);
1065}
1066
1068
1074inline cinterval operator*(const srvector& v1, const civector& v2) {
1075 return spf_vv_mult<srvector,civector,cinterval,sparse_cidot>(v1,v2);
1076}
1077
1079
1085inline cinterval operator*(const sivector& v1, const civector& v2) {
1086 return spf_vv_mult<sivector,civector,cinterval,sparse_cidot>(v1,v2);
1087}
1088
1090
1096inline cinterval operator*(const scvector& v1, const ivector& v2) {
1097 return spf_vv_mult<scvector,ivector,cinterval,sparse_cidot>(v1,v2);
1098}
1099
1101
1107inline cinterval operator*(const sivector& v1, const cvector& v2) {
1108 return spf_vv_mult<sivector,cvector,cinterval,sparse_cidot>(v1,v2);
1109}
1110
1112
1118inline cinterval operator*(const rvector& v1, const scivector& v2) {
1119 return fsp_vv_mult<rvector,scivector,cinterval,sparse_cidot>(v1,v2);
1120}
1121
1123
1129inline cinterval operator*(const cvector& v1, const scivector& v2) {
1130 return fsp_vv_mult<cvector,scivector,cinterval,sparse_cidot>(v1,v2);
1131}
1132
1134
1140inline cinterval operator*(const ivector& v1, const scivector& v2) {
1141 return fsp_vv_mult<ivector,scivector,cinterval,sparse_cidot>(v1,v2);
1142}
1143
1145
1151inline cinterval operator*(const civector& v1, const scivector& v2) {
1152 return fsp_vv_mult<civector,scivector,cinterval,sparse_cidot>(v1,v2);
1153}
1154
1156
1162inline cinterval operator*(const civector& v1, const srvector& v2) {
1163 return fsp_vv_mult<civector,srvector,cinterval,sparse_cidot>(v1,v2);
1164}
1165
1167
1173inline cinterval operator*(const civector& v1, const scvector& v2) {
1174 return fsp_vv_mult<civector,scvector,cinterval,sparse_cidot>(v1,v2);
1175}
1176
1178
1184inline cinterval operator*(const civector& v1, const sivector& v2) {
1185 return fsp_vv_mult<civector,sivector,cinterval,sparse_cidot>(v1,v2);
1186}
1187
1189
1195inline cinterval operator*(const ivector& v1, const scvector& v2) {
1196 return fsp_vv_mult<ivector,scvector,cinterval,sparse_cidot>(v1,v2);
1197}
1198
1200
1206inline cinterval operator*(const cvector& v1, const sivector& v2) {
1207 return fsp_vv_mult<cvector,sivector,cinterval,sparse_cidot>(v1,v2);
1208}
1209
1211
1217inline cinterval operator*(const scivector& v1, const cvector_slice& v2) {
1218 return spf_vv_mult<scivector,cvector_slice,cinterval,sparse_cidot>(v1,v2);
1219}
1220
1222
1228inline cinterval operator*(const scivector& v1, const rvector_slice& v2) {
1229 return spf_vv_mult<scivector,rvector_slice,cinterval,sparse_cidot>(v1,v2);
1230}
1231
1233
1239inline cinterval operator*(const scivector& v1, const ivector_slice& v2) {
1240 return spf_vv_mult<scivector,ivector_slice,cinterval,sparse_cidot>(v1,v2);
1241}
1242
1244
1250inline cinterval operator*(const scivector& v1, const civector_slice& v2) {
1251 return spf_vv_mult<scivector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1252}
1253
1255
1261inline cinterval operator*(const scvector& v1, const civector_slice& v2) {
1262 return spf_vv_mult<scvector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1263}
1264
1266
1272inline cinterval operator*(const srvector& v1, const civector_slice& v2) {
1273 return spf_vv_mult<srvector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1274}
1275
1277
1283inline cinterval operator*(const sivector& v1, const civector_slice& v2) {
1284 return spf_vv_mult<sivector,civector_slice,cinterval,sparse_cidot>(v1,v2);
1285}
1286
1288
1294inline cinterval operator*(const scvector& v1, const ivector_slice& v2) {
1295 return spf_vv_mult<scvector,ivector_slice,cinterval,sparse_cidot>(v1,v2);
1296}
1297
1299
1305inline cinterval operator*(const sivector& v1, const cvector_slice& v2) {
1306 return spf_vv_mult<sivector,cvector_slice,cinterval,sparse_cidot>(v1,v2);
1307}
1308
1310
1316inline cinterval operator*(const rvector_slice& v1, const scivector& v2) {
1317 return fsp_vv_mult<rvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1318}
1319
1321
1327inline cinterval operator*(const cvector_slice& v1, const scivector& v2) {
1328 return fsp_vv_mult<cvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1329}
1330
1332
1338inline cinterval operator*(const ivector_slice& v1, const scivector& v2) {
1339 return fsp_vv_mult<ivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1340}
1341
1343
1349inline cinterval operator*(const civector_slice& v1, const scivector& v2) {
1350 return fsp_vv_mult<civector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
1351}
1352
1354
1360inline cinterval operator*(const civector_slice& v1, const srvector& v2) {
1361 return fsp_vv_mult<civector_slice,srvector,cinterval,sparse_cidot>(v1,v2);
1362}
1363
1365
1371inline cinterval operator*(const civector_slice& v1, const scvector& v2) {
1372 return fsp_vv_mult<civector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
1373}
1374
1376
1382inline cinterval operator*(const civector_slice& v1, const sivector& v2) {
1383 return fsp_vv_mult<civector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
1384}
1385
1387
1393inline cinterval operator*(const ivector_slice& v1, const scvector& v2) {
1394 return fsp_vv_mult<ivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
1395}
1396
1398
1404inline cinterval operator*(const cvector_slice& v1, const sivector& v2) {
1405 return fsp_vv_mult<cvector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
1406}
1407
1409
1415inline cinterval operator*(const scivector& v1, const srvector& v2) {
1416 return spsp_vv_mult<scivector,srvector,cinterval,sparse_cidot>(v1,v2);
1417}
1418
1420
1426inline cinterval operator*(const scivector& v1, const scvector& v2) {
1427 return spsp_vv_mult<scivector,scvector,cinterval,sparse_cidot>(v1,v2);
1428}
1429
1431
1437inline cinterval operator*(const scivector& v1, const sivector& v2) {
1438 return spsp_vv_mult<scivector,sivector,cinterval,sparse_cidot>(v1,v2);
1439}
1440
1442
1448inline cinterval operator*(const scivector& v1, const scivector& v2) {
1449 return spsp_vv_mult<scivector,scivector,cinterval,sparse_cidot>(v1,v2);
1450}
1451
1453
1459inline cinterval operator*(const srvector& v1, const scivector& v2) {
1460 return spsp_vv_mult<srvector,scivector,cinterval,sparse_cidot>(v1,v2);
1461}
1462
1464
1470inline cinterval operator*(const scvector& v1, const scivector& v2) {
1471 return spsp_vv_mult<scvector,scivector,cinterval,sparse_cidot>(v1,v2);
1472}
1473
1475
1481inline cinterval operator*(const sivector& v1, const scivector& v2) {
1482 return spsp_vv_mult<sivector,scivector,cinterval,sparse_cidot>(v1,v2);
1483}
1484
1486
1492inline cinterval operator*(const scvector& v1, const sivector& v2) {
1493 return spsp_vv_mult<scvector,sivector,cinterval,sparse_cidot>(v1,v2);
1494}
1495
1497
1503inline cinterval operator*(const sivector& v1, const scvector& v2) {
1504 return spsp_vv_mult<sivector,scvector,cinterval,sparse_cidot>(v1,v2);
1505}
1506
1508inline scivector operator*(const scivector& v, const real& s) {
1509 return sp_vs_mult<scivector,real,scivector>(v,s);
1510}
1511
1513inline scivector operator*(const scivector& v, const complex& s) {
1514 return sp_vs_mult<scivector,complex,scivector>(v,s);
1515}
1516
1518inline scivector operator*(const scivector& v, const interval& s) {
1519 return sp_vs_mult<scivector,interval,scivector>(v,s);
1520}
1521
1523inline scivector operator*(const scivector& v, const cinterval& s) {
1524 return sp_vs_mult<scivector,cinterval,scivector>(v,s);
1525}
1526
1528inline scivector operator*(const scvector& v, const interval& s) {
1529 return sp_vs_mult<scvector,interval,scivector>(v,s);
1530}
1531
1533inline scivector operator*(const sivector& v, const complex& s) {
1534 return sp_vs_mult<sivector,complex,scivector>(v,s);
1535}
1536
1538inline scivector operator/(const scivector& v, const real& s) {
1539 return sp_vs_div<scivector,real,scivector>(v,s);
1540}
1541
1543inline scivector operator/(const scivector& v, const complex& s) {
1544 return sp_vs_div<scivector,complex,scivector>(v,s);
1545}
1546
1548inline scivector operator/(const scivector& v, const interval& s) {
1549 return sp_vs_div<scivector,interval,scivector>(v,s);
1550}
1551
1553inline scivector operator/(const scivector& v, const cinterval& s) {
1554 return sp_vs_div<scivector,cinterval,scivector>(v,s);
1555}
1556
1558inline scivector operator/(const srvector& v, const cinterval& s) {
1559 return sp_vs_div<srvector,cinterval,scivector>(v,s);
1560}
1561
1563inline scivector operator/(const scvector& v, const cinterval& s) {
1564 return sp_vs_div<scvector,cinterval,scivector>(v,s);
1565}
1566
1568inline scivector operator/(const sivector& v, const cinterval& s) {
1569 return sp_vs_div<sivector,cinterval,scivector>(v,s);
1570}
1571
1573inline scivector operator/(const scvector& v, const interval& s) {
1574 return sp_vs_div<scvector,interval,scivector>(v,s);
1575}
1576
1578inline scivector operator/(const sivector& v, const complex& s) {
1579 return sp_vs_div<sivector,complex,scivector>(v,s);
1580}
1581
1583inline scivector operator*(const real& s, const scivector& v) {
1584 return sp_sv_mult<real,scivector,scivector>(s,v);
1585}
1586
1588inline scivector operator*(const complex& s, const scivector& v) {
1589 return sp_sv_mult<complex,scivector,scivector>(s,v);
1590}
1591
1593inline scivector operator*(const interval& s, const scivector& v) {
1594 return sp_sv_mult<interval,scivector,scivector>(s,v);
1595}
1596
1598inline scivector operator*(const cinterval& s, const srvector& v) {
1599 return sp_sv_mult<cinterval,srvector,scivector>(s,v);
1600}
1601
1603inline scivector operator*(const cinterval& s, const sivector& v) {
1604 return sp_sv_mult<cinterval,sivector,scivector>(s,v);
1605}
1606
1608inline scivector operator*(const cinterval& s, const scvector& v) {
1609 return sp_sv_mult<cinterval,scvector,scivector>(s,v);
1610}
1611
1613inline scivector operator*(const cinterval& s, const scivector& v) {
1614 return sp_sv_mult<cinterval,scivector,scivector>(s,v);
1615}
1616
1618inline scivector operator*(const srvector& v, const cinterval& s) {
1619 return sp_sv_mult<cinterval,srvector,scivector>(s,v);
1620}
1621
1623inline scivector operator*(const sivector& v, const cinterval& s) {
1624 return sp_sv_mult<cinterval,sivector,scivector>(s,v);
1625}
1626
1628inline scivector operator*(const scvector& v, const cinterval& s) {
1629 return sp_sv_mult<cinterval,scvector,scivector>(s,v);
1630}
1631
1633inline scivector operator*(const complex& s, const sivector& v) {
1634 return sp_sv_mult<complex,sivector,scivector>(s,v);
1635}
1636
1638inline scivector operator*(const interval& s, const scvector& v) {
1639 return sp_sv_mult<interval,scvector,scivector>(s,v);
1640}
1641
1643inline civector operator+(const civector& v1, const srvector& v2) {
1644 return fsp_vv_add<civector,srvector,civector>(v1,v2);
1645}
1646
1648inline civector operator+(const civector& v1, const scvector& v2) {
1649 return fsp_vv_add<civector,scvector,civector>(v1,v2);
1650}
1651
1653inline civector operator+(const civector& v1, const sivector& v2) {
1654 return fsp_vv_add<civector,sivector,civector>(v1,v2);
1655}
1656
1658inline civector operator+(const civector& v1, const scivector& v2) {
1659 return fsp_vv_add<civector,scivector,civector>(v1,v2);
1660}
1661
1663inline civector operator+(const rvector& v1, const scivector& v2) {
1664 return fsp_vv_add<rvector,scivector,civector>(v1,v2);
1665}
1666
1668inline civector operator+(const cvector& v1, const scivector& v2) {
1669 return fsp_vv_add<cvector,scivector,civector>(v1,v2);
1670}
1671
1673inline civector operator+(const ivector& v1, const scivector& v2) {
1674 return fsp_vv_add<ivector,scivector,civector>(v1,v2);
1675}
1676
1678inline civector operator+(const cvector& v1, const sivector& v2) {
1679 return fsp_vv_add<cvector,sivector,civector>(v1,v2);
1680}
1681
1683inline civector operator+(const ivector& v1, const scvector& v2) {
1684 return fsp_vv_add<ivector,scvector,civector>(v1,v2);
1685}
1686
1688inline civector operator+(const scivector& v1, const rvector& v2) {
1689 return spf_vv_add<scivector,rvector,civector>(v1,v2);
1690}
1691
1693inline civector operator+(const scivector& v1, const cvector& v2) {
1694 return spf_vv_add<scivector,cvector,civector>(v1,v2);
1695}
1696
1698inline civector operator+(const scivector& v1, const ivector& v2) {
1699 return spf_vv_add<scivector,ivector,civector>(v1,v2);
1700}
1701
1703inline civector operator+(const scivector& v1, const civector& v2) {
1704 return spf_vv_add<scivector,civector,civector>(v1,v2);
1705}
1706
1708inline civector operator+(const srvector& v1, const civector& v2) {
1709 return spf_vv_add<srvector,civector,civector>(v1,v2);
1710}
1711
1713inline civector operator+(const scvector& v1, const civector& v2) {
1714 return spf_vv_add<scvector,civector,civector>(v1,v2);
1715}
1716
1718inline civector operator+(const sivector& v1, const civector& v2) {
1719 return spf_vv_add<sivector,civector,civector>(v1,v2);
1720}
1721
1723inline civector operator+(const scvector& v1, const ivector& v2) {
1724 return spf_vv_add<scvector,ivector,civector>(v1,v2);
1725}
1726
1728inline civector operator+(const sivector& v1, const cvector& v2) {
1729 return spf_vv_add<sivector,cvector,civector>(v1,v2);
1730}
1731
1733inline civector operator+(const civector_slice& v1, const srvector& v2) {
1734 return fsp_vv_add<civector_slice,srvector,civector>(v1,v2);
1735}
1736
1738inline civector operator+(const civector_slice& v1, const scvector& v2) {
1739 return fsp_vv_add<civector_slice,scvector,civector>(v1,v2);
1740}
1741
1743inline civector operator+(const civector_slice& v1, const sivector& v2) {
1744 return fsp_vv_add<civector_slice,sivector,civector>(v1,v2);
1745}
1746
1748inline civector operator+(const civector_slice& v1, const scivector& v2) {
1749 return fsp_vv_add<civector_slice,scivector,civector>(v1,v2);
1750}
1751
1753inline civector operator+(const rvector_slice& v1, const scivector& v2) {
1754 return fsp_vv_add<rvector_slice,scivector,civector>(v1,v2);
1755}
1756
1758inline civector operator+(const cvector_slice& v1, const scivector& v2) {
1759 return fsp_vv_add<cvector_slice,scivector,civector>(v1,v2);
1760}
1761
1763inline civector operator+(const ivector_slice& v1, const scivector& v2) {
1764 return fsp_vv_add<ivector_slice,scivector,civector>(v1,v2);
1765}
1766
1768inline civector operator+(const cvector_slice& v1, const sivector& v2) {
1769 return fsp_vv_add<cvector_slice,sivector,civector>(v1,v2);
1770}
1771
1773inline civector operator+(const ivector_slice& v1, const scvector& v2) {
1774 return fsp_vv_add<ivector_slice,scvector,civector>(v1,v2);
1775}
1776
1778inline civector operator+(const scivector& v1, const rvector_slice& v2) {
1779 return spf_vv_add<scivector,rvector_slice,civector>(v1,v2);
1780}
1781
1783inline civector operator+(const scivector& v1, const cvector_slice& v2) {
1784 return spf_vv_add<scivector,cvector_slice,civector>(v1,v2);
1785}
1786
1788inline civector operator+(const scivector& v1, const ivector_slice& v2) {
1789 return spf_vv_add<scivector,ivector_slice,civector>(v1,v2);
1790}
1791
1793inline civector operator+(const scivector& v1, const civector_slice& v2) {
1794 return spf_vv_add<scivector,civector_slice,civector>(v1,v2);
1795}
1796
1798inline civector operator+(const srvector& v1, const civector_slice& v2) {
1799 return spf_vv_add<srvector,civector_slice,civector>(v1,v2);
1800}
1801
1803inline civector operator+(const scvector& v1, const civector_slice& v2) {
1804 return spf_vv_add<scvector,civector_slice,civector>(v1,v2);
1805}
1806
1808inline civector operator+(const sivector& v1, const civector_slice& v2) {
1809 return spf_vv_add<sivector,civector_slice,civector>(v1,v2);
1810}
1811
1813inline civector operator+(const scvector& v1, const ivector_slice& v2) {
1814 return spf_vv_add<scvector,ivector_slice,civector>(v1,v2);
1815}
1816
1818inline civector operator+(const sivector& v1, const cvector_slice& v2) {
1819 return spf_vv_add<sivector,cvector_slice,civector>(v1,v2);
1820}
1821
1823inline scivector operator+(const scivector& v1, const srvector& v2) {
1824 return spsp_vv_add<scivector,srvector,scivector,cinterval>(v1,v2);
1825}
1826
1828inline scivector operator+(const scivector& v1, const scvector& v2) {
1829 return spsp_vv_add<scivector,scvector,scivector,cinterval>(v1,v2);
1830}
1831
1833inline scivector operator+(const scivector& v1, const sivector& v2) {
1834 return spsp_vv_add<scivector,sivector,scivector,cinterval>(v1,v2);
1835}
1836
1838inline scivector operator+(const scivector& v1, const scivector& v2) {
1839 return spsp_vv_add<scivector,scivector,scivector,cinterval>(v1,v2);
1840}
1841
1843inline scivector operator+(const srvector& v1, const scivector& v2) {
1844 return spsp_vv_add<srvector,scivector,scivector,cinterval>(v1,v2);
1845}
1846
1848inline scivector operator+(const scvector& v1, const scivector& v2) {
1849 return spsp_vv_add<scvector,scivector,scivector,cinterval>(v1,v2);
1850}
1851
1853inline scivector operator+(const sivector& v1, const scivector& v2) {
1854 return spsp_vv_add<sivector,scivector,scivector,cinterval>(v1,v2);
1855}
1856
1858inline scivector operator+(const scvector& v1, const sivector& v2) {
1859 return spsp_vv_add<scvector,sivector,scivector,cinterval>(v1,v2);
1860}
1861
1863inline scivector operator+(const sivector& v1, const scvector& v2) {
1864 return spsp_vv_add<sivector,scvector,scivector,cinterval>(v1,v2);
1865}
1866
1868inline civector operator-(const civector& v1, const srvector& v2) {
1869 return fsp_vv_sub<civector,srvector,civector>(v1,v2);
1870}
1871
1873inline civector operator-(const civector& v1, const sivector& v2) {
1874 return fsp_vv_sub<civector,sivector,civector>(v1,v2);
1875}
1876
1878inline civector operator-(const civector& v1, const scvector& v2) {
1879 return fsp_vv_sub<civector,scvector,civector>(v1,v2);
1880}
1881
1883inline civector operator-(const civector& v1, const scivector& v2) {
1884 return fsp_vv_sub<civector,scivector,civector>(v1,v2);
1885}
1886
1888inline civector operator-(const rvector& v1, const scivector& v2) {
1889 return fsp_vv_sub<rvector,scivector,civector>(v1,v2);
1890}
1891
1893inline civector operator-(const cvector& v1, const scivector& v2) {
1894 return fsp_vv_sub<cvector,scivector,civector>(v1,v2);
1895}
1896
1898inline civector operator-(const ivector& v1, const scivector& v2) {
1899 return fsp_vv_sub<ivector,scivector,civector>(v1,v2);
1900}
1901
1903inline civector operator-(const cvector& v1, const sivector& v2) {
1904 return fsp_vv_sub<cvector,sivector,civector>(v1,v2);
1905}
1906
1908inline civector operator-(const ivector& v1, const scvector& v2) {
1909 return fsp_vv_sub<ivector,scvector,civector>(v1,v2);
1910}
1911
1913inline civector operator-(const scivector& v1, const rvector& v2) {
1914 return spf_vv_sub<scivector,rvector,civector>(v1,v2);
1915}
1916
1918inline civector operator-(const scivector& v1, const cvector& v2) {
1919 return spf_vv_sub<scivector,cvector,civector>(v1,v2);
1920}
1921
1923inline civector operator-(const scivector& v1, const ivector& v2) {
1924 return spf_vv_sub<scivector,ivector,civector>(v1,v2);
1925}
1926
1928inline civector operator-(const scivector& v1, const civector& v2) {
1929 return spf_vv_sub<scivector,civector,civector>(v1,v2);
1930}
1931
1933inline civector operator-(const srvector& v1, const civector& v2) {
1934 return spf_vv_sub<srvector,civector,civector>(v1,v2);
1935}
1936
1938inline civector operator-(const scvector& v1, const civector& v2) {
1939 return spf_vv_sub<scvector,civector,civector>(v1,v2);
1940}
1941
1943inline civector operator-(const sivector& v1, const civector& v2) {
1944 return spf_vv_sub<sivector,civector,civector>(v1,v2);
1945}
1946
1948inline civector operator-(const scvector& v1, const ivector& v2) {
1949 return spf_vv_sub<scvector,ivector,civector>(v1,v2);
1950}
1951
1953inline civector operator-(const sivector& v1, const cvector& v2) {
1954 return spf_vv_sub<sivector,cvector,civector>(v1,v2);
1955}
1956
1958inline civector operator-(const civector_slice& v1, const srvector& v2) {
1959 return fsp_vv_sub<civector_slice,srvector,civector>(v1,v2);
1960}
1961
1963inline civector operator-(const civector_slice& v1, const sivector& v2) {
1964 return fsp_vv_sub<civector_slice,sivector,civector>(v1,v2);
1965}
1966
1968inline civector operator-(const civector_slice& v1, const scvector& v2) {
1969 return fsp_vv_sub<civector_slice,scvector,civector>(v1,v2);
1970}
1971
1973inline civector operator-(const civector_slice& v1, const scivector& v2) {
1974 return fsp_vv_sub<civector_slice,scivector,civector>(v1,v2);
1975}
1976
1978inline civector operator-(const rvector_slice& v1, const scivector& v2) {
1979 return fsp_vv_sub<rvector_slice,scivector,civector>(v1,v2);
1980}
1981
1983inline civector operator-(const cvector_slice& v1, const scivector& v2) {
1984 return fsp_vv_sub<cvector_slice,scivector,civector>(v1,v2);
1985}
1986
1988inline civector operator-(const ivector_slice& v1, const scivector& v2) {
1989 return fsp_vv_sub<ivector_slice,scivector,civector>(v1,v2);
1990}
1991
1993inline civector operator-(const cvector_slice& v1, const sivector& v2) {
1994 return fsp_vv_sub<cvector_slice,sivector,civector>(v1,v2);
1995}
1996
1998inline civector operator-(const ivector_slice& v1, const scvector& v2) {
1999 return fsp_vv_sub<ivector_slice,scvector,civector>(v1,v2);
2000}
2001
2003inline civector operator-(const scivector& v1, const rvector_slice& v2) {
2004 return spf_vv_sub<scivector,rvector_slice,civector>(v1,v2);
2005}
2006
2008inline civector operator-(const scivector& v1, const cvector_slice& v2) {
2009 return spf_vv_sub<scivector,cvector_slice,civector>(v1,v2);
2010}
2011
2013inline civector operator-(const scivector& v1, const ivector_slice& v2) {
2014 return spf_vv_sub<scivector,ivector_slice,civector>(v1,v2);
2015}
2016
2018inline civector operator-(const scivector& v1, const civector_slice& v2) {
2019 return spf_vv_sub<scivector,civector_slice,civector>(v1,v2);
2020}
2021
2023inline civector operator-(const srvector& v1, const civector_slice& v2) {
2024 return spf_vv_sub<srvector,civector_slice,civector>(v1,v2);
2025}
2026
2028inline civector operator-(const scvector& v1, const civector_slice& v2) {
2029 return spf_vv_sub<scvector,civector_slice,civector>(v1,v2);
2030}
2031
2033inline civector operator-(const sivector& v1, const civector_slice& v2) {
2034 return spf_vv_sub<sivector,civector_slice,civector>(v1,v2);
2035}
2036
2038inline civector operator-(const scvector& v1, const ivector_slice& v2) {
2039 return spf_vv_sub<scvector,ivector_slice,civector>(v1,v2);
2040}
2041
2043inline civector operator-(const sivector& v1, const cvector_slice& v2) {
2044 return spf_vv_sub<sivector,cvector_slice,civector>(v1,v2);
2045}
2046
2048inline scivector operator-(const scivector& v1, const srvector& v2) {
2049 return spsp_vv_sub<scivector,srvector,scivector,cinterval>(v1,v2);
2050}
2051
2053inline scivector operator-(const scivector& v1, const scvector& v2) {
2054 return spsp_vv_sub<scivector,scvector,scivector,cinterval>(v1,v2);
2055}
2056
2058inline scivector operator-(const scivector& v1, const sivector& v2) {
2059 return spsp_vv_sub<scivector,sivector,scivector,cinterval>(v1,v2);
2060}
2061
2063inline scivector operator-(const scivector& v1, const scivector& v2) {
2064 return spsp_vv_sub<scivector,scivector,scivector,cinterval>(v1,v2);
2065}
2066
2068inline scivector operator-(const srvector& v1, const scivector& v2) {
2069 return spsp_vv_sub<srvector,scivector,scivector,cinterval>(v1,v2);
2070}
2071
2073inline scivector operator-(const scvector& v1, const scivector& v2) {
2074 return spsp_vv_sub<scvector,scivector,scivector,cinterval>(v1,v2);
2075}
2076
2078inline scivector operator-(const sivector& v1, const scivector& v2) {
2079 return spsp_vv_sub<sivector,scivector,scivector,cinterval>(v1,v2);
2080}
2081
2083inline scivector operator-(const scvector& v1, const sivector& v2) {
2084 return spsp_vv_sub<scvector,sivector,scivector,cinterval>(v1,v2);
2085}
2086
2088inline scivector operator-(const sivector& v1, const scvector& v2) {
2089 return spsp_vv_sub<sivector,scvector,scivector,cinterval>(v1,v2);
2090}
2091
2093inline civector operator|(const civector& v1, const srvector& v2) {
2094 return fsp_vv_hull<civector,srvector,civector>(v1,v2);
2095}
2096
2098inline civector operator|(const civector& v1, const scvector& v2) {
2099 return fsp_vv_hull<civector,scvector,civector>(v1,v2);
2100}
2101
2103inline civector operator|(const civector& v1, const sivector& v2) {
2104 return fsp_vv_hull<civector,sivector,civector>(v1,v2);
2105}
2106
2108inline civector operator|(const civector& v1, const scivector& v2) {
2109 return fsp_vv_hull<civector,scivector,civector>(v1,v2);
2110}
2111
2113inline civector operator|(const rvector& v1, const scivector& v2) {
2114 return fsp_vv_hull<rvector,scivector,civector>(v1,v2);
2115}
2116
2118inline civector operator|(const cvector& v1, const scivector& v2) {
2119 return fsp_vv_hull<cvector,scivector,civector>(v1,v2);
2120}
2121
2123inline civector operator|(const ivector& v1, const scivector& v2) {
2124 return fsp_vv_hull<ivector,scivector,civector>(v1,v2);
2125}
2126
2128inline civector operator|(const cvector& v1, const sivector& v2) {
2129 return fsp_vv_hull<cvector,sivector,civector>(v1,v2);
2130}
2131
2133inline civector operator|(const ivector& v1, const scvector& v2) {
2134 return fsp_vv_hull<ivector,scvector,civector>(v1,v2);
2135}
2136
2138inline civector operator|(const scivector& v1, const rvector& v2) {
2139 return spf_vv_hull<scivector,rvector,civector>(v1,v2);
2140}
2141
2143inline civector operator|(const scivector& v1, const cvector& v2) {
2144 return spf_vv_hull<scivector,cvector,civector>(v1,v2);
2145}
2146
2148inline civector operator|(const scivector& v1, const ivector& v2) {
2149 return spf_vv_hull<scivector,ivector,civector>(v1,v2);
2150}
2151
2153inline civector operator|(const scivector& v1, const civector& v2) {
2154 return spf_vv_hull<scivector,civector,civector>(v1,v2);
2155}
2156
2158inline civector operator|(const srvector& v1, const civector& v2) {
2159 return spf_vv_hull<srvector,civector,civector>(v1,v2);
2160}
2161
2163inline civector operator|(const scvector& v1, const civector& v2) {
2164 return spf_vv_hull<scvector,civector,civector>(v1,v2);
2165}
2166
2168inline civector operator|(const sivector& v1, const civector& v2) {
2169 return spf_vv_hull<sivector,civector,civector>(v1,v2);
2170}
2171
2173inline civector operator|(const scvector& v1, const ivector& v2) {
2174 return spf_vv_hull<scvector,ivector,civector>(v1,v2);
2175}
2176
2178inline civector operator|(const sivector& v1, const cvector& v2) {
2179 return spf_vv_hull<sivector,cvector,civector>(v1,v2);
2180}
2181
2183inline civector operator|(const civector_slice& v1, const srvector& v2) {
2184 return fsp_vv_hull<civector_slice,srvector,civector>(v1,v2);
2185}
2186
2188inline civector operator|(const civector_slice& v1, const scvector& v2) {
2189 return fsp_vv_hull<civector_slice,scvector,civector>(v1,v2);
2190}
2191
2193inline civector operator|(const civector_slice& v1, const sivector& v2) {
2194 return fsp_vv_hull<civector_slice,sivector,civector>(v1,v2);
2195}
2196
2198inline civector operator|(const civector_slice& v1, const scivector& v2) {
2199 return fsp_vv_hull<civector_slice,scivector,civector>(v1,v2);
2200}
2201
2203inline civector operator|(const rvector_slice& v1, const scivector& v2) {
2204 return fsp_vv_hull<rvector_slice,scivector,civector>(v1,v2);
2205}
2206
2208inline civector operator|(const cvector_slice& v1, const scivector& v2) {
2209 return fsp_vv_hull<cvector_slice,scivector,civector>(v1,v2);
2210}
2211
2213inline civector operator|(const ivector_slice& v1, const scivector& v2) {
2214 return fsp_vv_hull<ivector_slice,scivector,civector>(v1,v2);
2215}
2216
2218inline civector operator|(const cvector_slice& v1, const sivector& v2) {
2219 return fsp_vv_hull<cvector_slice,sivector,civector>(v1,v2);
2220}
2221
2223inline civector operator|(const ivector_slice& v1, const scvector& v2) {
2224 return fsp_vv_hull<ivector_slice,scvector,civector>(v1,v2);
2225}
2226
2228inline civector operator|(const scivector& v1, const rvector_slice& v2) {
2229 return spf_vv_hull<scivector,rvector_slice,civector>(v1,v2);
2230}
2231
2233inline civector operator|(const scivector& v1, const cvector_slice& v2) {
2234 return spf_vv_hull<scivector,cvector_slice,civector>(v1,v2);
2235}
2236
2238inline civector operator|(const scivector& v1, const ivector_slice& v2) {
2239 return spf_vv_hull<scivector,ivector_slice,civector>(v1,v2);
2240}
2241
2243inline civector operator|(const scivector& v1, const civector_slice& v2) {
2244 return spf_vv_hull<scivector,civector_slice,civector>(v1,v2);
2245}
2246
2248inline civector operator|(const srvector& v1, const civector_slice& v2) {
2249 return spf_vv_hull<srvector,civector_slice,civector>(v1,v2);
2250}
2251
2253inline civector operator|(const scvector& v1, const civector_slice& v2) {
2254 return spf_vv_hull<scvector,civector_slice,civector>(v1,v2);
2255}
2256
2258inline civector operator|(const sivector& v1, const civector_slice& v2) {
2259 return spf_vv_hull<sivector,civector_slice,civector>(v1,v2);
2260}
2261
2263inline civector operator|(const scvector& v1, const ivector_slice& v2) {
2264 return spf_vv_hull<scvector,ivector_slice,civector>(v1,v2);
2265}
2266
2268inline civector operator|(const sivector& v1, const cvector_slice& v2) {
2269 return spf_vv_hull<sivector,cvector_slice,civector>(v1,v2);
2270}
2271
2273inline scivector operator|(const scivector& v1, const srvector& v2) {
2274 return spsp_vv_hull<scivector,srvector,scivector,cinterval>(v1,v2);
2275}
2276
2278inline scivector operator|(const scivector& v1, const scvector& v2) {
2279 return spsp_vv_hull<scivector,scvector,scivector,cinterval>(v1,v2);
2280}
2281
2283inline scivector operator|(const scivector& v1, const sivector& v2) {
2284 return spsp_vv_hull<scivector,sivector,scivector,cinterval>(v1,v2);
2285}
2286
2288inline scivector operator|(const scivector& v1, const scivector& v2) {
2289 return spsp_vv_hull<scivector,scivector,scivector,cinterval>(v1,v2);
2290}
2291
2293inline scivector operator|(const srvector& v1, const scivector& v2) {
2294 return spsp_vv_hull<srvector,scivector,scivector,cinterval>(v1,v2);
2295}
2296
2298inline scivector operator|(const scvector& v1, const scivector& v2) {
2299 return spsp_vv_hull<scvector,scivector,scivector,cinterval>(v1,v2);
2300}
2301
2303inline scivector operator|(const sivector& v1, const scivector& v2) {
2304 return spsp_vv_hull<sivector,scivector,scivector,cinterval>(v1,v2);
2305}
2306
2308inline scivector operator|(const scvector& v1, const sivector& v2) {
2309 return spsp_vv_hull<scvector,sivector,scivector,cinterval>(v1,v2);
2310}
2311
2313inline scivector operator|(const sivector& v1, const scvector& v2) {
2314 return spsp_vv_hull<sivector,scvector,scivector,cinterval>(v1,v2);
2315}
2316
2318inline civector operator|(const cvector& v1, const srvector& v2) {
2319 return fsp_vv_hull<cvector,srvector,civector>(v1,v2);
2320}
2321
2323inline civector operator|(const rvector& v1, const scvector& v2) {
2324 return fsp_vv_hull<rvector,scvector,civector>(v1,v2);
2325}
2326
2328inline civector operator|(const cvector& v1, const scvector& v2) {
2329 return fsp_vv_hull<cvector,scvector,civector>(v1,v2);
2330}
2331
2333inline civector operator|(const scvector& v1, const rvector& v2) {
2334 return spf_vv_hull<scvector,rvector,civector>(v1,v2);
2335}
2336
2338inline civector operator|(const srvector& v1, const cvector& v2) {
2339 return spf_vv_hull<srvector,cvector,civector>(v1,v2);
2340}
2341
2343inline civector operator|(const scvector& v1, const cvector& v2) {
2344 return spf_vv_hull<scvector,cvector,civector>(v1,v2);
2345}
2346
2348inline civector operator|(const cvector_slice& v1, const srvector& v2) {
2349 return fsp_vv_hull<cvector_slice,srvector,civector>(v1,v2);
2350}
2351
2353inline civector operator|(const rvector_slice& v1, const scvector& v2) {
2354 return fsp_vv_hull<rvector_slice,scvector,civector>(v1,v2);
2355}
2356
2358inline civector operator|(const cvector_slice& v1, const scvector& v2) {
2359 return fsp_vv_hull<cvector_slice,scvector,civector>(v1,v2);
2360}
2361
2363inline civector operator|(const scvector& v1, const rvector_slice& v2) {
2364 return spf_vv_hull<scvector,rvector_slice,civector>(v1,v2);
2365}
2366
2368inline civector operator|(const srvector& v1, const cvector_slice& v2) {
2369 return spf_vv_hull<srvector,cvector_slice,civector>(v1,v2);
2370}
2371
2373inline civector operator|(const scvector& v1, const cvector_slice& v2) {
2374 return spf_vv_hull<scvector,cvector_slice,civector>(v1,v2);
2375}
2376
2378inline scivector operator|(const scvector& v1, const srvector& v2) {
2379 return spsp_vv_hull<scvector,srvector,scivector,cinterval>(v1,v2);
2380}
2381
2383inline scivector operator|(const srvector& v1, const scvector& v2) {
2384 return spsp_vv_hull<srvector,scvector,scivector,cinterval>(v1,v2);
2385}
2386
2388inline scivector operator|(const scvector& v1, const scvector& v2) {
2389 return spsp_vv_hull<scvector,scvector,scivector,cinterval>(v1,v2);
2390}
2391
2393inline civector operator|(const cvector& v1, const srvector_slice& v2) {
2394 return fsl_vv_hull<cvector,srvector_slice,civector>(v1,v2);
2395}
2396
2398inline civector operator|(const rvector& v1, const scvector_slice& v2) {
2399 return fsl_vv_hull<rvector,scvector_slice,civector>(v1,v2);
2400}
2401
2403inline civector operator|(const cvector& v1, const scvector_slice& v2) {
2404 return fsl_vv_hull<cvector,scvector_slice,civector>(v1,v2);
2405}
2406
2408inline civector operator|(const scvector_slice& v1, const rvector& v2) {
2409 return slf_vv_hull<scvector_slice,rvector,civector>(v1,v2);
2410}
2411
2413inline civector operator|(const srvector_slice& v1, const cvector& v2) {
2414 return slf_vv_hull<srvector_slice,cvector,civector>(v1,v2);
2415}
2416
2418inline civector operator|(const scvector_slice& v1, const cvector& v2) {
2419 return slf_vv_hull<scvector_slice,cvector,civector>(v1,v2);
2420}
2421
2423inline civector operator|(const cvector_slice& v1, const srvector_slice& v2) {
2424 return fsl_vv_hull<cvector_slice,srvector_slice,civector>(v1,v2);
2425}
2426
2428inline civector operator|(const rvector_slice& v1, const scvector_slice& v2) {
2429 return fsl_vv_hull<rvector_slice,scvector_slice,civector>(v1,v2);
2430}
2431
2433inline civector operator|(const cvector_slice& v1, const scvector_slice& v2) {
2434 return fsl_vv_hull<cvector_slice,scvector_slice,civector>(v1,v2);
2435}
2436
2438inline civector operator|(const scvector_slice& v1, const rvector_slice& v2) {
2439 return slf_vv_hull<scvector_slice,rvector_slice,civector>(v1,v2);
2440}
2441
2443inline civector operator|(const srvector_slice& v1, const cvector_slice& v2) {
2444 return slf_vv_hull<srvector_slice,cvector_slice,civector>(v1,v2);
2445}
2446
2448inline civector operator|(const scvector_slice& v1, const cvector_slice& v2) {
2449 return slf_vv_hull<scvector_slice,cvector_slice,civector>(v1,v2);
2450}
2451
2453inline scivector operator|(const scvector_slice& v1, const srvector_slice& v2) {
2454 return slsl_vv_hull<scvector_slice,srvector_slice,scivector,cinterval>(v1,v2);
2455}
2456
2458inline scivector operator|(const srvector_slice& v1, const scvector_slice& v2) {
2459 return slsl_vv_hull<srvector_slice,scvector_slice,scivector,cinterval>(v1,v2);
2460}
2461
2463inline scivector operator|(const scvector_slice& v1, const scvector_slice& v2) {
2464 return slsl_vv_hull<scvector_slice,scvector_slice,scivector,cinterval>(v1,v2);
2465}
2466
2468inline scivector operator|(const scvector& v1, const srvector_slice& v2) {
2469 return spsl_vv_hull<scvector,srvector_slice,scivector,cinterval>(v1,v2);
2470}
2471
2473inline scivector operator|(const srvector& v1, const scvector_slice& v2) {
2474 return spsl_vv_hull<srvector,scvector_slice,scivector,cinterval>(v1,v2);
2475}
2476
2478inline scivector operator|(const scvector& v1, const scvector_slice& v2) {
2479 return spsl_vv_hull<scvector,scvector_slice,scivector,cinterval>(v1,v2);
2480}
2481
2483inline scivector operator|(const scvector_slice& v1, const srvector& v2) {
2484 return slsp_vv_hull<scvector_slice,srvector,scivector,cinterval>(v1,v2);
2485}
2486
2488inline scivector operator|(const srvector_slice& v1, const scvector& v2) {
2489 return slsp_vv_hull<srvector_slice,scvector,scivector,cinterval>(v1,v2);
2490}
2491
2493inline scivector operator|(const scvector_slice& v1, const scvector& v2) {
2494 return slsp_vv_hull<scvector_slice,scvector,scivector,cinterval>(v1,v2);
2495}
2496
2498inline civector operator&(const civector& v1, const sivector& v2) {
2499 return fsp_vv_intersect<civector,sivector,civector>(v1,v2);
2500}
2501
2503inline civector operator&(const civector& v1, const scivector& v2) {
2504 return fsp_vv_intersect<civector,scivector,civector>(v1,v2);
2505}
2506
2508inline civector operator&(const ivector& v1, const scivector& v2) {
2509 return fsp_vv_intersect<ivector,scivector,civector>(v1,v2);
2510}
2511
2513inline civector operator&(const scivector& v1, const ivector& v2) {
2514 return spf_vv_intersect<scivector,ivector,civector>(v1,v2);
2515}
2516
2518inline civector operator&(const scivector& v1, const civector& v2) {
2519 return spf_vv_intersect<scivector,civector,civector>(v1,v2);
2520}
2521
2523inline civector operator&(const sivector& v1, const civector& v2) {
2524 return spf_vv_intersect<sivector,civector,civector>(v1,v2);
2525}
2526
2528inline civector operator&(const civector_slice& v1, const sivector& v2) {
2529 return fsp_vv_intersect<civector_slice,sivector,civector>(v1,v2);
2530}
2531
2533inline civector operator&(const civector_slice& v1, const scivector& v2) {
2534 return fsp_vv_intersect<civector_slice,scivector,civector>(v1,v2);
2535}
2536
2538inline civector operator&(const ivector_slice& v1, const scivector& v2) {
2539 return fsp_vv_intersect<ivector_slice,scivector,civector>(v1,v2);
2540}
2541
2543inline civector operator&(const scivector& v1, const ivector_slice& v2) {
2544 return spf_vv_intersect<scivector,ivector_slice,civector>(v1,v2);
2545}
2546
2548inline civector operator&(const scivector& v1, const civector_slice& v2) {
2549 return spf_vv_intersect<scivector,civector_slice,civector>(v1,v2);
2550}
2551
2553inline civector operator&(const sivector& v1, const civector_slice& v2) {
2554 return spf_vv_intersect<sivector,civector_slice,civector>(v1,v2);
2555}
2556
2558inline scivector operator&(const scivector& v1, const sivector& v2) {
2559 return spsp_vv_intersect<scivector,sivector,scivector,cinterval>(v1,v2);
2560}
2561
2563inline scivector operator&(const scivector& v1, const scivector& v2) {
2564 return spsp_vv_intersect<scivector,scivector,scivector,cinterval>(v1,v2);
2565}
2566
2568inline scivector operator&(const sivector& v1, const scivector& v2) {
2569 return spsp_vv_intersect<sivector,scivector,scivector,cinterval>(v1,v2);
2570}
2571
2572inline civector& civector::operator+=(const srvector& v2) {
2573 return fsp_vv_addassign(*this,v2);
2574}
2575
2576inline civector& civector::operator+=(const scvector& v2) {
2577 return fsp_vv_addassign(*this,v2);
2578}
2579
2580inline civector& civector::operator+=(const sivector& v2) {
2581 return fsp_vv_addassign(*this,v2);
2582}
2583
2584inline civector& civector::operator+=(const scivector& v2) {
2585 return fsp_vv_addassign(*this,v2);
2586}
2587
2588inline civector_slice& civector_slice::operator+=(const srvector& v2) {
2589 return fsp_vv_addassign(*this,v2);
2590}
2591
2592inline civector_slice& civector_slice::operator+=(const scvector& v2) {
2593 return fsp_vv_addassign(*this,v2);
2594}
2595
2596inline civector_slice& civector_slice::operator+=(const sivector& v2) {
2597 return fsp_vv_addassign(*this,v2);
2598}
2599
2600inline civector_slice& civector_slice::operator+=(const scivector& v2) {
2601 return fsp_vv_addassign(*this,v2);
2602}
2603
2604inline civector& civector::operator-=(const srvector& v2) {
2605 return fsp_vv_subassign(*this,v2);
2606}
2607
2608inline civector& civector::operator-=(const scvector& v2) {
2609 return fsp_vv_subassign(*this,v2);
2610}
2611
2612inline civector& civector::operator-=(const sivector& v2) {
2613 return fsp_vv_subassign(*this,v2);
2614}
2615
2616inline civector& civector::operator-=(const scivector& v2) {
2617 return fsp_vv_subassign(*this,v2);
2618}
2619
2620inline civector_slice& civector_slice::operator-=(const srvector& v2) {
2621 return fsp_vv_subassign(*this,v2);
2622}
2623
2624inline civector_slice& civector_slice::operator-=(const scvector& v2) {
2625 return fsp_vv_subassign(*this,v2);
2626}
2627
2628inline civector_slice& civector_slice::operator-=(const sivector& v2) {
2629 return fsp_vv_subassign(*this,v2);
2630}
2631
2632inline civector_slice& civector_slice::operator-=(const scivector& v2) {
2633 return fsp_vv_subassign(*this,v2);
2634}
2635
2636inline civector& civector::operator|=(const srvector& v2) {
2637 return fsp_vv_hullassign(*this,v2);
2638}
2639
2640inline civector& civector::operator|=(const scvector& v2) {
2641 return fsp_vv_hullassign(*this,v2);
2642}
2643
2644inline civector& civector::operator|=(const sivector& v2) {
2645 return fsp_vv_hullassign(*this,v2);
2646}
2647
2648inline civector& civector::operator|=(const scivector& v2) {
2649 return fsp_vv_hullassign(*this,v2);
2650}
2651
2652inline civector_slice& civector_slice::operator|=(const srvector& v2) {
2653 return fsp_vv_hullassign(*this,v2);
2654}
2655
2656inline civector_slice& civector_slice::operator|=(const scvector& v2) {
2657 return fsp_vv_hullassign(*this,v2);
2658}
2659
2660inline civector_slice& civector_slice::operator|=(const sivector& v2) {
2661 return fsp_vv_hullassign(*this,v2);
2662}
2663
2664inline civector_slice& civector_slice::operator|=(const scivector& v2) {
2665 return fsp_vv_hullassign(*this,v2);
2666}
2667
2668inline civector& civector::operator&=(const sivector& v2) {
2669 return fsp_vv_intersectassign(*this,v2);
2670}
2671
2672inline civector& civector::operator&=(const scivector& v2) {
2673 return fsp_vv_intersectassign(*this,v2);
2674}
2675
2676inline civector_slice& civector_slice::operator&=(const sivector& v2) {
2677 return fsp_vv_intersectassign(*this,v2);
2678}
2679
2680inline civector_slice& civector_slice::operator&=(const scivector& v2) {
2681 return fsp_vv_intersectassign(*this,v2);
2682}
2683
2685
2688inline bool operator==(const scivector& v1, const scivector& v2) {
2689 return spsp_vv_comp(v1,v2);
2690}
2691
2693
2696inline bool operator==(const scivector& v1, const srvector& v2) {
2697 return spsp_vv_comp(v1,v2);
2698}
2699
2701
2704inline bool operator==(const scivector& v1, const sivector& v2) {
2705 return spsp_vv_comp(v1,v2);
2706}
2707
2709
2712inline bool operator==(const scivector& v1, const scvector& v2) {
2713 return spsp_vv_comp(v1,v2);
2714}
2715
2717
2720inline bool operator==(const srvector& v1, const scivector& v2) {
2721 return spsp_vv_comp(v1,v2);
2722}
2723
2725
2728inline bool operator==(const scvector& v1, const scivector& v2) {
2729 return spsp_vv_comp(v1,v2);
2730}
2731
2733
2736inline bool operator==(const sivector& v1, const scivector& v2) {
2737 return spsp_vv_comp(v1,v2);
2738}
2739
2741
2744inline bool operator==(const scivector& v1, const rvector& v2) {
2745 return spf_vv_comp(v1,v2);
2746}
2747
2749
2752inline bool operator==(const scivector& v1, const cvector& v2) {
2753 return spf_vv_comp(v1,v2);
2754}
2755
2757
2760inline bool operator==(const scivector& v1, const ivector& v2) {
2761 return spf_vv_comp(v1,v2);
2762}
2763
2765
2768inline bool operator==(const scivector& v1, const civector& v2) {
2769 return spf_vv_comp(v1,v2);
2770}
2771
2773
2776inline bool operator==(const srvector& v1, const civector& v2) {
2777 return spf_vv_comp(v1,v2);
2778}
2779
2781
2784inline bool operator==(const scvector& v1, const civector& v2) {
2785 return spf_vv_comp(v1,v2);
2786}
2787
2789
2792inline bool operator==(const sivector& v1, const civector& v2) {
2793 return spf_vv_comp(v1,v2);
2794}
2795
2797
2800inline bool operator==(const civector& v1, const srvector& v2) {
2801 return fsp_vv_comp(v1,v2);
2802}
2803
2805
2808inline bool operator==(const civector& v1, const scvector& v2) {
2809 return fsp_vv_comp(v1,v2);
2810}
2811
2813
2816inline bool operator==(const civector& v1, const sivector& v2) {
2817 return fsp_vv_comp(v1,v2);
2818}
2819
2821
2824inline bool operator==(const civector& v1, const scivector& v2) {
2825 return fsp_vv_comp(v1,v2);
2826}
2827
2829
2832inline bool operator==(const rvector& v1, const scivector& v2) {
2833 return fsp_vv_comp(v1,v2);
2834}
2835
2837
2840inline bool operator==(const cvector& v1, const scivector& v2) {
2841 return fsp_vv_comp(v1,v2);
2842}
2843
2845
2848inline bool operator==(const ivector& v1, const scivector& v2) {
2849 return fsp_vv_comp(v1,v2);
2850}
2851
2853
2856inline bool operator==(const scivector& v1, const rvector_slice& v2) {
2857 return spf_vv_comp(v1,v2);
2858}
2859
2861
2864inline bool operator==(const scivector& v1, const ivector_slice& v2) {
2865 return spf_vv_comp(v1,v2);
2866}
2867
2869
2872inline bool operator==(const scivector& v1, const cvector_slice& v2) {
2873 return spf_vv_comp(v1,v2);
2874}
2875
2877
2880inline bool operator==(const srvector& v1, const civector_slice& v2) {
2881 return spf_vv_comp(v1,v2);
2882}
2883
2885
2888inline bool operator==(const scvector& v1, const civector_slice& v2) {
2889 return spf_vv_comp(v1,v2);
2890}
2891
2893
2896inline bool operator==(const sivector& v1, const civector_slice& v2) {
2897 return spf_vv_comp(v1,v2);
2898}
2899
2901
2904inline bool operator==(const scivector& v1, const civector_slice& v2) {
2905 return spf_vv_comp(v1,v2);
2906}
2907
2909
2912inline bool operator==(const civector_slice& v1, const srvector& v2) {
2913 return fsp_vv_comp(v1,v2);
2914}
2915
2917
2920inline bool operator==(const civector_slice& v1, const sivector& v2) {
2921 return fsp_vv_comp(v1,v2);
2922}
2923
2925
2928inline bool operator==(const civector_slice& v1, const scvector& v2) {
2929 return fsp_vv_comp(v1,v2);
2930}
2931
2933
2936inline bool operator==(const rvector_slice& v1, const scivector& v2) {
2937 return fsp_vv_comp(v1,v2);
2938}
2939
2941
2944inline bool operator==(const ivector_slice& v1, const scivector& v2) {
2945 return fsp_vv_comp(v1,v2);
2946}
2947
2949
2952inline bool operator==(const cvector_slice& v1, const scivector& v2) {
2953 return fsp_vv_comp(v1,v2);
2954}
2955
2957
2960inline bool operator==(const civector_slice& v1, const scivector& v2) {
2961 return fsp_vv_comp(v1,v2);
2962}
2963
2965
2968inline bool operator!=(const scivector& v1, const scivector& v2) {
2969 return !spsp_vv_comp(v1,v2);
2970}
2971
2973
2976inline bool operator!=(const scivector& v1, const srvector& v2) {
2977 return !spsp_vv_comp(v1,v2);
2978}
2979
2981
2984inline bool operator!=(const scivector& v1, const sivector& v2) {
2985 return !spsp_vv_comp(v1,v2);
2986}
2987
2989
2992inline bool operator!=(const scivector& v1, const scvector& v2) {
2993 return !spsp_vv_comp(v1,v2);
2994}
2995
2997
3000inline bool operator!=(const srvector& v1, const scivector& v2) {
3001 return !spsp_vv_comp(v1,v2);
3002}
3003
3005
3008inline bool operator!=(const scvector& v1, const scivector& v2) {
3009 return !spsp_vv_comp(v1,v2);
3010}
3011
3013
3016inline bool operator!=(const sivector& v1, const scivector& v2) {
3017 return !spsp_vv_comp(v1,v2);
3018}
3019
3021
3024inline bool operator!=(const scivector& v1, const rvector& v2) {
3025 return !spf_vv_comp(v1,v2);
3026}
3027
3029
3032inline bool operator!=(const scivector& v1, const cvector& v2) {
3033 return !spf_vv_comp(v1,v2);
3034}
3035
3037
3040inline bool operator!=(const scivector& v1, const ivector& v2) {
3041 return !spf_vv_comp(v1,v2);
3042}
3043
3045
3048inline bool operator!=(const scivector& v1, const civector& v2) {
3049 return !spf_vv_comp(v1,v2);
3050}
3051
3053
3056inline bool operator!=(const srvector& v1, const civector& v2) {
3057 return !spf_vv_comp(v1,v2);
3058}
3059
3061
3064inline bool operator!=(const scvector& v1, const civector& v2) {
3065 return !spf_vv_comp(v1,v2);
3066}
3067
3069
3072inline bool operator!=(const sivector& v1, const civector& v2) {
3073 return !spf_vv_comp(v1,v2);
3074}
3075
3077
3080inline bool operator!=(const civector& v1, const srvector& v2) {
3081 return !fsp_vv_comp(v1,v2);
3082}
3083
3085
3088inline bool operator!=(const civector& v1, const sivector& v2) {
3089 return !fsp_vv_comp(v1,v2);
3090}
3091
3093
3096inline bool operator!=(const civector& v1, const scivector& v2) {
3097 return !fsp_vv_comp(v1,v2);
3098}
3099
3101
3104inline bool operator!=(const rvector& v1, const scivector& v2) {
3105 return !fsp_vv_comp(v1,v2);
3106}
3107
3109
3112inline bool operator!=(const cvector& v1, const scivector& v2) {
3113 return !fsp_vv_comp(v1,v2);
3114}
3115
3117
3120inline bool operator!=(const ivector& v1, const scivector& v2) {
3121 return !fsp_vv_comp(v1,v2);
3122}
3123
3125
3128inline bool operator!=(const scivector& v1, const rvector_slice& v2) {
3129 return !spf_vv_comp(v1,v2);
3130}
3131
3133
3136inline bool operator!=(const scivector& v1, const ivector_slice& v2) {
3137 return !spf_vv_comp(v1,v2);
3138}
3139
3141
3144inline bool operator!=(const scivector& v1, const cvector_slice& v2) {
3145 return !spf_vv_comp(v1,v2);
3146}
3147
3149
3152inline bool operator!=(const srvector& v1, const civector_slice& v2) {
3153 return !spf_vv_comp(v1,v2);
3154}
3155
3157
3160inline bool operator!=(const scvector& v1, const civector_slice& v2) {
3161 return !spf_vv_comp(v1,v2);
3162}
3163
3165
3168inline bool operator!=(const sivector& v1, const civector_slice& v2) {
3169 return !spf_vv_comp(v1,v2);
3170}
3171
3173
3176inline bool operator!=(const scivector& v1, const civector_slice& v2) {
3177 return !spf_vv_comp(v1,v2);
3178}
3179
3181
3184inline bool operator!=(const civector_slice& v1, const srvector& v2) {
3185 return !fsp_vv_comp(v1,v2);
3186}
3187
3189
3192inline bool operator!=(const civector_slice& v1, const sivector& v2) {
3193 return !fsp_vv_comp(v1,v2);
3194}
3195
3197
3200inline bool operator!=(const civector_slice& v1, const scvector& v2) {
3201 return !fsp_vv_comp(v1,v2);
3202}
3203
3205
3208inline bool operator!=(const rvector_slice& v1, const scivector& v2) {
3209 return !fsp_vv_comp(v1,v2);
3210}
3211
3213
3216inline bool operator!=(const ivector_slice& v1, const scivector& v2) {
3217 return !fsp_vv_comp(v1,v2);
3218}
3219
3221
3224inline bool operator!=(const cvector_slice& v1, const scivector& v2) {
3225 return !fsp_vv_comp(v1,v2);
3226}
3227
3229
3232inline bool operator!=(const civector_slice& v1, const scivector& v2) {
3233 return !fsp_vv_comp(v1,v2);
3234}
3235
3237
3240inline bool operator<(const scivector& v1, const scivector& v2) {
3241 return spsp_vv_less<scivector,scivector,cinterval>(v1,v2);
3242}
3243
3245
3248inline bool operator<(const scivector& v1, const sivector& v2) {
3249 return spsp_vv_less<scivector,sivector,cinterval>(v1,v2);
3250}
3251
3253
3256inline bool operator<(const srvector& v1, const scivector& v2) {
3257 return spsp_vv_less<srvector,scivector,cinterval>(v1,v2);
3258}
3259
3261
3264inline bool operator<(const scvector& v1, const scivector& v2) {
3265 return spsp_vv_less<scvector,scivector,cinterval>(v1,v2);
3266}
3267
3269
3272inline bool operator<(const sivector& v1, const scivector& v2) {
3273 return spsp_vv_less<sivector,scivector,cinterval>(v1,v2);
3274}
3275
3277
3280inline bool operator<(const scivector& v1, const ivector& v2) {
3281 return spf_vv_less<scivector,ivector,cinterval>(v1,v2);
3282}
3283
3285
3288inline bool operator<(const scivector& v1, const civector& v2) {
3289 return spf_vv_less<scivector,civector,cinterval>(v1,v2);
3290}
3291
3293
3296inline bool operator<(const srvector& v1, const civector& v2) {
3297 return spf_vv_less<srvector,civector,cinterval>(v1,v2);
3298}
3299
3301
3304inline bool operator<(const scvector& v1, const civector& v2) {
3305 return spf_vv_less<scvector,civector,cinterval>(v1,v2);
3306}
3307
3309
3312inline bool operator<(const sivector& v1, const civector& v2) {
3313 return spf_vv_less<sivector,civector,cinterval>(v1,v2);
3314}
3315
3317
3320inline bool operator<(const civector& v1, const sivector& v2) {
3321 return fsp_vv_less<civector,sivector,cinterval>(v1,v2);
3322}
3323
3325
3328inline bool operator<(const civector& v1, const scivector& v2) {
3329 return fsp_vv_less<civector,scivector,cinterval>(v1,v2);
3330}
3331
3333
3336inline bool operator<(const rvector& v1, const scivector& v2) {
3337 return fsp_vv_less<rvector,scivector,cinterval>(v1,v2);
3338}
3339
3341
3344inline bool operator<(const cvector& v1, const scivector& v2) {
3345 return fsp_vv_less<cvector,scivector,cinterval>(v1,v2);
3346}
3347
3349
3352inline bool operator<(const ivector& v1, const scivector& v2) {
3353 return fsp_vv_less<ivector,scivector,cinterval>(v1,v2);
3354}
3355
3357
3360inline bool operator<(const scivector& v1, const ivector_slice& v2) {
3361 return spf_vv_less<scivector,ivector_slice,cinterval>(v1,v2);
3362}
3363
3365
3368inline bool operator<(const srvector& v1, const civector_slice& v2) {
3369 return spf_vv_less<srvector,civector_slice,cinterval>(v1,v2);
3370}
3371
3373
3376inline bool operator<(const scvector& v1, const civector_slice& v2) {
3377 return spf_vv_less<scvector,civector_slice,cinterval>(v1,v2);
3378}
3379
3381
3384inline bool operator<(const sivector& v1, const civector_slice& v2) {
3385 return spf_vv_less<sivector,civector_slice,cinterval>(v1,v2);
3386}
3387
3389
3392inline bool operator<(const scivector& v1, const civector_slice& v2) {
3393 return spf_vv_less<scivector,civector_slice,cinterval>(v1,v2);
3394}
3395
3397
3400inline bool operator<(const civector_slice& v1, const sivector& v2) {
3401 return fsp_vv_less<civector_slice,sivector,cinterval>(v1,v2);
3402}
3403
3405
3408inline bool operator<(const rvector_slice& v1, const scivector& v2) {
3409 return fsp_vv_less<rvector_slice,scivector,cinterval>(v1,v2);
3410}
3411
3413
3416inline bool operator<(const ivector_slice& v1, const scivector& v2) {
3417 return fsp_vv_less<ivector_slice,scivector,cinterval>(v1,v2);
3418}
3419
3421
3424inline bool operator<(const cvector_slice& v1, const scivector& v2) {
3425 return fsp_vv_less<cvector_slice,scivector,cinterval>(v1,v2);
3426}
3427
3429
3432inline bool operator<(const civector_slice& v1, const scivector& v2) {
3433 return fsp_vv_less<civector_slice,scivector,cinterval>(v1,v2);
3434}
3435
3437
3440inline bool operator<=(const scivector& v1, const scivector& v2) {
3441 return spsp_vv_leq<scivector,scivector,cinterval>(v1,v2);
3442}
3443
3445
3448inline bool operator<=(const scivector& v1, const sivector& v2) {
3449 return spsp_vv_leq<scivector,sivector,cinterval>(v1,v2);
3450}
3451
3453
3456inline bool operator<=(const srvector& v1, const scivector& v2) {
3457 return spsp_vv_leq<srvector,scivector,cinterval>(v1,v2);
3458}
3459
3461
3464inline bool operator<=(const scvector& v1, const scivector& v2) {
3465 return spsp_vv_leq<scvector,scivector,cinterval>(v1,v2);
3466}
3467
3469
3472inline bool operator<=(const sivector& v1, const scivector& v2) {
3473 return spsp_vv_leq<sivector,scivector,cinterval>(v1,v2);
3474}
3475
3477
3480inline bool operator<=(const scivector& v1, const ivector& v2) {
3481 return spf_vv_leq<scivector,ivector,cinterval>(v1,v2);
3482}
3483
3485
3488inline bool operator<=(const scivector& v1, const civector& v2) {
3489 return spf_vv_leq<scivector,civector,cinterval>(v1,v2);
3490}
3491
3493
3496inline bool operator<=(const srvector& v1, const civector& v2) {
3497 return spf_vv_leq<srvector,civector,cinterval>(v1,v2);
3498}
3499
3501
3504inline bool operator<=(const scvector& v1, const civector& v2) {
3505 return spf_vv_leq<scvector,civector,cinterval>(v1,v2);
3506}
3507
3509
3512inline bool operator<=(const sivector& v1, const civector& v2) {
3513 return spf_vv_leq<sivector,civector,cinterval>(v1,v2);
3514}
3515
3517
3520inline bool operator<=(const civector& v1, const sivector& v2) {
3521 return fsp_vv_leq<civector,sivector,cinterval>(v1,v2);
3522}
3523
3525
3528inline bool operator<=(const civector& v1, const scivector& v2) {
3529 return fsp_vv_leq<civector,scivector,cinterval>(v1,v2);
3530}
3531
3533
3536inline bool operator<=(const rvector& v1, const scivector& v2) {
3537 return fsp_vv_leq<rvector,scivector,cinterval>(v1,v2);
3538}
3539
3541
3544inline bool operator<=(const cvector& v1, const scivector& v2) {
3545 return fsp_vv_leq<cvector,scivector,cinterval>(v1,v2);
3546}
3547
3549
3552inline bool operator<=(const ivector& v1, const scivector& v2) {
3553 return fsp_vv_leq<ivector,scivector,cinterval>(v1,v2);
3554}
3555
3557
3560inline bool operator<=(const scivector& v1, const ivector_slice& v2) {
3561 return spf_vv_leq<scivector,ivector_slice,cinterval>(v1,v2);
3562}
3563
3565
3568inline bool operator<=(const srvector& v1, const civector_slice& v2) {
3569 return spf_vv_leq<srvector,civector_slice,cinterval>(v1,v2);
3570}
3571
3573
3576inline bool operator<=(const scvector& v1, const civector_slice& v2) {
3577 return spf_vv_leq<scvector,civector_slice,cinterval>(v1,v2);
3578}
3579
3581
3584inline bool operator<=(const sivector& v1, const civector_slice& v2) {
3585 return spf_vv_leq<sivector,civector_slice,cinterval>(v1,v2);
3586}
3587
3589
3592inline bool operator<=(const scivector& v1, const civector_slice& v2) {
3593 return spf_vv_leq<scivector,civector_slice,cinterval>(v1,v2);
3594}
3595
3597
3600inline bool operator<=(const civector_slice& v1, const sivector& v2) {
3601 return fsp_vv_leq<civector_slice,sivector,cinterval>(v1,v2);
3602}
3603
3605
3608inline bool operator<=(const rvector_slice& v1, const scivector& v2) {
3609 return fsp_vv_leq<rvector_slice,scivector,cinterval>(v1,v2);
3610}
3611
3613
3616inline bool operator<=(const ivector_slice& v1, const scivector& v2) {
3617 return fsp_vv_leq<ivector_slice,scivector,cinterval>(v1,v2);
3618}
3619
3621
3624inline bool operator<=(const cvector_slice& v1, const scivector& v2) {
3625 return fsp_vv_leq<cvector_slice,scivector,cinterval>(v1,v2);
3626}
3627
3629
3632inline bool operator<=(const civector_slice& v1, const scivector& v2) {
3633 return fsp_vv_leq<civector_slice,scivector,cinterval>(v1,v2);
3634}
3635
3637
3640inline bool operator>(const scivector& v1, const scivector& v2) {
3641 return spsp_vv_greater<scivector,scivector,cinterval>(v1,v2);
3642}
3643
3645
3648inline bool operator>(const scivector& v1, const srvector& v2) {
3649 return spsp_vv_greater<scivector,srvector,cinterval>(v1,v2);
3650}
3651
3653
3656inline bool operator>(const scivector& v1, const sivector& v2) {
3657 return spsp_vv_greater<scivector,sivector,cinterval>(v1,v2);
3658}
3659
3661
3664inline bool operator>(const scivector& v1, const scvector& v2) {
3665 return spsp_vv_greater<scivector,scvector,cinterval>(v1,v2);
3666}
3667
3669
3672inline bool operator>(const sivector& v1, const scivector& v2) {
3673 return spsp_vv_greater<sivector,scivector,cinterval>(v1,v2);
3674}
3675
3677
3680inline bool operator>(const scivector& v1, const rvector& v2) {
3681 return spf_vv_greater<scivector,rvector,cinterval>(v1,v2);
3682}
3683
3685
3688inline bool operator>(const scivector& v1, const cvector& v2) {
3689 return spf_vv_greater<scivector,cvector,cinterval>(v1,v2);
3690}
3691
3693
3696inline bool operator>(const scivector& v1, const ivector& v2) {
3697 return spf_vv_greater<scivector,ivector,cinterval>(v1,v2);
3698}
3699
3701
3704inline bool operator>(const scivector& v1, const civector& v2) {
3705 return spf_vv_greater<scivector,civector,cinterval>(v1,v2);
3706}
3707
3709
3712inline bool operator>(const sivector& v1, const civector& v2) {
3713 return spf_vv_greater<sivector,civector,cinterval>(v1,v2);
3714}
3715
3717
3720inline bool operator>(const civector& v1, const srvector& v2) {
3721 return fsp_vv_greater<civector,srvector,cinterval>(v1,v2);
3722}
3723
3725
3728inline bool operator>(const civector& v1, const scvector& v2) {
3729 return fsp_vv_greater<civector,scvector,cinterval>(v1,v2);
3730}
3731
3733
3736inline bool operator>(const civector& v1, const sivector& v2) {
3737 return fsp_vv_greater<civector,sivector,cinterval>(v1,v2);
3738}
3739
3741
3744inline bool operator>(const civector& v1, const scivector& v2) {
3745 return fsp_vv_greater<civector,scivector,cinterval>(v1,v2);
3746}
3747
3749
3752inline bool operator>(const ivector& v1, const scivector& v2) {
3753 return fsp_vv_greater<ivector,scivector,cinterval>(v1,v2);
3754}
3755
3757
3760inline bool operator>(const scivector& v1, const rvector_slice& v2) {
3761 return spf_vv_greater<scivector,rvector_slice,cinterval>(v1,v2);
3762}
3763
3765
3768inline bool operator>(const scivector& v1, const ivector_slice& v2) {
3769 return spf_vv_greater<scivector,ivector_slice,cinterval>(v1,v2);
3770}
3771
3773
3776inline bool operator>(const scivector& v1, const cvector_slice& v2) {
3777 return spf_vv_greater<scivector,cvector_slice,cinterval>(v1,v2);
3778}
3779
3781
3784inline bool operator>(const sivector& v1, const civector_slice& v2) {
3785 return spf_vv_greater<sivector,civector_slice,cinterval>(v1,v2);
3786}
3787
3789
3792inline bool operator>(const scivector& v1, const civector_slice& v2) {
3793 return spf_vv_greater<scivector,civector_slice,cinterval>(v1,v2);
3794}
3795
3797
3800inline bool operator>(const civector_slice& v1, const srvector& v2) {
3801 return fsp_vv_greater<civector_slice,srvector,cinterval>(v1,v2);
3802}
3803
3805
3808inline bool operator>(const civector_slice& v1, const sivector& v2) {
3809 return fsp_vv_greater<civector_slice,sivector,cinterval>(v1,v2);
3810}
3811
3813
3816inline bool operator>(const civector_slice& v1, const scvector& v2) {
3817 return fsp_vv_greater<civector_slice,scvector,cinterval>(v1,v2);
3818}
3819
3821
3824inline bool operator>(const ivector_slice& v1, const scivector& v2) {
3825 return fsp_vv_greater<ivector_slice,scivector,cinterval>(v1,v2);
3826}
3827
3829
3832inline bool operator>(const civector_slice& v1, const scivector& v2) {
3833 return fsp_vv_greater<civector_slice,scivector,cinterval>(v1,v2);
3834}
3835
3837
3840inline bool operator>=(const scivector& v1, const scivector& v2) {
3841 return spsp_vv_geq<scivector,scivector,cinterval>(v1,v2);
3842}
3843
3845
3848inline bool operator>=(const scivector& v1, const srvector& v2) {
3849 return spsp_vv_geq<scivector,srvector,cinterval>(v1,v2);
3850}
3851
3853
3856inline bool operator>=(const scivector& v1, const sivector& v2) {
3857 return spsp_vv_geq<scivector,sivector,cinterval>(v1,v2);
3858}
3859
3861
3864inline bool operator>=(const scivector& v1, const scvector& v2) {
3865 return spsp_vv_geq<scivector,scvector,cinterval>(v1,v2);
3866}
3867
3869
3872inline bool operator>=(const sivector& v1, const scivector& v2) {
3873 return spsp_vv_geq<sivector,scivector,cinterval>(v1,v2);
3874}
3875
3877
3880inline bool operator>=(const scivector& v1, const rvector& v2) {
3881 return spf_vv_geq<scivector,rvector,cinterval>(v1,v2);
3882}
3883
3885
3888inline bool operator>=(const scivector& v1, const cvector& v2) {
3889 return spf_vv_geq<scivector,cvector,cinterval>(v1,v2);
3890}
3891
3893
3896inline bool operator>=(const scivector& v1, const ivector& v2) {
3897 return spf_vv_geq<scivector,ivector,cinterval>(v1,v2);
3898}
3899
3901
3904inline bool operator>=(const scivector& v1, const civector& v2) {
3905 return spf_vv_geq<scivector,civector,cinterval>(v1,v2);
3906}
3907
3909
3912inline bool operator>=(const sivector& v1, const civector& v2) {
3913 return spf_vv_geq<sivector,civector,cinterval>(v1,v2);
3914}
3915
3917
3920inline bool operator>=(const civector& v1, const srvector& v2) {
3921 return fsp_vv_geq<civector,srvector,cinterval>(v1,v2);
3922}
3923
3925
3928inline bool operator>=(const civector& v1, const scvector& v2) {
3929 return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
3930}
3931
3933
3936inline bool operator>=(const civector& v1, const sivector& v2) {
3937 return fsp_vv_geq<civector,sivector,cinterval>(v1,v2);
3938}
3939
3941
3944inline bool operator>=(const civector& v1, const scivector& v2) {
3945 return fsp_vv_geq<civector,scivector,cinterval>(v1,v2);
3946}
3947
3949
3952inline bool operator>=(const ivector& v1, const scivector& v2) {
3953 return fsp_vv_geq<ivector,scivector,cinterval>(v1,v2);
3954}
3955
3957
3960inline bool operator>=(const scivector& v1, const rvector_slice& v2) {
3961 return spf_vv_geq<scivector,rvector_slice,cinterval>(v1,v2);
3962}
3963
3965
3968inline bool operator>=(const scivector& v1, const ivector_slice& v2) {
3969 return spf_vv_geq<scivector,ivector_slice,cinterval>(v1,v2);
3970}
3971
3973
3976inline bool operator>=(const scivector& v1, const cvector_slice& v2) {
3977 return spf_vv_geq<scivector,cvector_slice,cinterval>(v1,v2);
3978}
3979
3981
3984inline bool operator>=(const sivector& v1, const civector_slice& v2) {
3985 return spf_vv_geq<sivector,civector_slice,cinterval>(v1,v2);
3986}
3987
3989
3992inline bool operator>=(const scivector& v1, const civector_slice& v2) {
3993 return spf_vv_geq<scivector,civector_slice,cinterval>(v1,v2);
3994}
3995
3997
4000inline bool operator>=(const civector_slice& v1, const srvector& v2) {
4001 return fsp_vv_geq<civector_slice,srvector,cinterval>(v1,v2);
4002}
4003
4005
4008inline bool operator>=(const civector_slice& v1, const sivector& v2) {
4009 return fsp_vv_geq<civector_slice,sivector,cinterval>(v1,v2);
4010}
4011
4013
4016inline bool operator>=(const civector_slice& v1, const scvector& v2) {
4017 return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
4018}
4019
4021
4024inline bool operator>=(const ivector_slice& v1, const scivector& v2) {
4025 return fsp_vv_geq<ivector_slice,scivector,cinterval>(v1,v2);
4026}
4027
4029
4032inline bool operator>=(const civector_slice& v1, const scivector& v2) {
4033 return fsp_vv_geq<civector_slice,scivector,cinterval>(v1,v2);
4034}
4035
4037
4042inline std::ostream& operator<<(std::ostream& os, const scivector& v) {
4043 return sp_v_output<scivector,cinterval>(os,v);
4044}
4045
4047
4052inline std::istream& operator>>(std::istream& is, scivector& v) {
4053 return sp_v_input<scivector,cinterval>(is,v);
4054}
4055
4056
4058
4064 private:
4065 std::vector<int>& p;
4066 std::vector<cinterval>& x;
4067 scivector& orig;
4068 int start,end;
4069 int lb;
4070 int ub;
4071 int n;
4072 int nnz;
4073 int offset;
4074
4076
4080 scivector_slice(scivector& v, int l, int u) : p(v.p), x(v.x), orig(v), lb(l), ub(u), n(u-l+1) {
4081 int i;
4082
4083 for(i=0 ; i<v.get_nnz() && p[i]<lb-v.lb ; i++);
4084
4085 start = i;
4086
4087 for(i=start ; i<v.get_nnz() && p[i]<=ub-v.lb ; i++);
4088
4089 end = i-1;
4090
4091 nnz = end-start+1;
4092 offset = lb-v.lb;
4093 }
4094
4095 public:
4096
4098 int get_nnz() const {
4099 return nnz;
4100 }
4101
4103 real density() const {
4104 return (double)nnz/n;
4105 }
4106
4108
4112 cinterval& operator[](const int i) {
4113#if(CXSC_INDEX_CHECK)
4114 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator[](const int)"));
4115#endif
4116 int k;
4117
4118 for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
4119 if(p[k]-offset == i-lb)
4120 return x[k];
4121 }
4122
4123 p.insert(p.begin() + k, i-lb);
4124 x.insert(x.begin() + k, cinterval(0.0));
4125 end++;
4126
4127 return x[k];
4128 }
4129
4131
4135 cinterval operator[](const int i) const {
4136#if(CXSC_INDEX_CHECK)
4137 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator[](const int)"));
4138#endif
4139 return (*this)(i);
4140 }
4141
4143
4147 const cinterval operator()(const int i) const {
4148#if(CXSC_INDEX_CHECK)
4149 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator()(const int)"));
4150#endif
4151 cinterval r(0.0);
4152
4153 for(int k=start ; k<end && p[k]-start<=i-lb ; k++) {
4154 if(p[k]-start == i-lb)
4155 r = x[k];
4156 }
4157
4158 return r;
4159 }
4160
4163 return sl_vs_assign<scivector_slice,real,cinterval,std::vector<cinterval>::iterator>(*this,v);
4164 }
4165
4168 return sl_vs_assign<scivector_slice,complex,cinterval,std::vector<cinterval>::iterator>(*this,v);
4169 }
4170
4173 return sl_vs_assign<scivector_slice,interval,cinterval,std::vector<cinterval>::iterator>(*this,v);
4174 }
4175
4178 return sl_vs_assign<scivector_slice,cinterval,cinterval,std::vector<cinterval>::iterator>(*this,v);
4179 }
4180
4183 return slsl_vv_assign<scivector_slice,srvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4184 }
4185
4188 return slsl_vv_assign<scivector_slice,scvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4189 }
4190
4193 return slsl_vv_assign<scivector_slice,sivector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4194 }
4195
4198 return slsl_vv_assign<scivector_slice,scivector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4199 }
4200
4203 return slsp_vv_assign<scivector_slice,srvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4204 }
4205
4208 return slsp_vv_assign<scivector_slice,scvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4209 }
4210
4213 return slsp_vv_assign<scivector_slice,sivector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4214 }
4215
4218 return slsp_vv_assign<scivector_slice,scivector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4219 }
4220
4223 return slf_vv_assign<scivector_slice,rvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4224 }
4225
4228 return slf_vv_assign<scivector_slice,cvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4229 }
4230
4233 return slf_vv_assign<scivector_slice,ivector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4234 }
4235
4238 return slf_vv_assign<scivector_slice,civector,cinterval,std::vector<cinterval>::iterator>(*this,v);
4239 }
4240
4243 return slf_vv_assign<scivector_slice,rvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4244 }
4245
4248 return slf_vv_assign<scivector_slice,cvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4249 }
4250
4253 return slf_vv_assign<scivector_slice,ivector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4254 }
4255
4258 return slf_vv_assign<scivector_slice,civector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
4259 }
4260
4263 return sl_vs_multassign(*this,s);
4264 }
4265
4268 return sl_vs_multassign(*this,s);
4269 }
4270
4273 return sl_vs_multassign(*this,s);
4274 }
4275
4278 return sl_vs_multassign(*this,s);
4279 }
4280
4283 return sl_vs_divassign(*this,s);
4284 }
4285
4288 return sl_vs_divassign(*this,s);
4289 }
4292 return sl_vs_divassign(*this,s);
4293 }
4294
4297 return sl_vs_divassign(*this,s);
4298 }
4299
4302 return slf_vv_addassign<scivector_slice,rvector,cinterval>(*this,v);
4303 }
4304
4307 return slf_vv_addassign<scivector_slice,ivector,cinterval>(*this,v);
4308 }
4309
4312 return slf_vv_addassign<scivector_slice,cvector,cinterval>(*this,v);
4313 }
4314
4317 return slf_vv_addassign<scivector_slice,civector,cinterval>(*this,v);
4318 }
4319
4322 return slf_vv_addassign<scivector_slice,rvector_slice,cinterval>(*this,v);
4323 }
4324
4327 return slf_vv_addassign<scivector_slice,cvector_slice,cinterval>(*this,v);
4328 }
4329
4332 return slf_vv_addassign<scivector_slice,ivector_slice,cinterval>(*this,v);
4333 }
4334
4337 return slf_vv_addassign<scivector_slice,civector_slice,cinterval>(*this,v);
4338 }
4339
4342 return slsp_vv_addassign(*this,v);
4343 }
4344
4347 return slsp_vv_addassign(*this,v);
4348 }
4349
4352 return slsp_vv_addassign(*this,v);
4353 }
4354
4357 return slsp_vv_addassign(*this,v);
4358 }
4359
4362 return slsl_vv_addassign(*this,v);
4363 }
4364
4367 return slsl_vv_addassign(*this,v);
4368 }
4369
4372 return slsl_vv_addassign(*this,v);
4373 }
4374
4377 return slsl_vv_addassign(*this,v);
4378 }
4379
4382 return slf_vv_subassign<scivector_slice,rvector,cinterval>(*this,v);
4383 }
4384
4387 return slf_vv_subassign<scivector_slice,ivector,cinterval>(*this,v);
4388 }
4389
4392 return slf_vv_subassign<scivector_slice,cvector,cinterval>(*this,v);
4393 }
4394
4397 return slf_vv_subassign<scivector_slice,civector,cinterval>(*this,v);
4398 }
4399
4402 return slf_vv_subassign<scivector_slice,rvector_slice,cinterval>(*this,v);
4403 }
4404
4407 return slf_vv_subassign<scivector_slice,cvector_slice,cinterval>(*this,v);
4408 }
4409
4412 return slf_vv_subassign<scivector_slice,ivector_slice,cinterval>(*this,v);
4413 }
4414
4417 return slf_vv_subassign<scivector_slice,civector_slice,cinterval>(*this,v);
4418 }
4419
4422 return slsp_vv_subassign(*this,v);
4423 }
4424
4427 return slsp_vv_subassign(*this,v);
4428 }
4429
4432 return slsp_vv_subassign(*this,v);
4433 }
4434
4437 return slsp_vv_subassign(*this,v);
4438 }
4439
4442 return slsl_vv_subassign(*this,v);
4443 }
4444
4447 return slsl_vv_subassign(*this,v);
4448 }
4449
4452 return slsl_vv_subassign(*this,v);
4453 }
4454
4457 return slsl_vv_subassign(*this,v);
4458 }
4459
4462 return slf_vv_hullassign<scivector_slice,rvector,cinterval>(*this,v);
4463 }
4464
4467 return slf_vv_hullassign<scivector_slice,ivector,cinterval>(*this,v);
4468 }
4469
4472 return slf_vv_hullassign<scivector_slice,cvector,cinterval>(*this,v);
4473 }
4474
4477 return slf_vv_hullassign<scivector_slice,civector,cinterval>(*this,v);
4478 }
4479
4482 return slf_vv_hullassign<scivector_slice,rvector_slice,cinterval>(*this,v);
4483 }
4484
4487 return slf_vv_hullassign<scivector_slice,cvector_slice,cinterval>(*this,v);
4488 }
4489
4492 return slf_vv_hullassign<scivector_slice,ivector_slice,cinterval>(*this,v);
4493 }
4494
4497 return slf_vv_hullassign<scivector_slice,civector_slice,cinterval>(*this,v);
4498 }
4499
4502 return slsp_vv_hullassign(*this,v);
4503 }
4504
4507 return slsp_vv_hullassign(*this,v);
4508 }
4509
4512 return slsp_vv_hullassign(*this,v);
4513 }
4514
4517 return slsp_vv_hullassign(*this,v);
4518 }
4519
4522 return slsl_vv_hullassign(*this,v);
4523 }
4524
4527 return slsl_vv_hullassign(*this,v);
4528 }
4529
4532 return slsl_vv_hullassign(*this,v);
4533 }
4534
4537 return slsl_vv_hullassign(*this,v);
4538 }
4539
4542 return slf_vv_intersectassign<scivector_slice,ivector,cinterval>(*this,v);
4543 }
4544
4547 return slf_vv_intersectassign<scivector_slice,civector,cinterval>(*this,v);
4548 }
4549
4552 return slf_vv_intersectassign<scivector_slice,ivector_slice,cinterval>(*this,v);
4553 }
4554
4557 return slf_vv_intersectassign<scivector_slice,civector_slice,cinterval>(*this,v);
4558 }
4559
4562 return slsp_vv_intersectassign(*this,v);
4563 }
4564
4567 return slsp_vv_intersectassign(*this,v);
4568 }
4569
4572 return slsl_vv_intersectassign(*this,v);
4573 }
4574
4577 return slsl_vv_intersectassign(*this,v);
4578 }
4579
4580 friend int Lb(const scivector_slice&);
4581 friend int Ub(const scivector_slice&);
4582 friend sivector Re(const scivector_slice&);
4583 friend sivector Im(const scivector_slice&);
4584 friend scvector Inf(const scivector_slice&);
4585 friend scvector Sup(const scivector_slice&);
4586 friend srvector InfRe(const scivector_slice&);
4587 friend srvector InfIm(const scivector_slice&);
4588 friend srvector SupRe(const scivector_slice&);
4589 friend srvector SupIm(const scivector_slice&);
4590 friend sivector abs(const scivector_slice&);
4591 friend scivector conj(const scivector_slice&);
4592 friend scvector mid(const scivector_slice&);
4593 friend scvector diam(const scivector_slice&);
4594 friend int VecLen(const scivector_slice&);
4595
4596// friend srvector operator*(const srmatrix&, const srvector_slice&); //ok
4597// friend srvector operator*(const srmatrix_slice&, const srvector_slice&); //ok
4598
4599 friend class srvector;
4600 friend class scvector;
4601 friend class sivector;
4602 friend class scivector;
4603 friend class civector;
4604 friend class civector_slice;
4605
4606#include "vector_friend_declarations.inl"
4607};
4608
4610 l = v.lb;
4611 u = v.ub;
4612 size = v.n;
4613 dat = new cinterval[v.n];
4614 for(int i=0 ; i<v.n ; i++)
4615 dat[i] = 0.0;
4616 for(int i=v.start ; i<=v.end ; i++)
4617 dat[v.p[i]] = v.x[i];
4618}
4619
4621 l = v.lb;
4622 u = v.ub;
4623 size = v.n;
4624 dat = new cinterval[v.n];
4625 for(int i=0 ; i<v.n ; i++)
4626 dat[i] = 0.0;
4627 for(int i=v.start ; i<=v.end ; i++)
4628 dat[v.p[i]] = v.x[i];
4629}
4630
4632 l = v.lb;
4633 u = v.ub;
4634 size = v.n;
4635 dat = new cinterval[v.n];
4636 for(int i=0 ; i<v.n ; i++)
4637 dat[i] = 0.0;
4638 for(int i=v.start ; i<=v.end ; i++)
4639 dat[v.p[i]] = v.x[i];
4640}
4641
4643 l = v.lb;
4644 u = v.ub;
4645 size = v.n;
4646 dat = new cinterval[v.n];
4647 for(int i=0 ; i<v.n ; i++)
4648 dat[i] = 0.0;
4649 for(int i=v.start ; i<=v.end ; i++)
4650 dat[v.p[i]] = v.x[i];
4651}
4652
4654 *this = rvector(v);
4655 return *this;
4656}
4657
4659 *this = rvector(v);
4660 return *this;
4661}
4662
4664 *this = ivector(v);
4665 return *this;
4666}
4667
4669 *this = ivector(v);
4670 return *this;
4671}
4672
4674 *this = cvector(v);
4675 return *this;
4676}
4677
4679 *this = cvector(v);
4680 return *this;
4681}
4682
4684 *this = civector(v);
4685 return *this;
4686}
4687
4689 *this = civector(v);
4690 return *this;
4691}
4692
4693inline scivector::scivector(const srvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
4694 p.reserve(s.nnz);
4695 x.reserve(s.nnz);
4696
4697 for(int i=s.start ; i<=s.end ; i++) {
4698 p.push_back(s.p[i]-s.offset);
4699 x.push_back(cinterval(s.x[i]));
4700 }
4701
4702}
4703
4704inline scivector::scivector(const scvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
4705 p.reserve(s.nnz);
4706 x.reserve(s.nnz);
4707
4708 for(int i=s.start ; i<=s.end ; i++) {
4709 p.push_back(s.p[i]-s.offset);
4710 x.push_back(cinterval(s.x[i]));
4711 }
4712
4713}
4714
4715inline scivector::scivector(const sivector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
4716 p.reserve(s.nnz);
4717 x.reserve(s.nnz);
4718
4719 for(int i=s.start ; i<=s.end ; i++) {
4720 p.push_back(s.p[i]-s.offset);
4721 x.push_back(cinterval(s.x[i]));
4722 }
4723
4724}
4725
4726inline scivector::scivector(const scivector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
4727 p.reserve(s.nnz);
4728 x.reserve(s.nnz);
4729
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]);
4733 }
4734
4735}
4736
4738 return spsl_vv_assign<scivector,srvector_slice,cinterval>(*this,v);
4739}
4740
4742 return spsl_vv_assign<scivector,scvector_slice,cinterval>(*this,v);
4743}
4744
4746 return spsl_vv_assign<scivector,sivector_slice,cinterval>(*this,v);
4747}
4748
4750 return spsl_vv_assign<scivector,scivector_slice,cinterval>(*this,v);
4751}
4752
4753inline scivector_slice scivector::operator()(const int i, const int j) {
4754#if(CXSC_INDEX_CHECK)
4755 if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator()(const int, const int)"));
4756#endif
4757 return scivector_slice(*this,i,j);
4758}
4759
4761inline scivector operator-(const scivector_slice& v) {
4762 return sl_v_negative<scivector_slice,scivector>(v);
4763}
4764
4766inline int Lb(const scivector_slice& v) {
4767 return v.lb;
4768}
4769
4771inline int Ub(const scivector_slice& v) {
4772 return v.ub;
4773}
4774
4776inline sivector Re(const scivector_slice& v) {
4777 return Re(scivector(v));
4778}
4779
4781inline sivector Im(const scivector_slice& v) {
4782 return Im(scivector(v));
4783}
4784
4786inline scvector Inf(const scivector_slice& v) {
4787 return Inf(scivector(v));
4788}
4789
4791inline scvector Sup(const scivector_slice& v) {
4792 return Sup(scivector(v));
4793}
4794
4796inline srvector InfRe(const scivector_slice& v) {
4797 return InfRe(scivector(v));
4798}
4799
4801inline srvector InfIm(const scivector_slice& v) {
4802 return InfIm(scivector(v));
4803}
4804
4806inline srvector SupRe(const scivector_slice& v) {
4807 return SupRe(scivector(v));
4808}
4809
4811inline srvector SupIm(const scivector_slice& v) {
4812 return SupIm(scivector(v));
4813}
4814
4816inline scivector conj(const scivector_slice& v) {
4817 scivector res(v.n, v.nnz);
4818 res.lb = v.lb;
4819 res.ub = v.ub;
4820 res.p = v.p;
4821 for(int i=v.start ; i<=v.end ; i++)
4822 res.x.push_back(conj(v.x[i]));
4823 return res;
4824}
4825
4827inline sivector abs(const scivector_slice& v) {
4828 sivector res(v.n, v.nnz);
4829 res.lb = v.lb;
4830 res.ub = v.ub;
4831 res.p = v.p;
4832 for(int i=v.start ; i<=v.end ; i++)
4833 res.x.push_back(abs(v.x[i]));
4834 return res;
4835}
4836
4838inline scvector mid(const scivector_slice& v) {
4839 scvector res(v.n, v.nnz);
4840 res.lb = v.lb;
4841 res.ub = v.ub;
4842 res.p = v.p;
4843 for(int i=v.start ; i<=v.end ; i++)
4844 res.x.push_back(mid(v.x[i]));
4845 return res;
4846}
4847
4850 scvector res(v.n, v.nnz);
4851 res.lb = v.lb;
4852 res.ub = v.ub;
4853 res.p = v.p;
4854 for(int i=v.start ; i<v.end ; i++)
4855 res.x.push_back(diam(v.x[i]));
4856 return res;
4857}
4858
4860inline int VecLen(const scivector_slice& v) {
4861 return v.n;
4862}
4863
4865
4871inline cinterval operator*(const scivector_slice& v1, const rvector& v2) {
4872 return slf_vv_mult<scivector_slice,rvector,cinterval,sparse_cidot>(v1,v2);
4873}
4874
4876
4882inline cinterval operator*(const scivector_slice& v1, const cvector& v2) {
4883 return slf_vv_mult<scivector_slice,cvector,cinterval,sparse_cidot>(v1,v2);
4884}
4885
4887
4893inline cinterval operator*(const scivector_slice& v1, const ivector& v2) {
4894 return slf_vv_mult<scivector_slice,ivector,cinterval,sparse_cidot>(v1,v2);
4895}
4896
4898
4904inline cinterval operator*(const scivector_slice& v1, const civector& v2) {
4905 return slf_vv_mult<scivector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4906}
4907
4909
4915inline cinterval operator*(const srvector_slice& v1, const civector& v2) {
4916 return slf_vv_mult<srvector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4917}
4918
4920
4926inline cinterval operator*(const sivector_slice& v1, const civector& v2) {
4927 return slf_vv_mult<sivector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4928}
4929
4931
4937inline cinterval operator*(const scvector_slice& v1, const civector& v2) {
4938 return slf_vv_mult<scvector_slice,civector,cinterval,sparse_cidot>(v1,v2);
4939}
4940
4942
4948inline cinterval operator*(const scvector_slice& v1, const ivector& v2) {
4949 return slf_vv_mult<scvector_slice,ivector,cinterval,sparse_cidot>(v1,v2);
4950}
4951
4953
4959inline cinterval operator*(const sivector_slice& v1, const cvector& v2) {
4960 return slf_vv_mult<sivector_slice,cvector,cinterval,sparse_cidot>(v1,v2);
4961}
4962
4964
4970inline cinterval operator*(const civector& v1, const srvector_slice& v2) {
4971 return fsl_vv_mult<civector,srvector_slice,cinterval,sparse_cidot>(v1,v2);
4972}
4973
4975
4981inline cinterval operator*(const civector& v1, const scvector_slice& v2) {
4982 return fsl_vv_mult<civector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
4983}
4984
4986
4992inline cinterval operator*(const civector& v1, const sivector_slice& v2) {
4993 return fsl_vv_mult<civector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
4994}
4995
4997
5003inline cinterval operator*(const civector& v1, const scivector_slice& v2) {
5004 return fsl_vv_mult<civector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5005}
5006
5008
5014inline cinterval operator*(const rvector& v1, const scivector_slice& v2) {
5015 return fsl_vv_mult<rvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5016}
5017
5019
5025inline cinterval operator*(const cvector& v1, const scivector_slice& v2) {
5026 return fsl_vv_mult<cvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5027}
5028
5030
5036inline cinterval operator*(const ivector& v1, const scivector_slice& v2) {
5037 return fsl_vv_mult<ivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5038}
5039
5041
5047inline cinterval operator*(const cvector& v1, const sivector_slice& v2) {
5048 return fsl_vv_mult<cvector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5049}
5050
5052
5058inline cinterval operator*(const ivector& v1, const scvector_slice& v2) {
5059 return fsl_vv_mult<ivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5060}
5061
5063
5069inline cinterval operator*(const scivector_slice& v1, const rvector_slice& v2) {
5070 return slf_vv_mult<scivector_slice,rvector_slice,cinterval,sparse_cidot>(v1,v2);
5071}
5072
5074
5080inline cinterval operator*(const scivector_slice& v1, const ivector_slice& v2) {
5081 return slf_vv_mult<scivector_slice,ivector_slice,cinterval,sparse_cidot>(v1,v2);
5082}
5083
5085
5091inline cinterval operator*(const scivector_slice& v1, const cvector_slice& v2) {
5092 return slf_vv_mult<scivector_slice,cvector_slice,cinterval,sparse_cidot>(v1,v2);
5093}
5094
5096
5103 return slf_vv_mult<scivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5104}
5105
5107
5113inline cinterval operator*(const srvector_slice& v1, const civector_slice& v2) {
5114 return slf_vv_mult<srvector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5115}
5116
5118
5124inline cinterval operator*(const scvector_slice& v1, const civector_slice& v2) {
5125 return slf_vv_mult<scvector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5126}
5127
5129
5135inline cinterval operator*(const sivector_slice& v1, const civector_slice& v2) {
5136 return slf_vv_mult<sivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5137}
5138
5140
5146inline cinterval operator*(const scvector_slice& v1, const ivector_slice& v2) {
5147 return slf_vv_mult<scvector_slice,ivector_slice,cinterval,sparse_cidot>(v1,v2);
5148}
5149
5151
5157inline cinterval operator*(const sivector_slice& v1, const cvector_slice& v2) {
5158 return slf_vv_mult<sivector_slice,cvector_slice,cinterval,sparse_cidot>(v1,v2);
5159}
5160
5162
5168inline cinterval operator*(const civector_slice& v1, const srvector_slice& v2) {
5169 return fsl_vv_mult<civector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5170}
5171
5173
5179inline cinterval operator*(const civector_slice& v1, const scvector_slice& v2) {
5180 return fsl_vv_mult<civector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5181}
5182
5184
5190inline cinterval operator*(const civector_slice& v1, const sivector_slice& v2) {
5191 return fsl_vv_mult<civector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5192}
5193
5195
5202 return fsl_vv_mult<civector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5203}
5204
5206
5212inline cinterval operator*(const rvector_slice& v1, const scivector_slice& v2) {
5213 return fsl_vv_mult<rvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5214}
5215
5217
5223inline cinterval operator*(const ivector_slice& v1, const scivector_slice& v2) {
5224 return fsl_vv_mult<ivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5225}
5226
5228
5234inline cinterval operator*(const cvector_slice& v1, const scivector_slice& v2) {
5235 return fsl_vv_mult<cvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5236}
5237
5239
5245inline cinterval operator*(const cvector_slice& v1, const sivector_slice& v2) {
5246 return fsl_vv_mult<cvector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5247}
5248
5250
5256inline cinterval operator*(const ivector_slice& v1, const scvector_slice& v2) {
5257 return fsl_vv_mult<ivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5258}
5259
5261
5267inline cinterval operator*(const scivector& v1, const srvector_slice& v2) {
5268 return spsl_vv_mult<scivector,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5269}
5270
5272
5278inline cinterval operator*(const scivector& v1, const scvector_slice& v2) {
5279 return spsl_vv_mult<scivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5280}
5281
5283
5289inline cinterval operator*(const scivector& v1, const sivector_slice& v2) {
5290 return spsl_vv_mult<scivector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5291}
5292
5294
5300inline cinterval operator*(const scivector& v1, const scivector_slice& v2) {
5301 return spsl_vv_mult<scivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5302}
5303
5305
5311inline cinterval operator*(const srvector& v1, const scivector_slice& v2) {
5312 return spsl_vv_mult<srvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5313}
5314
5316
5322inline cinterval operator*(const scvector& v1, const scivector_slice& v2) {
5323 return spsl_vv_mult<scvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5324}
5325
5327
5333inline cinterval operator*(const sivector& v1, const scivector_slice& v2) {
5334 return spsl_vv_mult<sivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5335}
5336
5338
5344inline cinterval operator*(const scvector& v1, const sivector_slice& v2) {
5345 return spsl_vv_mult<scvector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5346}
5347
5349
5355inline cinterval operator*(const sivector& v1, const scvector_slice& v2) {
5356 return spsl_vv_mult<sivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5357}
5358
5360
5366inline cinterval operator*(const scivector_slice& v1, const srvector& v2) {
5367 return slsp_vv_mult<scivector_slice,srvector,cinterval,sparse_cidot>(v1,v2);
5368}
5369
5371
5377inline cinterval operator*(const scivector_slice& v1, const scvector& v2) {
5378 return slsp_vv_mult<scivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
5379}
5380
5382
5388inline cinterval operator*(const scivector_slice& v1, const sivector& v2) {
5389 return slsp_vv_mult<scivector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
5390}
5391
5393
5399inline cinterval operator*(const scivector_slice& v1, const scivector& v2) {
5400 return slsp_vv_mult<scivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5401}
5402
5404
5410inline cinterval operator*(const srvector_slice& v1, const scivector& v2) {
5411 return slsp_vv_mult<srvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5412}
5413
5415
5421inline cinterval operator*(const sivector_slice& v1, const scivector& v2) {
5422 return slsp_vv_mult<sivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5423}
5424
5426
5432inline cinterval operator*(const scvector_slice& v1, const scivector& v2) {
5433 return slsp_vv_mult<scvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
5434}
5435
5437
5443inline cinterval operator*(const scvector_slice& v1, const sivector& v2) {
5444 return slsp_vv_mult<scvector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
5445}
5446
5448
5454inline cinterval operator*(const sivector_slice& v1, const scvector& v2) {
5455 return slsp_vv_mult<sivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
5456}
5457
5459
5466 return slsl_vv_mult<scivector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5467}
5468
5470
5477 return slsl_vv_mult<scivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5478}
5479
5481
5488 return slsl_vv_mult<scivector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5489}
5490
5492
5499 return slsl_vv_mult<scivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5500}
5501
5503
5510 return slsl_vv_mult<srvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5511}
5512
5514
5521 return slsl_vv_mult<scvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5522}
5523
5525
5532 return slsl_vv_mult<sivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5533}
5534
5536
5542inline cinterval operator*(const sivector_slice& v1, const scvector_slice& v2) {
5543 return slsl_vv_mult<sivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5544}
5545
5547
5553inline cinterval operator*(const scvector_slice& v1, const sivector_slice& v2) {
5554 return slsl_vv_mult<scvector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5555}
5556
5558inline scivector operator*(const scivector_slice& v, const real& s) {
5559 return sp_vs_mult<scivector_slice,real,scivector>(v,s);
5560}
5561
5563inline scivector operator*(const scivector_slice& v, const complex& s) {
5564 return sp_vs_mult<scivector_slice,complex,scivector>(v,s);
5565}
5566
5568inline scivector operator*(const scivector_slice& v, const interval& s) {
5569 return sp_vs_mult<scivector_slice,interval,scivector>(v,s);
5570}
5571
5573inline scivector operator*(const scivector_slice& v, const cinterval& s) {
5574 return sp_vs_mult<scivector_slice,cinterval,scivector>(v,s);
5575}
5576
5578inline scivector operator*(const srvector_slice& v, const cinterval& s) {
5579 return sp_vs_mult<srvector_slice,cinterval,scivector>(v,s);
5580}
5581
5583inline scivector operator*(const scvector_slice& v, const cinterval& s) {
5584 return sp_vs_mult<scvector_slice,cinterval,scivector>(v,s);
5585}
5586
5588inline scivector operator*(const sivector_slice& v, const cinterval& s) {
5589 return sp_vs_mult<sivector_slice,cinterval,scivector>(v,s);
5590}
5591
5593inline scivector operator*(const scvector_slice& v, const interval& s) {
5594 return sp_vs_mult<scvector_slice,interval,scivector>(v,s);
5595}
5596
5598inline scivector operator*(const sivector_slice& v, const complex& s) {
5599 return sp_vs_mult<sivector_slice,complex,scivector>(v,s);
5600}
5601
5603inline scivector operator/(const scivector_slice& v, const real& s) {
5604 return sp_vs_div<scivector_slice,real,scivector>(v,s);
5605}
5606
5608inline scivector operator/(const scivector_slice& v, const complex& s) {
5609 return sp_vs_div<scivector_slice,complex,scivector>(v,s);
5610}
5611
5613inline scivector operator/(const scivector_slice& v, const interval& s) {
5614 return sp_vs_div<scivector_slice,interval,scivector>(v,s);
5615}
5616
5618inline scivector operator/(const scivector_slice& v, const cinterval& s) {
5619 return sp_vs_div<scivector_slice,cinterval,scivector>(v,s);
5620}
5621
5623inline scivector operator/(const srvector_slice& v, const cinterval& s) {
5624 return sp_vs_div<srvector_slice,cinterval,scivector>(v,s);
5625}
5626
5628inline scivector operator/(const scvector_slice& v, const cinterval& s) {
5629 return sp_vs_div<scvector_slice,cinterval,scivector>(v,s);
5630}
5631
5633inline scivector operator/(const sivector_slice& v, const cinterval& s) {
5634 return sp_vs_div<sivector_slice,cinterval,scivector>(v,s);
5635}
5636
5638inline scivector operator/(const scvector_slice& v, const interval& s) {
5639 return sp_vs_div<scvector_slice,interval,scivector>(v,s);
5640}
5641
5643inline scivector operator/(const sivector_slice& v, const complex& s) {
5644 return sp_vs_div<sivector_slice,complex,scivector>(v,s);
5645}
5646
5648inline scivector operator*(const real& s, const scivector_slice& v) {
5649 return sp_sv_mult<real,scivector_slice,scivector>(s,v);
5650}
5651
5653inline scivector operator*(const complex& s, const scivector_slice& v) {
5654 return sp_sv_mult<complex,scivector_slice,scivector>(s,v);
5655}
5656
5658inline scivector operator*(const interval& s, const scivector_slice& v) {
5659 return sp_sv_mult<interval,scivector_slice,scivector>(s,v);
5660}
5661
5663inline scivector operator*(const cinterval& s, const scivector_slice& v) {
5664 return sp_sv_mult<cinterval,scivector_slice,scivector>(s,v);
5665}
5666
5668inline scivector operator*(const cinterval& s, const srvector_slice& v) {
5669 return sp_sv_mult<cinterval,srvector_slice,scivector>(s,v);
5670}
5671
5673inline scivector operator*(const cinterval& s, const scvector_slice& v) {
5674 return sp_sv_mult<cinterval,scvector_slice,scivector>(s,v);
5675}
5676
5678inline scivector operator*(const cinterval& s, const sivector_slice& v) {
5679 return sp_sv_mult<cinterval,sivector_slice,scivector>(s,v);
5680}
5681
5683inline scivector operator*(const complex& s, const sivector_slice& v) {
5684 return sp_sv_mult<complex,sivector_slice,scivector>(s,v);
5685}
5686
5688inline scivector operator*(const interval& s, const scvector_slice& v) {
5689 return sp_sv_mult<interval,scvector_slice,scivector>(s,v);
5690}
5691
5693inline civector operator+(const civector& v1, const srvector_slice& v2) {
5694 return fsl_vv_add<civector,srvector_slice,civector>(v1,v2);
5695}
5696
5698inline civector operator+(const civector& v1, const scvector_slice& v2) {
5699 return fsl_vv_add<civector,scvector_slice,civector>(v1,v2);
5700}
5701
5703inline civector operator+(const civector& v1, const sivector_slice& v2) {
5704 return fsl_vv_add<civector,sivector_slice,civector>(v1,v2);
5705}
5706
5708inline civector operator+(const civector& v1, const scivector_slice& v2) {
5709 return fsl_vv_add<civector,scivector_slice,civector>(v1,v2);
5710}
5711
5713inline civector operator+(const rvector& v1, const scivector_slice& v2) {
5714 return fsl_vv_add<rvector,scivector_slice,civector>(v1,v2);
5715}
5716
5718inline civector operator+(const cvector& v1, const scivector_slice& v2) {
5719 return fsl_vv_add<cvector,scivector_slice,civector>(v1,v2);
5720}
5721
5723inline civector operator+(const ivector& v1, const scivector_slice& v2) {
5724 return fsl_vv_add<ivector,scivector_slice,civector>(v1,v2);
5725}
5726
5728inline civector operator+(const cvector& v1, const sivector_slice& v2) {
5729 return fsl_vv_add<cvector,sivector_slice,civector>(v1,v2);
5730}
5731
5733inline civector operator+(const ivector& v1, const scvector_slice& v2) {
5734 return fsl_vv_add<ivector,scvector_slice,civector>(v1,v2);
5735}
5736
5738inline civector operator+(const scivector_slice& v1, const rvector& v2) {
5739 return slf_vv_add<scivector_slice,rvector,civector>(v1,v2);
5740}
5741
5743inline civector operator+(const scivector_slice& v1, const cvector& v2) {
5744 return slf_vv_add<scivector_slice,cvector,civector>(v1,v2);
5745}
5746
5748inline civector operator+(const scivector_slice& v1, const ivector& v2) {
5749 return slf_vv_add<scivector_slice,ivector,civector>(v1,v2);
5750}
5751
5753inline civector operator+(const scivector_slice& v1, const civector& v2) {
5754 return slf_vv_add<scivector_slice,civector,civector>(v1,v2);
5755}
5756
5758inline civector operator+(const srvector_slice& v1, const civector& v2) {
5759 return slf_vv_add<srvector_slice,civector,civector>(v1,v2);
5760}
5761
5763inline civector operator+(const scvector_slice& v1, const civector& v2) {
5764 return slf_vv_add<scvector_slice,civector,civector>(v1,v2);
5765}
5766
5768inline civector operator+(const sivector_slice& v1, const civector& v2) {
5769 return slf_vv_add<sivector_slice,civector,civector>(v1,v2);
5770}
5771
5773inline civector operator+(const scvector_slice& v1, const ivector& v2) {
5774 return slf_vv_add<scvector_slice,ivector,civector>(v1,v2);
5775}
5776
5778inline civector operator+(const sivector_slice& v1, const cvector& v2) {
5779 return slf_vv_add<sivector_slice,cvector,civector>(v1,v2);
5780}
5781
5783inline civector operator+(const civector_slice& v1, const srvector_slice& v2) {
5784 return fsl_vv_add<civector_slice,srvector_slice,civector>(v1,v2);
5785}
5786
5788inline civector operator+(const civector_slice& v1, const scvector_slice& v2) {
5789 return fsl_vv_add<civector_slice,scvector_slice,civector>(v1,v2);
5790}
5791
5793inline civector operator+(const civector_slice& v1, const sivector_slice& v2) {
5794 return fsl_vv_add<civector_slice,sivector_slice,civector>(v1,v2);
5795}
5796
5798inline civector operator+(const civector_slice& v1, const scivector_slice& v2) {
5799 return fsl_vv_add<civector_slice,scivector_slice,civector>(v1,v2);
5800}
5801
5803inline civector operator+(const rvector_slice& v1, const scivector_slice& v2) {
5804 return fsl_vv_add<rvector_slice,scivector_slice,civector>(v1,v2);
5805}
5806
5808inline civector operator+(const cvector_slice& v1, const scivector_slice& v2) {
5809 return fsl_vv_add<cvector_slice,scivector_slice,civector>(v1,v2);
5810}
5811
5813inline civector operator+(const ivector_slice& v1, const scivector_slice& v2) {
5814 return fsl_vv_add<ivector_slice,scivector_slice,civector>(v1,v2);
5815}
5816
5818inline civector operator+(const ivector_slice& v1, const scvector_slice& v2) {
5819 return fsl_vv_add<ivector_slice,scvector_slice,civector>(v1,v2);
5820}
5821
5823inline civector operator+(const cvector_slice& v1, const sivector_slice& v2) {
5824 return fsl_vv_add<cvector_slice,sivector_slice,civector>(v1,v2);
5825}
5826
5828inline civector operator+(const scivector_slice& v1, const rvector_slice& v2) {
5829 return slf_vv_add<scivector_slice,rvector_slice,civector>(v1,v2);
5830}
5831
5833inline civector operator+(const scivector_slice& v1, const ivector_slice& v2) {
5834 return slf_vv_add<scivector_slice,ivector_slice,civector>(v1,v2);
5835}
5836
5838inline civector operator+(const scivector_slice& v1, const cvector_slice& v2) {
5839 return slf_vv_add<scivector_slice,cvector_slice,civector>(v1,v2);
5840}
5841
5843inline civector operator+(const scivector_slice& v1, const civector_slice& v2) {
5844 return slf_vv_add<scivector_slice,civector_slice,civector>(v1,v2);
5845}
5846
5848inline civector operator+(const srvector_slice& v1, const civector_slice& v2) {
5849 return slf_vv_add<srvector_slice,civector_slice,civector>(v1,v2);
5850}
5851
5853inline civector operator+(const sivector_slice& v1, const civector_slice& v2) {
5854 return slf_vv_add<sivector_slice,civector_slice,civector>(v1,v2);
5855}
5856
5858inline civector operator+(const scvector_slice& v1, const civector_slice& v2) {
5859 return slf_vv_add<scvector_slice,civector_slice,civector>(v1,v2);
5860}
5861
5863inline civector operator+(const scvector_slice& v1, const ivector_slice& v2) {
5864 return slf_vv_add<scvector_slice,ivector_slice,civector>(v1,v2);
5865}
5866
5868inline civector operator+(const sivector_slice& v1, const cvector_slice& v2) {
5869 return slf_vv_add<sivector_slice,cvector_slice,civector>(v1,v2);
5870}
5871
5873inline scivector operator+(const scivector_slice& v1, const srvector_slice& v2) {
5874 return slsl_vv_add<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
5875}
5876
5878inline scivector operator+(const scivector_slice& v1, const scvector_slice& v2) {
5879 return slsl_vv_add<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
5880}
5881
5883inline scivector operator+(const scivector_slice& v1, const sivector_slice& v2) {
5884 return slsl_vv_add<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
5885}
5886
5888inline scivector operator+(const scivector_slice& v1, const scivector_slice& v2) {
5889 return slsl_vv_add<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5890}
5891
5893inline scivector operator+(const srvector_slice& v1, const scivector_slice& v2) {
5894 return slsl_vv_add<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5895}
5896
5898inline scivector operator+(const scvector_slice& v1, const scivector_slice& v2) {
5899 return slsl_vv_add<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5900}
5901
5903inline scivector operator+(const sivector_slice& v1, const scivector_slice& v2) {
5904 return slsl_vv_add<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
5905}
5906
5908inline scivector operator+(const scvector_slice& v1, const sivector_slice& v2) {
5909 return slsl_vv_add<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
5910}
5911
5913inline scivector operator+(const sivector_slice& v1, const scvector_slice& v2) {
5914 return slsl_vv_add<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
5915}
5916
5918inline scivector operator+(const scivector& v1, const srvector_slice& v2) {
5919 return spsl_vv_add<scivector,srvector_slice,scivector,cinterval>(v1,v2);
5920}
5921
5923inline scivector operator+(const scivector& v1, const scvector_slice& v2) {
5924 return spsl_vv_add<scivector,scvector_slice,scivector,cinterval>(v1,v2);
5925}
5926
5928inline scivector operator+(const scivector& v1, const sivector_slice& v2) {
5929 return spsl_vv_add<scivector,sivector_slice,scivector,cinterval>(v1,v2);
5930}
5931
5933inline scivector operator+(const scivector& v1, const scivector_slice& v2) {
5934 return spsl_vv_add<scivector,scivector_slice,scivector,cinterval>(v1,v2);
5935}
5936
5938inline scivector operator+(const srvector& v1, const scivector_slice& v2) {
5939 return spsl_vv_add<srvector,scivector_slice,scivector,cinterval>(v1,v2);
5940}
5941
5943inline scivector operator+(const scvector& v1, const scivector_slice& v2) {
5944 return spsl_vv_add<scvector,scivector_slice,scivector,cinterval>(v1,v2);
5945}
5946
5948inline scivector operator+(const sivector& v1, const scivector_slice& v2) {
5949 return spsl_vv_add<sivector,scivector_slice,scivector,cinterval>(v1,v2);
5950}
5951
5953inline scivector operator+(const scvector& v1, const sivector_slice& v2) {
5954 return spsl_vv_add<scvector,sivector_slice,scivector,cinterval>(v1,v2);
5955}
5956
5958inline scivector operator+(const sivector& v1, const scvector_slice& v2) {
5959 return spsl_vv_add<sivector,scvector_slice,scivector,cinterval>(v1,v2);
5960}
5961
5963inline scivector operator+(const scivector_slice& v1, const srvector& v2) {
5964 return slsp_vv_add<scivector_slice,srvector,scivector,cinterval>(v1,v2);
5965}
5966
5968inline scivector operator+(const scivector_slice& v1, const scvector& v2) {
5969 return slsp_vv_add<scivector_slice,scvector,scivector,cinterval>(v1,v2);
5970}
5971
5973inline scivector operator+(const scivector_slice& v1, const sivector& v2) {
5974 return slsp_vv_add<scivector_slice,sivector,scivector,cinterval>(v1,v2);
5975}
5976
5978inline scivector operator+(const scivector_slice& v1, const scivector& v2) {
5979 return slsp_vv_add<scivector_slice,scivector,scivector,cinterval>(v1,v2);
5980}
5981
5983inline scivector operator+(const srvector_slice& v1, const scivector& v2) {
5984 return slsp_vv_add<srvector_slice,scivector,scivector,cinterval>(v1,v2);
5985}
5986
5988inline scivector operator+(const scvector_slice& v1, const scivector& v2) {
5989 return slsp_vv_add<scvector_slice,scivector,scivector,cinterval>(v1,v2);
5990}
5991
5993inline scivector operator+(const sivector_slice& v1, const scivector& v2) {
5994 return slsp_vv_add<sivector_slice,scivector,scivector,cinterval>(v1,v2);
5995}
5996
5998inline scivector operator+(const scvector_slice& v1, const sivector& v2) {
5999 return slsp_vv_add<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6000}
6001
6003inline scivector operator+(const sivector_slice& v1, const scvector& v2) {
6004 return slsp_vv_add<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6005}
6006
6008inline civector operator-(const civector& v1, const srvector_slice& v2) {
6009 return fsl_vv_sub<civector,srvector_slice,civector>(v1,v2);
6010}
6011
6013inline civector operator-(const civector& v1, const scvector_slice& v2) {
6014 return fsl_vv_sub<civector,scvector_slice,civector>(v1,v2);
6015}
6016
6018inline civector operator-(const civector& v1, const sivector_slice& v2) {
6019 return fsl_vv_sub<civector,sivector_slice,civector>(v1,v2);
6020}
6021
6023inline civector operator-(const civector& v1, const scivector_slice& v2) {
6024 return fsl_vv_sub<civector,scivector_slice,civector>(v1,v2);
6025}
6026
6028inline civector operator-(const rvector& v1, const scivector_slice& v2) {
6029 return fsl_vv_sub<rvector,scivector_slice,civector>(v1,v2);
6030}
6031
6033inline civector operator-(const cvector& v1, const scivector_slice& v2) {
6034 return fsl_vv_sub<cvector,scivector_slice,civector>(v1,v2);
6035}
6036
6038inline civector operator-(const ivector& v1, const scivector_slice& v2) {
6039 return fsl_vv_sub<ivector,scivector_slice,civector>(v1,v2);
6040}
6041
6043inline civector operator-(const cvector& v1, const sivector_slice& v2) {
6044 return fsl_vv_sub<cvector,sivector_slice,civector>(v1,v2);
6045}
6046
6048inline civector operator-(const ivector& v1, const scvector_slice& v2) {
6049 return fsl_vv_sub<ivector,scvector_slice,civector>(v1,v2);
6050}
6051
6053inline civector operator-(const scivector_slice& v1, const rvector& v2) {
6054 return slf_vv_sub<scivector_slice,rvector,civector>(v1,v2);
6055}
6056
6058inline civector operator-(const scivector_slice& v1, const cvector& v2) {
6059 return slf_vv_sub<scivector_slice,cvector,civector>(v1,v2);
6060}
6061
6063inline civector operator-(const scivector_slice& v1, const ivector& v2) {
6064 return slf_vv_sub<scivector_slice,ivector,civector>(v1,v2);
6065}
6066
6068inline civector operator-(const scivector_slice& v1, const civector& v2) {
6069 return slf_vv_sub<scivector_slice,civector,civector>(v1,v2);
6070}
6071
6073inline civector operator-(const srvector_slice& v1, const civector& v2) {
6074 return slf_vv_sub<srvector_slice,civector,civector>(v1,v2);
6075}
6076
6078inline civector operator-(const scvector_slice& v1, const civector& v2) {
6079 return slf_vv_sub<scvector_slice,civector,civector>(v1,v2);
6080}
6081
6083inline civector operator-(const sivector_slice& v1, const civector& v2) {
6084 return slf_vv_sub<sivector_slice,civector,civector>(v1,v2);
6085}
6086
6088inline civector operator-(const scvector_slice& v1, const ivector& v2) {
6089 return slf_vv_sub<scvector_slice,ivector,civector>(v1,v2);
6090}
6091
6093inline civector operator-(const sivector_slice& v1, const cvector& v2) {
6094 return slf_vv_sub<sivector_slice,cvector,civector>(v1,v2);
6095}
6096
6098inline civector operator-(const civector_slice& v1, const srvector_slice& v2) {
6099 return fsl_vv_sub<civector_slice,srvector_slice,civector>(v1,v2);
6100}
6101
6103inline civector operator-(const civector_slice& v1, const scvector_slice& v2) {
6104 return fsl_vv_sub<civector_slice,scvector_slice,civector>(v1,v2);
6105}
6106
6108inline civector operator-(const civector_slice& v1, const sivector_slice& v2) {
6109 return fsl_vv_sub<civector_slice,sivector_slice,civector>(v1,v2);
6110}
6111
6113inline civector operator-(const civector_slice& v1, const scivector_slice& v2) {
6114 return fsl_vv_sub<civector_slice,scivector_slice,civector>(v1,v2);
6115}
6116
6118inline civector operator-(const rvector_slice& v1, const scivector_slice& v2) {
6119 return fsl_vv_sub<rvector_slice,scivector_slice,civector>(v1,v2);
6120}
6121
6123inline civector operator-(const cvector_slice& v1, const scivector_slice& v2) {
6124 return fsl_vv_sub<cvector_slice,scivector_slice,civector>(v1,v2);
6125}
6126
6128inline civector operator-(const ivector_slice& v1, const scivector_slice& v2) {
6129 return fsl_vv_sub<ivector_slice,scivector_slice,civector>(v1,v2);
6130}
6131
6133inline civector operator-(const ivector_slice& v1, const scvector_slice& v2) {
6134 return fsl_vv_sub<ivector_slice,scvector_slice,civector>(v1,v2);
6135}
6136
6138inline civector operator-(const cvector_slice& v1, const sivector_slice& v2) {
6139 return fsl_vv_sub<cvector_slice,sivector_slice,civector>(v1,v2);
6140}
6141
6143inline civector operator-(const scivector_slice& v1, const rvector_slice& v2) {
6144 return slf_vv_sub<scivector_slice,rvector_slice,civector>(v1,v2);
6145}
6146
6148inline civector operator-(const scivector_slice& v1, const ivector_slice& v2) {
6149 return slf_vv_sub<scivector_slice,ivector_slice,civector>(v1,v2);
6150}
6151
6153inline civector operator-(const scivector_slice& v1, const cvector_slice& v2) {
6154 return slf_vv_sub<scivector_slice,cvector_slice,civector>(v1,v2);
6155}
6156
6158inline civector operator-(const scivector_slice& v1, const civector_slice& v2) {
6159 return slf_vv_sub<scivector_slice,civector_slice,civector>(v1,v2);
6160}
6161
6163inline civector operator-(const srvector_slice& v1, const civector_slice& v2) {
6164 return slf_vv_sub<srvector_slice,civector_slice,civector>(v1,v2);
6165}
6166
6168inline civector operator-(const sivector_slice& v1, const civector_slice& v2) {
6169 return slf_vv_sub<sivector_slice,civector_slice,civector>(v1,v2);
6170}
6171
6173inline civector operator-(const scvector_slice& v1, const civector_slice& v2) {
6174 return slf_vv_sub<scvector_slice,civector_slice,civector>(v1,v2);
6175}
6176
6178inline civector operator-(const scvector_slice& v1, const ivector_slice& v2) {
6179 return slf_vv_sub<scvector_slice,ivector_slice,civector>(v1,v2);
6180}
6181
6183inline civector operator-(const sivector_slice& v1, const cvector_slice& v2) {
6184 return slf_vv_sub<sivector_slice,cvector_slice,civector>(v1,v2);
6185}
6186
6188inline scivector operator-(const scivector_slice& v1, const srvector_slice& v2) {
6189 return slsl_vv_sub<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
6190}
6191
6193inline scivector operator-(const scivector_slice& v1, const scvector_slice& v2) {
6194 return slsl_vv_sub<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6195}
6196
6198inline scivector operator-(const scivector_slice& v1, const sivector_slice& v2) {
6199 return slsl_vv_sub<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6200}
6201
6203inline scivector operator-(const scivector_slice& v1, const scivector_slice& v2) {
6204 return slsl_vv_sub<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6205}
6206
6208inline scivector operator-(const srvector_slice& v1, const scivector_slice& v2) {
6209 return slsl_vv_sub<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6210}
6211
6213inline scivector operator-(const scvector_slice& v1, const scivector_slice& v2) {
6214 return slsl_vv_sub<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6215}
6216
6218inline scivector operator-(const sivector_slice& v1, const scivector_slice& v2) {
6219 return slsl_vv_sub<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6220}
6221
6223inline scivector operator-(const scvector_slice& v1, const sivector_slice& v2) {
6224 return slsl_vv_sub<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6225}
6226
6228inline scivector operator-(const sivector_slice& v1, const scvector_slice& v2) {
6229 return slsl_vv_sub<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6230}
6231
6233inline scivector operator-(const scivector& v1, const srvector_slice& v2) {
6234 return spsl_vv_sub<scivector,srvector_slice,scivector,cinterval>(v1,v2);
6235}
6236
6238inline scivector operator-(const scivector& v1, const scvector_slice& v2) {
6239 return spsl_vv_sub<scivector,scvector_slice,scivector,cinterval>(v1,v2);
6240}
6241
6243inline scivector operator-(const scivector& v1, const sivector_slice& v2) {
6244 return spsl_vv_sub<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6245}
6246
6248inline scivector operator-(const scivector& v1, const scivector_slice& v2) {
6249 return spsl_vv_sub<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6250}
6251
6253inline scivector operator-(const srvector& v1, const scivector_slice& v2) {
6254 return spsl_vv_sub<srvector,scivector_slice,scivector,cinterval>(v1,v2);
6255}
6256
6258inline scivector operator-(const scvector& v1, const scivector_slice& v2) {
6259 return spsl_vv_sub<scvector,scivector_slice,scivector,cinterval>(v1,v2);
6260}
6261
6263inline scivector operator-(const sivector& v1, const scivector_slice& v2) {
6264 return spsl_vv_sub<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6265}
6266
6268inline scivector operator-(const scvector& v1, const sivector_slice& v2) {
6269 return spsl_vv_sub<scvector,sivector_slice,scivector,cinterval>(v1,v2);
6270}
6271
6273inline scivector operator-(const sivector& v1, const scvector_slice& v2) {
6274 return spsl_vv_sub<sivector,scvector_slice,scivector,cinterval>(v1,v2);
6275}
6276
6278inline scivector operator-(const scivector_slice& v1, const srvector& v2) {
6279 return slsp_vv_sub<scivector_slice,srvector,scivector,cinterval>(v1,v2);
6280}
6281
6283inline scivector operator-(const scivector_slice& v1, const scvector& v2) {
6284 return slsp_vv_sub<scivector_slice,scvector,scivector,cinterval>(v1,v2);
6285}
6286
6288inline scivector operator-(const scivector_slice& v1, const sivector& v2) {
6289 return slsp_vv_sub<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6290}
6291
6293inline scivector operator-(const scivector_slice& v1, const scivector& v2) {
6294 return slsp_vv_sub<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6295}
6296
6298inline scivector operator-(const srvector_slice& v1, const scivector& v2) {
6299 return slsp_vv_sub<srvector_slice,scivector,scivector,cinterval>(v1,v2);
6300}
6301
6303inline scivector operator-(const scvector_slice& v1, const scivector& v2) {
6304 return slsp_vv_sub<scvector_slice,scivector,scivector,cinterval>(v1,v2);
6305}
6306
6308inline scivector operator-(const sivector_slice& v1, const scivector& v2) {
6309 return slsp_vv_sub<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6310}
6311
6313inline scivector operator-(const scvector_slice& v1, const sivector& v2) {
6314 return slsp_vv_sub<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6315}
6316
6318inline scivector operator-(const sivector_slice& v1, const scvector& v2) {
6319 return slsp_vv_sub<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6320}
6321
6323inline civector operator|(const civector& v1, const srvector_slice& v2) {
6324 return fsl_vv_hull<civector,srvector_slice,civector>(v1,v2);
6325}
6326
6328inline civector operator|(const civector& v1, const scvector_slice& v2) {
6329 return fsl_vv_hull<civector,scvector_slice,civector>(v1,v2);
6330}
6331
6333inline civector operator|(const civector& v1, const sivector_slice& v2) {
6334 return fsl_vv_hull<civector,sivector_slice,civector>(v1,v2);
6335}
6336
6338inline civector operator|(const civector& v1, const scivector_slice& v2) {
6339 return fsl_vv_hull<civector,scivector_slice,civector>(v1,v2);
6340}
6341
6343inline civector operator|(const rvector& v1, const scivector_slice& v2) {
6344 return fsl_vv_hull<rvector,scivector_slice,civector>(v1,v2);
6345}
6346
6348inline civector operator|(const cvector& v1, const scivector_slice& v2) {
6349 return fsl_vv_hull<cvector,scivector_slice,civector>(v1,v2);
6350}
6351
6353inline civector operator|(const ivector& v1, const scivector_slice& v2) {
6354 return fsl_vv_hull<ivector,scivector_slice,civector>(v1,v2);
6355}
6356
6358inline civector operator|(const cvector& v1, const sivector_slice& v2) {
6359 return fsl_vv_hull<cvector,sivector_slice,civector>(v1,v2);
6360}
6361
6363inline civector operator|(const ivector& v1, const scvector_slice& v2) {
6364 return fsl_vv_hull<ivector,scvector_slice,civector>(v1,v2);
6365}
6366
6368inline civector operator|(const scivector_slice& v1, const rvector& v2) {
6369 return slf_vv_hull<scivector_slice,rvector,civector>(v1,v2);
6370}
6371
6373inline civector operator|(const scivector_slice& v1, const cvector& v2) {
6374 return slf_vv_hull<scivector_slice,cvector,civector>(v1,v2);
6375}
6376
6378inline civector operator|(const scivector_slice& v1, const ivector& v2) {
6379 return slf_vv_hull<scivector_slice,ivector,civector>(v1,v2);
6380}
6381
6383inline civector operator|(const scivector_slice& v1, const civector& v2) {
6384 return slf_vv_hull<scivector_slice,civector,civector>(v1,v2);
6385}
6386
6388inline civector operator|(const srvector_slice& v1, const civector& v2) {
6389 return slf_vv_hull<srvector_slice,civector,civector>(v1,v2);
6390}
6391
6393inline civector operator|(const scvector_slice& v1, const civector& v2) {
6394 return slf_vv_hull<scvector_slice,civector,civector>(v1,v2);
6395}
6396
6398inline civector operator|(const sivector_slice& v1, const civector& v2) {
6399 return slf_vv_hull<sivector_slice,civector,civector>(v1,v2);
6400}
6401
6403inline civector operator|(const scvector_slice& v1, const ivector& v2) {
6404 return slf_vv_hull<scvector_slice,ivector,civector>(v1,v2);
6405}
6406
6408inline civector operator|(const sivector_slice& v1, const cvector& v2) {
6409 return slf_vv_hull<sivector_slice,cvector,civector>(v1,v2);
6410}
6411
6413inline civector operator|(const civector_slice& v1, const srvector_slice& v2) {
6414 return fsl_vv_hull<civector_slice,srvector_slice,civector>(v1,v2);
6415}
6416
6418inline civector operator|(const civector_slice& v1, const scvector_slice& v2) {
6419 return fsl_vv_hull<civector_slice,scvector_slice,civector>(v1,v2);
6420}
6421
6423inline civector operator|(const civector_slice& v1, const sivector_slice& v2) {
6424 return fsl_vv_hull<civector_slice,sivector_slice,civector>(v1,v2);
6425}
6426
6428inline civector operator|(const civector_slice& v1, const scivector_slice& v2) {
6429 return fsl_vv_hull<civector_slice,scivector_slice,civector>(v1,v2);
6430}
6431
6433inline civector operator|(const rvector_slice& v1, const scivector_slice& v2) {
6434 return fsl_vv_hull<rvector_slice,scivector_slice,civector>(v1,v2);
6435}
6436
6438inline civector operator|(const cvector_slice& v1, const scivector_slice& v2) {
6439 return fsl_vv_hull<cvector_slice,scivector_slice,civector>(v1,v2);
6440}
6441
6443inline civector operator|(const ivector_slice& v1, const scivector_slice& v2) {
6444 return fsl_vv_hull<ivector_slice,scivector_slice,civector>(v1,v2);
6445}
6446
6448inline civector operator|(const ivector_slice& v1, const scvector_slice& v2) {
6449 return fsl_vv_hull<ivector_slice,scvector_slice,civector>(v1,v2);
6450}
6451
6453inline civector operator|(const cvector_slice& v1, const sivector_slice& v2) {
6454 return fsl_vv_hull<cvector_slice,sivector_slice,civector>(v1,v2);
6455}
6456
6458inline civector operator|(const scivector_slice& v1, const rvector_slice& v2) {
6459 return slf_vv_hull<scivector_slice,rvector_slice,civector>(v1,v2);
6460}
6461
6463inline civector operator|(const scivector_slice& v1, const ivector_slice& v2) {
6464 return slf_vv_hull<scivector_slice,ivector_slice,civector>(v1,v2);
6465}
6466
6468inline civector operator|(const scivector_slice& v1, const cvector_slice& v2) {
6469 return slf_vv_hull<scivector_slice,cvector_slice,civector>(v1,v2);
6470}
6471
6473inline civector operator|(const scivector_slice& v1, const civector_slice& v2) {
6474 return slf_vv_hull<scivector_slice,civector_slice,civector>(v1,v2);
6475}
6476
6478inline civector operator|(const srvector_slice& v1, const civector_slice& v2) {
6479 return slf_vv_hull<srvector_slice,civector_slice,civector>(v1,v2);
6480}
6481
6483inline civector operator|(const sivector_slice& v1, const civector_slice& v2) {
6484 return slf_vv_hull<sivector_slice,civector_slice,civector>(v1,v2);
6485}
6486
6488inline civector operator|(const scvector_slice& v1, const civector_slice& v2) {
6489 return slf_vv_hull<scvector_slice,civector_slice,civector>(v1,v2);
6490}
6491
6493inline civector operator|(const scvector_slice& v1, const ivector_slice& v2) {
6494 return slf_vv_hull<scvector_slice,ivector_slice,civector>(v1,v2);
6495}
6496
6498inline civector operator|(const sivector_slice& v1, const cvector_slice& v2) {
6499 return slf_vv_hull<sivector_slice,cvector_slice,civector>(v1,v2);
6500}
6501
6503inline scivector operator|(const scivector_slice& v1, const srvector_slice& v2) {
6504 return slsl_vv_hull<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
6505}
6506
6508inline scivector operator|(const scivector_slice& v1, const scvector_slice& v2) {
6509 return slsl_vv_hull<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6510}
6511
6513inline scivector operator|(const scivector_slice& v1, const sivector_slice& v2) {
6514 return slsl_vv_hull<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6515}
6516
6518inline scivector operator|(const scivector_slice& v1, const scivector_slice& v2) {
6519 return slsl_vv_hull<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6520}
6521
6523inline scivector operator|(const srvector_slice& v1, const scivector_slice& v2) {
6524 return slsl_vv_hull<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6525}
6526
6528inline scivector operator|(const scvector_slice& v1, const scivector_slice& v2) {
6529 return slsl_vv_hull<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6530}
6531
6533inline scivector operator|(const sivector_slice& v1, const scivector_slice& v2) {
6534 return slsl_vv_hull<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6535}
6536
6538inline scivector operator|(const scvector_slice& v1, const sivector_slice& v2) {
6539 return slsl_vv_hull<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6540}
6541
6543inline scivector operator|(const sivector_slice& v1, const scvector_slice& v2) {
6544 return slsl_vv_hull<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
6545}
6546
6548inline scivector operator|(const scivector& v1, const srvector_slice& v2) {
6549 return spsl_vv_hull<scivector,srvector_slice,scivector,cinterval>(v1,v2);
6550}
6551
6553inline scivector operator|(const scivector& v1, const scvector_slice& v2) {
6554 return spsl_vv_hull<scivector,scvector_slice,scivector,cinterval>(v1,v2);
6555}
6556
6558inline scivector operator|(const scivector& v1, const sivector_slice& v2) {
6559 return spsl_vv_hull<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6560}
6561
6563inline scivector operator|(const scivector& v1, const scivector_slice& v2) {
6564 return spsl_vv_hull<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6565}
6566
6568inline scivector operator|(const srvector& v1, const scivector_slice& v2) {
6569 return spsl_vv_hull<srvector,scivector_slice,scivector,cinterval>(v1,v2);
6570}
6571
6573inline scivector operator|(const scvector& v1, const scivector_slice& v2) {
6574 return spsl_vv_hull<scvector,scivector_slice,scivector,cinterval>(v1,v2);
6575}
6576
6578inline scivector operator|(const sivector& v1, const scivector_slice& v2) {
6579 return spsl_vv_hull<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6580}
6581
6583inline scivector operator|(const scvector& v1, const sivector_slice& v2) {
6584 return spsl_vv_hull<scvector,sivector_slice,scivector,cinterval>(v1,v2);
6585}
6586
6588inline scivector operator|(const sivector& v1, const scvector_slice& v2) {
6589 return spsl_vv_hull<sivector,scvector_slice,scivector,cinterval>(v1,v2);
6590}
6591
6593inline scivector operator|(const scivector_slice& v1, const srvector& v2) {
6594 return slsp_vv_hull<scivector_slice,srvector,scivector,cinterval>(v1,v2);
6595}
6596
6598inline scivector operator|(const scivector_slice& v1, const scvector& v2) {
6599 return slsp_vv_hull<scivector_slice,scvector,scivector,cinterval>(v1,v2);
6600}
6601
6603inline scivector operator|(const scivector_slice& v1, const sivector& v2) {
6604 return slsp_vv_hull<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6605}
6606
6608inline scivector operator|(const scivector_slice& v1, const scivector& v2) {
6609 return slsp_vv_hull<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6610}
6611
6613inline scivector operator|(const srvector_slice& v1, const scivector& v2) {
6614 return slsp_vv_hull<srvector_slice,scivector,scivector,cinterval>(v1,v2);
6615}
6616
6618inline scivector operator|(const scvector_slice& v1, const scivector& v2) {
6619 return slsp_vv_hull<scvector_slice,scivector,scivector,cinterval>(v1,v2);
6620}
6621
6623inline scivector operator|(const sivector_slice& v1, const scivector& v2) {
6624 return slsp_vv_hull<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6625}
6626
6628inline scivector operator|(const scvector_slice& v1, const sivector& v2) {
6629 return slsp_vv_hull<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6630}
6631
6633inline scivector operator|(const sivector_slice& v1, const scvector& v2) {
6634 return slsp_vv_hull<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6635}
6636
6638inline civector operator&(const civector& v1, const sivector_slice& v2) {
6639 return fsl_vv_intersect<civector,sivector_slice,civector>(v1,v2);
6640}
6641
6643inline civector operator&(const civector& v1, const scivector_slice& v2) {
6644 return fsl_vv_intersect<civector,scivector_slice,civector>(v1,v2);
6645}
6646
6648inline civector operator&(const ivector& v1, const scivector_slice& v2) {
6649 return fsl_vv_intersect<ivector,scivector_slice,civector>(v1,v2);
6650}
6651
6653inline civector operator&(const scivector_slice& v1, const ivector& v2) {
6654 return slf_vv_intersect<scivector_slice,ivector,civector>(v1,v2);
6655}
6656
6658inline civector operator&(const scivector_slice& v1, const civector& v2) {
6659 return slf_vv_intersect<scivector_slice,civector,civector>(v1,v2);
6660}
6661
6663inline civector operator&(const sivector_slice& v1, const civector& v2) {
6664 return slf_vv_intersect<sivector_slice,civector,civector>(v1,v2);
6665}
6666
6668inline civector operator&(const civector_slice& v1, const sivector_slice& v2) {
6669 return fsl_vv_intersect<civector_slice,sivector_slice,civector>(v1,v2);
6670}
6671
6673inline civector operator&(const civector_slice& v1, const scivector_slice& v2) {
6674 return fsl_vv_intersect<civector_slice,scivector_slice,civector>(v1,v2);
6675}
6676
6678inline civector operator&(const ivector_slice& v1, const scivector_slice& v2) {
6679 return fsl_vv_intersect<ivector_slice,scivector_slice,civector>(v1,v2);
6680}
6681
6683inline civector operator&(const scivector_slice& v1, const ivector_slice& v2) {
6684 return slf_vv_intersect<scivector_slice,ivector_slice,civector>(v1,v2);
6685}
6686
6688inline civector operator&(const scivector_slice& v1, const civector_slice& v2) {
6689 return slf_vv_intersect<scivector_slice,civector_slice,civector>(v1,v2);
6690}
6691
6693inline civector operator&(const sivector_slice& v1, const civector_slice& v2) {
6694 return slf_vv_intersect<sivector_slice,civector_slice,civector>(v1,v2);
6695}
6696
6698inline scivector operator&(const scivector_slice& v1, const sivector_slice& v2) {
6699 return slsl_vv_intersect<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
6700}
6701
6703inline scivector operator&(const scivector_slice& v1, const scivector_slice& v2) {
6704 return slsl_vv_intersect<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6705}
6706
6708inline scivector operator&(const sivector_slice& v1, const scivector_slice& v2) {
6709 return slsl_vv_intersect<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
6710}
6711
6713inline scivector operator&(const scivector& v1, const sivector_slice& v2) {
6714 return spsl_vv_intersect<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6715}
6716
6718inline scivector operator&(const scivector& v1, const scivector_slice& v2) {
6719 return spsl_vv_intersect<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6720}
6721
6723inline scivector operator&(const sivector& v1, const scivector_slice& v2) {
6724 return spsl_vv_intersect<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6725}
6726
6728inline scivector operator&(const scivector_slice& v1, const sivector& v2) {
6729 return slsp_vv_intersect<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6730}
6731
6733inline scivector operator&(const scivector_slice& v1, const scivector& v2) {
6734 return slsp_vv_intersect<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6735}
6736
6738inline scivector operator&(const sivector_slice& v1, const scivector& v2) {
6739 return slsp_vv_intersect<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6740}
6741
6742inline civector& civector::operator+=(const srvector_slice& v2) {
6743 return fsl_vv_addassign(*this,v2);
6744}
6745
6746inline civector& civector::operator+=(const scvector_slice& v2) {
6747 return fsl_vv_addassign(*this,v2);
6748}
6749
6750inline civector& civector::operator+=(const sivector_slice& v2) {
6751 return fsl_vv_addassign(*this,v2);
6752}
6753
6754inline civector& civector::operator+=(const scivector_slice& v2) {
6755 return fsl_vv_addassign(*this,v2);
6756}
6757
6758inline civector_slice& civector_slice::operator+=(const srvector_slice& v2) {
6759 return fsl_vv_addassign(*this,v2);
6760}
6761
6762inline civector_slice& civector_slice::operator+=(const scvector_slice& v2) {
6763 return fsl_vv_addassign(*this,v2);
6764}
6765
6766inline civector_slice& civector_slice::operator+=(const sivector_slice& v2) {
6767 return fsl_vv_addassign(*this,v2);
6768}
6769
6770inline civector_slice& civector_slice::operator+=(const scivector_slice& v2) {
6771 return fsl_vv_addassign(*this,v2);
6772}
6773
6775 return spsl_vv_addassign(*this,v2);
6776}
6777
6779 return spsl_vv_addassign(*this,v2);
6780}
6781
6783 return spsl_vv_addassign(*this,v2);
6784}
6785
6787 return spsl_vv_addassign(*this,v2);
6788}
6789
6790inline civector& civector::operator-=(const srvector_slice& v2) {
6791 return fsl_vv_subassign(*this,v2);
6792}
6793
6794inline civector& civector::operator-=(const scvector_slice& v2) {
6795 return fsl_vv_subassign(*this,v2);
6796}
6797
6798inline civector& civector::operator-=(const sivector_slice& v2) {
6799 return fsl_vv_subassign(*this,v2);
6800}
6801
6802inline civector& civector::operator-=(const scivector_slice& v2) {
6803 return fsl_vv_subassign(*this,v2);
6804}
6805
6806inline civector_slice& civector_slice::operator-=(const srvector_slice& v2) {
6807 return fsl_vv_subassign(*this,v2);
6808}
6809
6810inline civector_slice& civector_slice::operator-=(const scvector_slice& v2) {
6811 return fsl_vv_subassign(*this,v2);
6812}
6813
6814inline civector_slice& civector_slice::operator-=(const sivector_slice& v2) {
6815 return fsl_vv_subassign(*this,v2);
6816}
6817
6818inline civector_slice& civector_slice::operator-=(const scivector_slice& v2) {
6819 return fsl_vv_subassign(*this,v2);
6820}
6821
6823 return spsl_vv_subassign(*this,v2);
6824}
6825
6827 return spsl_vv_subassign(*this,v2);
6828}
6829
6831 return spsl_vv_subassign(*this,v2);
6832}
6833
6835 return spsl_vv_subassign(*this,v2);
6836}
6837
6838inline civector& civector::operator|=(const srvector_slice& v2) {
6839 return fsl_vv_hullassign(*this,v2);
6840}
6841
6842inline civector& civector::operator|=(const scvector_slice& v2) {
6843 return fsl_vv_hullassign(*this,v2);
6844}
6845
6846inline civector& civector::operator|=(const sivector_slice& v2) {
6847 return fsl_vv_hullassign(*this,v2);
6848}
6849
6850inline civector& civector::operator|=(const scivector_slice& v2) {
6851 return fsl_vv_hullassign(*this,v2);
6852}
6853
6854inline civector_slice& civector_slice::operator|=(const srvector_slice& v2) {
6855 return fsl_vv_hullassign(*this,v2);
6856}
6857
6858inline civector_slice& civector_slice::operator|=(const scvector_slice& v2) {
6859 return fsl_vv_hullassign(*this,v2);
6860}
6861
6862inline civector_slice& civector_slice::operator|=(const sivector_slice& v2) {
6863 return fsl_vv_hullassign(*this,v2);
6864}
6865
6866inline civector_slice& civector_slice::operator|=(const scivector_slice& v2) {
6867 return fsl_vv_hullassign(*this,v2);
6868}
6869
6871 return spsl_vv_hullassign(*this,v2);
6872}
6873
6875 return spsl_vv_hullassign(*this,v2);
6876}
6877
6879 return spsl_vv_hullassign(*this,v2);
6880}
6881
6883 return spsl_vv_hullassign(*this,v2);
6884}
6885
6886inline civector& civector::operator&=(const sivector_slice& v2) {
6887 return fsl_vv_intersectassign(*this,v2);
6888}
6889
6890inline civector& civector::operator&=(const scivector_slice& v2) {
6891 return fsl_vv_intersectassign(*this,v2);
6892}
6893
6894inline civector_slice& civector_slice::operator&=(const sivector_slice& v2) {
6895 return fsl_vv_intersectassign(*this,v2);
6896}
6897
6898inline civector_slice& civector_slice::operator&=(const scivector_slice& v2) {
6899 return fsl_vv_intersectassign(*this,v2);
6900}
6901
6903 return spsl_vv_intersectassign(*this,v2);
6904}
6905
6907 return spsl_vv_intersectassign(*this,v2);
6908}
6909
6911
6914inline bool operator==(const scivector_slice& v1, const srvector_slice& v2) {
6915 return slsl_vv_comp(v1,v2);
6916}
6917
6919
6922inline bool operator==(const scivector_slice& v1, const scvector_slice& v2) {
6923 return slsl_vv_comp(v1,v2);
6924}
6925
6927
6930inline bool operator==(const scivector_slice& v1, const sivector_slice& v2) {
6931 return slsl_vv_comp(v1,v2);
6932}
6933
6935
6938inline bool operator==(const scivector_slice& v1, const scivector_slice& v2) {
6939 return slsl_vv_comp(v1,v2);
6940}
6941
6943
6946inline bool operator==(const srvector_slice& v1, const scivector_slice& v2) {
6947 return slsl_vv_comp(v1,v2);
6948}
6949
6951
6954inline bool operator==(const scvector_slice& v1, const scivector_slice& v2) {
6955 return slsl_vv_comp(v1,v2);
6956}
6957
6959
6962inline bool operator==(const sivector_slice& v1, const scivector_slice& v2) {
6963 return slsl_vv_comp(v1,v2);
6964}
6965
6967
6970inline bool operator==(const scivector_slice& v1, const srvector& v2) {
6971 return slsp_vv_comp(v1,v2);
6972}
6973
6975
6978inline bool operator==(const scivector_slice& v1, const scvector& v2) {
6979 return slsp_vv_comp(v1,v2);
6980}
6981
6983
6986inline bool operator==(const scivector_slice& v1, const sivector& v2) {
6987 return slsp_vv_comp(v1,v2);
6988}
6989
6991
6994inline bool operator==(const scivector_slice& v1, const scivector& v2) {
6995 return slsp_vv_comp(v1,v2);
6996}
6997
6999
7002inline bool operator==(const srvector_slice& v1, const scivector& v2) {
7003 return slsp_vv_comp(v1,v2);
7004}
7005
7007
7010inline bool operator==(const scvector_slice& v1, const scivector& v2) {
7011 return slsp_vv_comp(v1,v2);
7012}
7013
7015
7018inline bool operator==(const sivector_slice& v1, const scivector& v2) {
7019 return slsp_vv_comp(v1,v2);
7020}
7021
7023
7026inline bool operator==(const scivector& v1, const srvector_slice& v2) {
7027 return spsl_vv_comp(v1,v2);
7028}
7029
7031
7034inline bool operator==(const scivector& v1, const scvector_slice& v2) {
7035 return spsl_vv_comp(v1,v2);
7036}
7037
7039
7042inline bool operator==(const scivector& v1, const sivector_slice& v2) {
7043 return spsl_vv_comp(v1,v2);
7044}
7045
7047
7050inline bool operator==(const scivector& v1, const scivector_slice& v2) {
7051 return spsl_vv_comp(v1,v2);
7052}
7053
7055
7058inline bool operator==(const srvector& v1, const scivector_slice& v2) {
7059 return spsl_vv_comp(v1,v2);
7060}
7061
7063
7066inline bool operator==(const scvector& v1, const scivector_slice& v2) {
7067 return spsl_vv_comp(v1,v2);
7068}
7069
7071
7074inline bool operator==(const sivector& v1, const scivector_slice& v2) {
7075 return spsl_vv_comp(v1,v2);
7076}
7077
7079
7082inline bool operator==(const scivector_slice& v1, const rvector& v2) {
7083 return slf_vv_comp(v1,v2);
7084}
7085
7087
7090inline bool operator==(const scivector_slice& v1, const cvector& v2) {
7091 return slf_vv_comp(v1,v2);
7092}
7093
7095
7098inline bool operator==(const scivector_slice& v1, const ivector& v2) {
7099 return slf_vv_comp(v1,v2);
7100}
7101
7103
7106inline bool operator==(const scivector_slice& v1, const civector& v2) {
7107 return slf_vv_comp(v1,v2);
7108}
7109
7111
7114inline bool operator==(const srvector_slice& v1, const civector& v2) {
7115 return slf_vv_comp(v1,v2);
7116}
7117
7119
7122inline bool operator==(const sivector_slice& v1, const civector& v2) {
7123 return slf_vv_comp(v1,v2);
7124}
7125
7127
7130inline bool operator==(const scvector_slice& v1, const civector& v2) {
7131 return slf_vv_comp(v1,v2);
7132}
7133
7135
7138inline bool operator==(const civector& v1, const srvector_slice& v2) {
7139 return fsl_vv_comp(v1,v2);
7140}
7141
7143
7146inline bool operator==(const civector& v1, const scvector_slice& v2) {
7147 return fsl_vv_comp(v1,v2);
7148}
7149
7151
7154inline bool operator==(const civector& v1, const sivector_slice& v2) {
7155 return fsl_vv_comp(v1,v2);
7156}
7157
7159
7162inline bool operator==(const civector& v1, const scivector_slice& v2) {
7163 return fsl_vv_comp(v1,v2);
7164}
7165
7167
7170inline bool operator==(const rvector& v1, const scivector_slice& v2) {
7171 return fsl_vv_comp(v1,v2);
7172}
7173
7175
7178inline bool operator==(const cvector& v1, const scivector_slice& v2) {
7179 return fsl_vv_comp(v1,v2);
7180}
7181
7183
7186inline bool operator==(const ivector& v1, const scivector_slice& v2) {
7187 return fsl_vv_comp(v1,v2);
7188}
7189
7191
7194inline bool operator==(const scivector_slice& v1, const rvector_slice& v2) {
7195 return slf_vv_comp(v1,v2);
7196}
7197
7199
7202inline bool operator==(const scivector_slice& v1, const ivector_slice& v2) {
7203 return slf_vv_comp(v1,v2);
7204}
7205
7207
7210inline bool operator==(const scivector_slice& v1, const cvector_slice& v2) {
7211 return slf_vv_comp(v1,v2);
7212}
7213
7215
7218inline bool operator==(const scivector_slice& v1, const civector_slice& v2) {
7219 return slf_vv_comp(v1,v2);
7220}
7221
7223
7226inline bool operator==(const srvector_slice& v1, const civector_slice& v2) {
7227 return slf_vv_comp(v1,v2);
7228}
7229
7231
7234inline bool operator==(const sivector_slice& v1, const civector_slice& v2) {
7235 return slf_vv_comp(v1,v2);
7236}
7237
7239
7242inline bool operator==(const scvector_slice& v1, const civector_slice& v2) {
7243 return slf_vv_comp(v1,v2);
7244}
7245
7247
7250inline bool operator==(const civector_slice& v1, const srvector_slice& v2) {
7251 return fsl_vv_comp(v1,v2);
7252}
7253
7255
7258inline bool operator==(const civector_slice& v1, const scvector_slice& v2) {
7259 return fsl_vv_comp(v1,v2);
7260}
7261
7263
7266inline bool operator==(const civector_slice& v1, const sivector_slice& v2) {
7267 return fsl_vv_comp(v1,v2);
7268}
7269
7271
7274inline bool operator==(const civector_slice& v1, const scivector_slice& v2) {
7275 return fsl_vv_comp(v1,v2);
7276}
7277
7279
7282inline bool operator==(const rvector_slice& v1, const scivector_slice& v2) {
7283 return fsl_vv_comp(v1,v2);
7284}
7285
7287
7290inline bool operator==(const cvector_slice& v1, const scivector_slice& v2) {
7291 return fsl_vv_comp(v1,v2);
7292}
7293
7295
7298inline bool operator==(const ivector_slice& v1, const scivector_slice& v2) {
7299 return fsl_vv_comp(v1,v2);
7300}
7301
7303
7306inline bool operator!=(const scivector_slice& v1, const srvector_slice& v2) {
7307 return !slsl_vv_comp(v1,v2);
7308}
7309
7311
7314inline bool operator!=(const scivector_slice& v1, const scvector_slice& v2) {
7315 return !slsl_vv_comp(v1,v2);
7316}
7317
7319
7322inline bool operator!=(const scivector_slice& v1, const sivector_slice& v2) {
7323 return !slsl_vv_comp(v1,v2);
7324}
7325
7327
7330inline bool operator!=(const scivector_slice& v1, const scivector_slice& v2) {
7331 return !slsl_vv_comp(v1,v2);
7332}
7333
7335
7338inline bool operator!=(const srvector_slice& v1, const scivector_slice& v2) {
7339 return !slsl_vv_comp(v1,v2);
7340}
7341
7343
7346inline bool operator!=(const scvector_slice& v1, const scivector_slice& v2) {
7347 return !slsl_vv_comp(v1,v2);
7348}
7349
7351
7354inline bool operator!=(const sivector_slice& v1, const scivector_slice& v2) {
7355 return !slsl_vv_comp(v1,v2);
7356}
7357
7359
7362inline bool operator!=(const scivector_slice& v1, const srvector& v2) {
7363 return !slsp_vv_comp(v1,v2);
7364}
7365
7367
7370inline bool operator!=(const scivector_slice& v1, const scvector& v2) {
7371 return !slsp_vv_comp(v1,v2);
7372}
7373
7375
7378inline bool operator!=(const scivector_slice& v1, const sivector& v2) {
7379 return !slsp_vv_comp(v1,v2);
7380}
7381
7383
7386inline bool operator!=(const scivector_slice& v1, const scivector& v2) {
7387 return !slsp_vv_comp(v1,v2);
7388}
7389
7391
7394inline bool operator!=(const srvector_slice& v1, const scivector& v2) {
7395 return !slsp_vv_comp(v1,v2);
7396}
7397
7399
7402inline bool operator!=(const scvector_slice& v1, const scivector& v2) {
7403 return !slsp_vv_comp(v1,v2);
7404}
7405
7407
7410inline bool operator!=(const sivector_slice& v1, const scivector& v2) {
7411 return !slsp_vv_comp(v1,v2);
7412}
7413
7415
7418inline bool operator!=(const scivector& v1, const srvector_slice& v2) {
7419 return !spsl_vv_comp(v1,v2);
7420}
7421
7423
7426inline bool operator!=(const scivector& v1, const scvector_slice& v2) {
7427 return !spsl_vv_comp(v1,v2);
7428}
7429
7431
7434inline bool operator!=(const scivector& v1, const sivector_slice& v2) {
7435 return !spsl_vv_comp(v1,v2);
7436}
7437
7439
7442inline bool operator!=(const scivector& v1, const scivector_slice& v2) {
7443 return !spsl_vv_comp(v1,v2);
7444}
7445
7447
7450inline bool operator!=(const srvector& v1, const scivector_slice& v2) {
7451 return !spsl_vv_comp(v1,v2);
7452}
7453
7455
7458inline bool operator!=(const scvector& v1, const scivector_slice& v2) {
7459 return !spsl_vv_comp(v1,v2);
7460}
7461
7463
7466inline bool operator!=(const sivector& v1, const scivector_slice& v2) {
7467 return !spsl_vv_comp(v1,v2);
7468}
7469
7471
7474inline bool operator!=(const scivector_slice& v1, const rvector& v2) {
7475 return !slf_vv_comp(v1,v2);
7476}
7477
7479
7482inline bool operator!=(const scivector_slice& v1, const cvector& v2) {
7483 return !slf_vv_comp(v1,v2);
7484}
7485
7487
7490inline bool operator!=(const scivector_slice& v1, const ivector& v2) {
7491 return !slf_vv_comp(v1,v2);
7492}
7493
7495
7498inline bool operator!=(const scivector_slice& v1, const civector& v2) {
7499 return !slf_vv_comp(v1,v2);
7500}
7501
7503
7506inline bool operator!=(const srvector_slice& v1, const civector& v2) {
7507 return !slf_vv_comp(v1,v2);
7508}
7509
7511
7514inline bool operator!=(const sivector_slice& v1, const civector& v2) {
7515 return !slf_vv_comp(v1,v2);
7516}
7517
7519
7522inline bool operator!=(const scvector_slice& v1, const civector& v2) {
7523 return !slf_vv_comp(v1,v2);
7524}
7525
7527
7530inline bool operator!=(const civector& v1, const srvector_slice& v2) {
7531 return !fsl_vv_comp(v1,v2);
7532}
7533
7535
7538inline bool operator!=(const civector& v1, const scvector_slice& v2) {
7539 return !fsl_vv_comp(v1,v2);
7540}
7541
7543
7546inline bool operator!=(const civector& v1, const sivector_slice& v2) {
7547 return !fsl_vv_comp(v1,v2);
7548}
7549
7551
7554inline bool operator!=(const civector& v1, const scivector_slice& v2) {
7555 return !fsl_vv_comp(v1,v2);
7556}
7557
7559
7562inline bool operator!=(const rvector& v1, const scivector_slice& v2) {
7563 return !fsl_vv_comp(v1,v2);
7564}
7565
7567
7570inline bool operator!=(const cvector& v1, const scivector_slice& v2) {
7571 return !fsl_vv_comp(v1,v2);
7572}
7573
7575
7578inline bool operator!=(const ivector& v1, const scivector_slice& v2) {
7579 return !fsl_vv_comp(v1,v2);
7580}
7581
7583
7586inline bool operator!=(const scivector_slice& v1, const rvector_slice& v2) {
7587 return !slf_vv_comp(v1,v2);
7588}
7589
7591
7594inline bool operator!=(const scivector_slice& v1, const ivector_slice& v2) {
7595 return !slf_vv_comp(v1,v2);
7596}
7597
7599
7602inline bool operator!=(const scivector_slice& v1, const cvector_slice& v2) {
7603 return !slf_vv_comp(v1,v2);
7604}
7605
7607
7610inline bool operator!=(const scivector_slice& v1, const civector_slice& v2) {
7611 return !slf_vv_comp(v1,v2);
7612}
7613
7615
7618inline bool operator!=(const srvector_slice& v1, const civector_slice& v2) {
7619 return !slf_vv_comp(v1,v2);
7620}
7621
7623
7626inline bool operator!=(const sivector_slice& v1, const civector_slice& v2) {
7627 return !slf_vv_comp(v1,v2);
7628}
7629
7631
7634inline bool operator!=(const scvector_slice& v1, const civector_slice& v2) {
7635 return !slf_vv_comp(v1,v2);
7636}
7637
7639
7642inline bool operator!=(const civector_slice& v1, const srvector_slice& v2) {
7643 return !fsl_vv_comp(v1,v2);
7644}
7645
7647
7650inline bool operator!=(const civector_slice& v1, const scvector_slice& v2) {
7651 return !fsl_vv_comp(v1,v2);
7652}
7653
7655
7658inline bool operator!=(const civector_slice& v1, const sivector_slice& v2) {
7659 return !fsl_vv_comp(v1,v2);
7660}
7661
7663
7666inline bool operator!=(const civector_slice& v1, const scivector_slice& v2) {
7667 return !fsl_vv_comp(v1,v2);
7668}
7669
7671
7674inline bool operator!=(const rvector_slice& v1, const scivector_slice& v2) {
7675 return !fsl_vv_comp(v1,v2);
7676}
7677
7679
7682inline bool operator!=(const cvector_slice& v1, const scivector_slice& v2) {
7683 return !fsl_vv_comp(v1,v2);
7684}
7685
7687
7690inline bool operator!=(const ivector_slice& v1, const scivector_slice& v2) {
7691 return !fsl_vv_comp(v1,v2);
7692}
7693
7695
7698inline bool operator<(const scivector_slice& v1, const sivector_slice& v2) {
7699 return slsl_vv_less<scivector_slice,sivector_slice,cinterval>(v1,v2);
7700}
7701
7703
7706inline bool operator<(const scivector_slice& v1, const scivector_slice& v2) {
7707 return slsl_vv_less<scivector_slice,scivector_slice,cinterval>(v1,v2);
7708}
7709
7711
7714inline bool operator<(const srvector_slice& v1, const scivector_slice& v2) {
7715 return slsl_vv_less<srvector_slice,scivector_slice,cinterval>(v1,v2);
7716}
7717
7719
7722inline bool operator<(const scvector_slice& v1, const scivector_slice& v2) {
7723 return slsl_vv_less<scvector_slice,scivector_slice,cinterval>(v1,v2);
7724}
7725
7727
7730inline bool operator<(const sivector_slice& v1, const scivector_slice& v2) {
7731 return slsl_vv_less<sivector_slice,scivector_slice,cinterval>(v1,v2);
7732}
7733
7735
7738inline bool operator<(const scivector_slice& v1, const sivector& v2) {
7739 return slsp_vv_less<scivector_slice,sivector,cinterval>(v1,v2);
7740}
7741
7743
7746inline bool operator<(const scivector_slice& v1, const scivector& v2) {
7747 return slsp_vv_less<scivector_slice,scivector,cinterval>(v1,v2);
7748}
7749
7751
7754inline bool operator<(const srvector_slice& v1, const scivector& v2) {
7755 return slsp_vv_less<srvector_slice,scivector,cinterval>(v1,v2);
7756}
7757
7759
7762inline bool operator<(const scvector_slice& v1, const scivector& v2) {
7763 return slsp_vv_less<scvector_slice,scivector,cinterval>(v1,v2);
7764}
7765
7767
7770inline bool operator<(const sivector_slice& v1, const scivector& v2) {
7771 return slsp_vv_less<sivector_slice,scivector,cinterval>(v1,v2);
7772}
7773
7775
7778inline bool operator<(const scivector& v1, const sivector_slice& v2) {
7779 return spsl_vv_less<scivector,sivector_slice,cinterval>(v1,v2);
7780}
7781
7783
7786inline bool operator<(const scivector& v1, const scivector_slice& v2) {
7787 return spsl_vv_less<scivector,scivector_slice,cinterval>(v1,v2);
7788}
7789
7791
7794inline bool operator<(const srvector& v1, const scivector_slice& v2) {
7795 return spsl_vv_less<srvector,scivector_slice,cinterval>(v1,v2);
7796}
7797
7799
7802inline bool operator<(const scvector& v1, const scivector_slice& v2) {
7803 return spsl_vv_less<scvector,scivector_slice,cinterval>(v1,v2);
7804}
7805
7807
7810inline bool operator<(const sivector& v1, const scivector_slice& v2) {
7811 return spsl_vv_less<sivector,scivector_slice,cinterval>(v1,v2);
7812}
7813
7815
7818inline bool operator<(const scivector_slice& v1, const ivector& v2) {
7819 return slf_vv_less<scivector_slice,ivector,cinterval>(v1,v2);
7820}
7821
7823
7826inline bool operator<(const scivector_slice& v1, const civector& v2) {
7827 return slf_vv_less<scivector_slice,civector,cinterval>(v1,v2);
7828}
7829
7831
7834inline bool operator<(const srvector_slice& v1, const civector& v2) {
7835 return slf_vv_less<srvector_slice,civector,cinterval>(v1,v2);
7836}
7837
7839
7842inline bool operator<(const sivector_slice& v1, const civector& v2) {
7843 return slf_vv_less<sivector_slice,civector,cinterval>(v1,v2);
7844}
7845
7847
7850inline bool operator<(const scvector_slice& v1, const civector& v2) {
7851 return slf_vv_less<scvector_slice,civector,cinterval>(v1,v2);
7852}
7853
7855
7858inline bool operator<(const civector& v1, const sivector_slice& v2) {
7859 return fsl_vv_less<civector,sivector_slice,cinterval>(v1,v2);
7860}
7861
7863
7866inline bool operator<(const civector& v1, const scivector_slice& v2) {
7867 return fsl_vv_less<civector,scivector_slice,cinterval>(v1,v2);
7868}
7869
7871
7874inline bool operator<(const rvector& v1, const scivector_slice& v2) {
7875 return fsl_vv_less<rvector,scivector_slice,cinterval>(v1,v2);
7876}
7877
7879
7882inline bool operator<(const cvector& v1, const scivector_slice& v2) {
7883 return fsl_vv_less<cvector,scivector_slice,cinterval>(v1,v2);
7884}
7885
7887
7890inline bool operator<(const ivector& v1, const scivector_slice& v2) {
7891 return fsl_vv_less<ivector,scivector_slice,cinterval>(v1,v2);
7892}
7893
7895
7898inline bool operator<=(const scivector_slice& v1, const sivector_slice& v2) {
7899 return slsl_vv_leq<scivector_slice,sivector_slice,cinterval>(v1,v2);
7900}
7901
7903
7906inline bool operator<=(const scivector_slice& v1, const scivector_slice& v2) {
7907 return slsl_vv_leq<scivector_slice,scivector_slice,cinterval>(v1,v2);
7908}
7909
7911
7914inline bool operator<=(const srvector_slice& v1, const scivector_slice& v2) {
7915 return slsl_vv_leq<srvector_slice,scivector_slice,cinterval>(v1,v2);
7916}
7917
7919
7922inline bool operator<=(const scvector_slice& v1, const scivector_slice& v2) {
7923 return slsl_vv_leq<scvector_slice,scivector_slice,cinterval>(v1,v2);
7924}
7925
7927
7930inline bool operator<=(const sivector_slice& v1, const scivector_slice& v2) {
7931 return slsl_vv_leq<sivector_slice,scivector_slice,cinterval>(v1,v2);
7932}
7933
7935
7938inline bool operator<=(const scivector_slice& v1, const sivector& v2) {
7939 return slsp_vv_leq<scivector_slice,sivector,cinterval>(v1,v2);
7940}
7941
7943
7946inline bool operator<=(const scivector_slice& v1, const scivector& v2) {
7947 return slsp_vv_leq<scivector_slice,scivector,cinterval>(v1,v2);
7948}
7949
7951
7954inline bool operator<=(const srvector_slice& v1, const scivector& v2) {
7955 return slsp_vv_leq<srvector_slice,scivector,cinterval>(v1,v2);
7956}
7957
7959
7962inline bool operator<=(const scvector_slice& v1, const scivector& v2) {
7963 return slsp_vv_leq<scvector_slice,scivector,cinterval>(v1,v2);
7964}
7965
7967
7970inline bool operator<=(const sivector_slice& v1, const scivector& v2) {
7971 return slsp_vv_leq<sivector_slice,scivector,cinterval>(v1,v2);
7972}
7973
7975
7978inline bool operator<=(const scivector& v1, const sivector_slice& v2) {
7979 return spsl_vv_leq<scivector,sivector_slice,cinterval>(v1,v2);
7980}
7981
7983
7986inline bool operator<=(const scivector& v1, const scivector_slice& v2) {
7987 return spsl_vv_leq<scivector,scivector_slice,cinterval>(v1,v2);
7988}
7989
7991
7994inline bool operator<=(const srvector& v1, const scivector_slice& v2) {
7995 return spsl_vv_leq<srvector,scivector_slice,cinterval>(v1,v2);
7996}
7997
7999
8002inline bool operator<=(const scvector& v1, const scivector_slice& v2) {
8003 return spsl_vv_leq<scvector,scivector_slice,cinterval>(v1,v2);
8004}
8005
8007
8010inline bool operator<=(const sivector& v1, const scivector_slice& v2) {
8011 return spsl_vv_leq<sivector,scivector_slice,cinterval>(v1,v2);
8012}
8013
8015
8018inline bool operator<=(const scivector_slice& v1, const ivector& v2) {
8019 return slf_vv_leq<scivector_slice,ivector,cinterval>(v1,v2);
8020}
8021
8023
8026inline bool operator<=(const scivector_slice& v1, const civector& v2) {
8027 return slf_vv_leq<scivector_slice,civector,cinterval>(v1,v2);
8028}
8029
8031
8034inline bool operator<=(const srvector_slice& v1, const civector& v2) {
8035 return slf_vv_leq<srvector_slice,civector,cinterval>(v1,v2);
8036}
8037
8039
8042inline bool operator<=(const sivector_slice& v1, const civector& v2) {
8043 return slf_vv_leq<sivector_slice,civector,cinterval>(v1,v2);
8044}
8045
8047
8050inline bool operator<=(const scvector_slice& v1, const civector& v2) {
8051 return slf_vv_leq<scvector_slice,civector,cinterval>(v1,v2);
8052}
8053
8055
8058inline bool operator<=(const civector& v1, const sivector_slice& v2) {
8059 return fsl_vv_leq<civector,sivector_slice,cinterval>(v1,v2);
8060}
8061
8063
8066inline bool operator<=(const civector& v1, const scivector_slice& v2) {
8067 return fsl_vv_leq<civector,scivector_slice,cinterval>(v1,v2);
8068}
8069
8071
8074inline bool operator<=(const rvector& v1, const scivector_slice& v2) {
8075 return fsl_vv_leq<rvector,scivector_slice,cinterval>(v1,v2);
8076}
8077
8079
8082inline bool operator<=(const cvector& v1, const scivector_slice& v2) {
8083 return fsl_vv_leq<cvector,scivector_slice,cinterval>(v1,v2);
8084}
8085
8087
8090inline bool operator<=(const ivector& v1, const scivector_slice& v2) {
8091 return fsl_vv_leq<ivector,scivector_slice,cinterval>(v1,v2);
8092}
8093
8095
8098inline bool operator>(const scivector_slice& v1, const srvector_slice& v2) {
8099 return slsl_vv_greater<scivector_slice,srvector_slice,cinterval>(v1,v2);
8100}
8101
8103
8106inline bool operator>(const scivector_slice& v1, const scvector_slice& v2) {
8107 return slsl_vv_greater<scivector_slice,scvector_slice,cinterval>(v1,v2);
8108}
8109
8111
8114inline bool operator>(const scivector_slice& v1, const sivector_slice& v2) {
8115 return slsl_vv_greater<scivector_slice,sivector_slice,cinterval>(v1,v2);
8116}
8117
8119
8122inline bool operator>(const scivector_slice& v1, const scivector_slice& v2) {
8123 return slsl_vv_greater<scivector_slice,scivector_slice,cinterval>(v1,v2);
8124}
8125
8127
8130inline bool operator>(const sivector_slice& v1, const scivector_slice& v2) {
8131 return slsl_vv_greater<sivector_slice,scivector_slice,cinterval>(v1,v2);
8132}
8133
8135
8138inline bool operator>(const scivector_slice& v1, const srvector& v2) {
8139 return slsp_vv_greater<scivector_slice,srvector,cinterval>(v1,v2);
8140}
8141
8143
8146inline bool operator>(const scivector_slice& v1, const scvector& v2) {
8147 return slsp_vv_greater<scivector_slice,scvector,cinterval>(v1,v2);
8148}
8149
8151
8154inline bool operator>(const scivector_slice& v1, const sivector& v2) {
8155 return slsp_vv_greater<scivector_slice,sivector,cinterval>(v1,v2);
8156}
8157
8159
8162inline bool operator>(const scivector_slice& v1, const scivector& v2) {
8163 return slsp_vv_greater<scivector_slice,scivector,cinterval>(v1,v2);
8164}
8165
8167
8170inline bool operator>(const sivector_slice& v1, const scivector& v2) {
8171 return slsp_vv_greater<sivector_slice,scivector,cinterval>(v1,v2);
8172}
8173
8175
8178inline bool operator>(const scivector& v1, const srvector_slice& v2) {
8179 return spsl_vv_greater<scivector,srvector_slice,cinterval>(v1,v2);
8180}
8181
8183
8186inline bool operator>(const scivector& v1, const scvector_slice& v2) {
8187 return spsl_vv_greater<scivector,scvector_slice,cinterval>(v1,v2);
8188}
8189
8191
8194inline bool operator>(const scivector& v1, const sivector_slice& v2) {
8195 return spsl_vv_greater<scivector,sivector_slice,cinterval>(v1,v2);
8196}
8197
8199
8202inline bool operator>(const scivector& v1, const scivector_slice& v2) {
8203 return spsl_vv_greater<scivector,scivector_slice,cinterval>(v1,v2);
8204}
8205
8207
8210inline bool operator>(const sivector& v1, const scivector_slice& v2) {
8211 return spsl_vv_greater<sivector,scivector_slice,cinterval>(v1,v2);
8212}
8213
8215
8218inline bool operator>(const scivector_slice& v1, const rvector& v2) {
8219 return slf_vv_greater<scivector_slice,rvector,cinterval>(v1,v2);
8220}
8221
8223
8226inline bool operator>(const scivector_slice& v1, const cvector& v2) {
8227 return slf_vv_greater<scivector_slice,cvector,cinterval>(v1,v2);
8228}
8229
8231
8234inline bool operator>(const scivector_slice& v1, const ivector& v2) {
8235 return slf_vv_greater<scivector_slice,ivector,cinterval>(v1,v2);
8236}
8237
8239
8242inline bool operator>(const scivector_slice& v1, const civector& v2) {
8243 return slf_vv_greater<scivector_slice,civector,cinterval>(v1,v2);
8244}
8245
8247
8250inline bool operator>(const sivector_slice& v1, const civector& v2) {
8251 return slf_vv_greater<sivector_slice,civector,cinterval>(v1,v2);
8252}
8253
8255
8258inline bool operator>(const civector& v1, const srvector_slice& v2) {
8259 return fsl_vv_greater<civector,srvector_slice,cinterval>(v1,v2);
8260}
8261
8263
8266inline bool operator>(const civector& v1, const scvector_slice& v2) {
8267 return fsl_vv_greater<civector,scvector_slice,cinterval>(v1,v2);
8268}
8269
8271
8274inline bool operator>(const civector& v1, const sivector_slice& v2) {
8275 return fsl_vv_greater<civector,sivector_slice,cinterval>(v1,v2);
8276}
8277
8279
8282inline bool operator>(const civector& v1, const scivector_slice& v2) {
8283 return fsl_vv_greater<civector,scivector_slice,cinterval>(v1,v2);
8284}
8285
8287
8290inline bool operator>(const ivector& v1, const scivector_slice& v2) {
8291 return fsl_vv_greater<ivector,scivector_slice,cinterval>(v1,v2);
8292}
8293
8295
8298inline bool operator>(const scivector_slice& v1, const rvector_slice& v2) {
8299 return slf_vv_greater<scivector_slice,rvector_slice,cinterval>(v1,v2);
8300}
8301
8303
8306inline bool operator>(const scivector_slice& v1, const ivector_slice& v2) {
8307 return slf_vv_greater<scivector_slice,ivector_slice,cinterval>(v1,v2);
8308}
8309
8311
8314inline bool operator>(const scivector_slice& v1, const cvector_slice& v2) {
8315 return slf_vv_greater<scivector_slice,cvector_slice,cinterval>(v1,v2);
8316}
8317
8319
8322inline bool operator>(const scivector_slice& v1, const civector_slice& v2) {
8323 return slf_vv_greater<scivector_slice,civector_slice,cinterval>(v1,v2);
8324}
8325
8327
8330inline bool operator>(const sivector_slice& v1, const civector_slice& v2) {
8331 return slf_vv_greater<sivector_slice,civector_slice,cinterval>(v1,v2);
8332}
8333
8335
8338inline bool operator>(const civector_slice& v1, const srvector_slice& v2) {
8339 return fsl_vv_greater<civector_slice,srvector_slice,cinterval>(v1,v2);
8340}
8341
8343
8346inline bool operator>(const civector_slice& v1, const scvector_slice& v2) {
8347 return fsl_vv_greater<civector_slice,scvector_slice,cinterval>(v1,v2);
8348}
8349
8351
8354inline bool operator>(const civector_slice& v1, const sivector_slice& v2) {
8355 return fsl_vv_greater<civector_slice,sivector_slice,cinterval>(v1,v2);
8356}
8357
8359
8362inline bool operator>(const civector_slice& v1, const scivector_slice& v2) {
8363 return fsl_vv_greater<civector_slice,scivector_slice,cinterval>(v1,v2);
8364}
8365
8367
8370inline bool operator>(const ivector_slice& v1, const scivector_slice& v2) {
8371 return fsl_vv_greater<ivector_slice,scivector_slice,cinterval>(v1,v2);
8372}
8373
8375
8378inline bool operator>=(const scivector_slice& v1, const srvector_slice& v2) {
8379 return slsl_vv_geq<scivector_slice,srvector_slice,cinterval>(v1,v2);
8380}
8381
8383
8386inline bool operator>=(const scivector_slice& v1, const scvector_slice& v2) {
8387 return slsl_vv_geq<scivector_slice,scvector_slice,cinterval>(v1,v2);
8388}
8389
8391
8394inline bool operator>=(const scivector_slice& v1, const sivector_slice& v2) {
8395 return slsl_vv_geq<scivector_slice,sivector_slice,cinterval>(v1,v2);
8396}
8397
8399
8402inline bool operator>=(const scivector_slice& v1, const scivector_slice& v2) {
8403 return slsl_vv_geq<scivector_slice,scivector_slice,cinterval>(v1,v2);
8404}
8405
8407
8410inline bool operator>=(const sivector_slice& v1, const scivector_slice& v2) {
8411 return slsl_vv_geq<sivector_slice,scivector_slice,cinterval>(v1,v2);
8412}
8413
8415
8418inline bool operator>=(const scivector_slice& v1, const srvector& v2) {
8419 return slsp_vv_geq<scivector_slice,srvector,cinterval>(v1,v2);
8420}
8421
8423
8426inline bool operator>=(const scivector_slice& v1, const scvector& v2) {
8427 return slsp_vv_geq<scivector_slice,scvector,cinterval>(v1,v2);
8428}
8429
8431
8434inline bool operator>=(const scivector_slice& v1, const sivector& v2) {
8435 return slsp_vv_geq<scivector_slice,sivector,cinterval>(v1,v2);
8436}
8437
8439
8442inline bool operator>=(const scivector_slice& v1, const scivector& v2) {
8443 return slsp_vv_geq<scivector_slice,scivector,cinterval>(v1,v2);
8444}
8445
8447
8450inline bool operator>=(const sivector_slice& v1, const scivector& v2) {
8451 return slsp_vv_geq<sivector_slice,scivector,cinterval>(v1,v2);
8452}
8453
8455
8458inline bool operator>=(const scivector& v1, const srvector_slice& v2) {
8459 return spsl_vv_geq<scivector,srvector_slice,cinterval>(v1,v2);
8460}
8461
8463
8466inline bool operator>=(const scivector& v1, const scvector_slice& v2) {
8467 return spsl_vv_geq<scivector,scvector_slice,cinterval>(v1,v2);
8468}
8469
8471
8474inline bool operator>=(const scivector& v1, const sivector_slice& v2) {
8475 return spsl_vv_geq<scivector,sivector_slice,cinterval>(v1,v2);
8476}
8477
8479
8482inline bool operator>=(const scivector& v1, const scivector_slice& v2) {
8483 return spsl_vv_geq<scivector,scivector_slice,cinterval>(v1,v2);
8484}
8485
8487
8490inline bool operator>=(const sivector& v1, const scivector_slice& v2) {
8491 return spsl_vv_geq<sivector,scivector_slice,cinterval>(v1,v2);
8492}
8493
8495
8498inline bool operator>=(const scivector_slice& v1, const rvector& v2) {
8499 return slf_vv_geq<scivector_slice,rvector,cinterval>(v1,v2);
8500}
8501
8503
8506inline bool operator>=(const scivector_slice& v1, const cvector& v2) {
8507 return slf_vv_geq<scivector_slice,cvector,cinterval>(v1,v2);
8508}
8509
8511
8514inline bool operator>=(const scivector_slice& v1, const ivector& v2) {
8515 return slf_vv_geq<scivector_slice,ivector,cinterval>(v1,v2);
8516}
8517
8519
8522inline bool operator>=(const scivector_slice& v1, const civector& v2) {
8523 return slf_vv_geq<scivector_slice,civector,cinterval>(v1,v2);
8524}
8525
8527
8530inline bool operator>=(const sivector_slice& v1, const civector& v2) {
8531 return slf_vv_geq<sivector_slice,civector,cinterval>(v1,v2);
8532}
8533
8535
8538inline bool operator>=(const civector& v1, const srvector_slice& v2) {
8539 return fsl_vv_geq<civector,srvector_slice,cinterval>(v1,v2);
8540}
8541
8543
8546inline bool operator>=(const civector& v1, const scvector_slice& v2) {
8547 return fsl_vv_geq<civector,scvector_slice,cinterval>(v1,v2);
8548}
8549
8551
8554inline bool operator>=(const civector& v1, const sivector_slice& v2) {
8555 return fsl_vv_geq<civector,sivector_slice,cinterval>(v1,v2);
8556}
8557
8559
8562inline bool operator>=(const civector& v1, const scivector_slice& v2) {
8563 return fsl_vv_geq<civector,scivector_slice,cinterval>(v1,v2);
8564}
8565
8567
8570inline bool operator>=(const ivector& v1, const scivector_slice& v2) {
8571 return fsl_vv_geq<ivector,scivector_slice,cinterval>(v1,v2);
8572}
8573
8575
8578inline bool operator>=(const scivector_slice& v1, const rvector_slice& v2) {
8579 return slf_vv_geq<scivector_slice,rvector_slice,cinterval>(v1,v2);
8580}
8581
8583
8586inline bool operator>=(const scivector_slice& v1, const ivector_slice& v2) {
8587 return slf_vv_geq<scivector_slice,ivector_slice,cinterval>(v1,v2);
8588}
8589
8591
8594inline bool operator>=(const scivector_slice& v1, const cvector_slice& v2) {
8595 return slf_vv_geq<scivector_slice,cvector_slice,cinterval>(v1,v2);
8596}
8597
8599
8602inline bool operator>=(const scivector_slice& v1, const civector_slice& v2) {
8603 return slf_vv_geq<scivector_slice,civector_slice,cinterval>(v1,v2);
8604}
8605
8607
8610inline bool operator>=(const sivector_slice& v1, const civector_slice& v2) {
8611 return slf_vv_geq<sivector_slice,civector_slice,cinterval>(v1,v2);
8612}
8613
8615
8618inline bool operator>=(const civector_slice& v1, const srvector_slice& v2) {
8619 return fsl_vv_geq<civector_slice,srvector_slice,cinterval>(v1,v2);
8620}
8621
8623
8626inline bool operator>=(const civector_slice& v1, const scvector_slice& v2) {
8627 return fsl_vv_geq<civector_slice,scvector_slice,cinterval>(v1,v2);
8628}
8629
8631
8634inline bool operator>=(const civector_slice& v1, const sivector_slice& v2) {
8635 return fsl_vv_geq<civector_slice,sivector_slice,cinterval>(v1,v2);
8636}
8637
8639
8642inline bool operator>=(const civector_slice& v1, const scivector_slice& v2) {
8643 return fsl_vv_geq<civector_slice,scivector_slice,cinterval>(v1,v2);
8644}
8645
8647
8650inline bool operator>=(const ivector_slice& v1, const scivector_slice& v2) {
8651 return fsl_vv_geq<ivector_slice,scivector_slice,cinterval>(v1,v2);
8652}
8653
8655
8660inline std::ostream& operator<<(std::ostream& os, const scivector_slice& v) {
8661 return sl_v_output<scivector_slice,cinterval>(os,v);
8662}
8663
8665
8670inline std::istream& operator>>(std::istream& is, scivector_slice& v) {
8671 return sl_v_input<scivector_slice,cinterval>(is,v);
8672}
8673
8675
8678inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const rvector& v2) {
8679 slf_vv_accu<cidotprecision,scivector_slice,rvector,sparse_cidot>(dot,v1,v2);
8680}
8681
8683
8686inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const cvector& v2) {
8687 slf_vv_accu<cidotprecision,scivector_slice,cvector,sparse_cidot>(dot,v1,v2);
8688}
8689
8691
8694inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const ivector& v2) {
8695 slf_vv_accu<cidotprecision,scivector_slice,ivector,sparse_cidot>(dot,v1,v2);
8696}
8697
8699
8702inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const civector& v2) {
8703 slf_vv_accu<cidotprecision,scivector_slice,civector,sparse_cidot>(dot,v1,v2);
8704}
8705
8707
8710inline void accumulate(cidotprecision& dot, const srvector_slice& v1, const civector& v2) {
8711 slf_vv_accu<cidotprecision,srvector_slice,civector,sparse_cidot>(dot,v1,v2);
8712}
8713
8715
8718inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const civector& v2) {
8719 slf_vv_accu<cidotprecision,sivector_slice,civector,sparse_cidot>(dot,v1,v2);
8720}
8721
8723
8726inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const civector& v2) {
8727 slf_vv_accu<cidotprecision,scvector_slice,civector,sparse_cidot>(dot,v1,v2);
8728}
8729
8731
8734inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const ivector& v2) {
8735 slf_vv_accu<cidotprecision,scvector_slice,ivector,sparse_cidot>(dot,v1,v2);
8736}
8737
8739
8742inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const cvector& v2) {
8743 slf_vv_accu<cidotprecision,sivector_slice,cvector,sparse_cidot>(dot,v1,v2);
8744}
8745
8747
8750inline void accumulate(cidotprecision& dot, const civector& v1, const srvector_slice& v2) {
8751 fsl_vv_accu<cidotprecision,civector,srvector_slice,sparse_cidot>(dot,v1,v2);
8752}
8753
8755
8758inline void accumulate(cidotprecision& dot, const civector& v1, const scvector_slice& v2) {
8759 fsl_vv_accu<cidotprecision,civector,scvector_slice,sparse_cidot>(dot,v1,v2);
8760}
8761
8763
8766inline void accumulate(cidotprecision& dot, const civector& v1, const sivector_slice& v2) {
8767 fsl_vv_accu<cidotprecision,civector,sivector_slice,sparse_cidot>(dot,v1,v2);
8768}
8769
8771
8774inline void accumulate(cidotprecision& dot, const civector& v1, const scivector_slice& v2) {
8775 fsl_vv_accu<cidotprecision,civector,scivector_slice,sparse_cidot>(dot,v1,v2);
8776}
8777
8779
8782inline void accumulate(cidotprecision& dot, const rvector& v1, const scivector_slice& v2) {
8783 fsl_vv_accu<cidotprecision,rvector,scivector_slice,sparse_cidot>(dot,v1,v2);
8784}
8785
8787
8790inline void accumulate(cidotprecision& dot, const cvector& v1, const scivector_slice& v2) {
8791 fsl_vv_accu<cidotprecision,cvector,scivector_slice,sparse_cidot>(dot,v1,v2);
8792}
8793
8795
8798inline void accumulate(cidotprecision& dot, const ivector& v1, const scivector_slice& v2) {
8799 fsl_vv_accu<cidotprecision,ivector,scivector_slice,sparse_cidot>(dot,v1,v2);
8800}
8801
8803
8806inline void accumulate(cidotprecision& dot, const cvector& v1, const sivector_slice& v2) {
8807 fsl_vv_accu<cidotprecision,cvector,sivector_slice,sparse_cidot>(dot,v1,v2);
8808}
8809
8811
8814inline void accumulate(cidotprecision& dot, const ivector& v1, const scvector_slice& v2) {
8815 fsl_vv_accu<cidotprecision,ivector,scvector_slice,sparse_cidot>(dot,v1,v2);
8816}
8817
8819
8822inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const rvector_slice& v2) {
8823 slf_vv_accu<cidotprecision,scivector_slice,rvector_slice,sparse_cidot>(dot,v1,v2);
8824}
8825
8827
8830inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const ivector_slice& v2) {
8831 slf_vv_accu<cidotprecision,scivector_slice,ivector_slice,sparse_cidot>(dot,v1,v2);
8832}
8833
8835
8838inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const cvector_slice& v2) {
8839 slf_vv_accu<cidotprecision,scivector_slice,cvector_slice,sparse_cidot>(dot,v1,v2);
8840}
8841
8843
8846inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const civector_slice& v2) {
8847 slf_vv_accu<cidotprecision,scivector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8848}
8849
8851
8854inline void accumulate(cidotprecision& dot, const srvector_slice& v1, const civector_slice& v2) {
8855 slf_vv_accu<cidotprecision,srvector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8856}
8857
8859
8862inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const civector_slice& v2) {
8863 slf_vv_accu<cidotprecision,scvector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8864}
8865
8867
8870inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const civector_slice& v2) {
8871 slf_vv_accu<cidotprecision,sivector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
8872}
8873
8875
8878inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const ivector_slice& v2) {
8879 slf_vv_accu<cidotprecision,scvector_slice,ivector_slice,sparse_cidot>(dot,v1,v2);
8880}
8881
8883
8886inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const cvector_slice& v2) {
8887 slf_vv_accu<cidotprecision,sivector_slice,cvector_slice,sparse_cidot>(dot,v1,v2);
8888}
8889
8891
8894inline void accumulate(cidotprecision& dot, const civector_slice& v1, const srvector_slice& v2) {
8895 fsl_vv_accu<cidotprecision,civector_slice,srvector_slice,sparse_cidot>(dot,v1,v2);
8896}
8897
8899
8902inline void accumulate(cidotprecision& dot, const civector_slice& v1, const scvector_slice& v2) {
8903 fsl_vv_accu<cidotprecision,civector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
8904}
8905
8907
8910inline void accumulate(cidotprecision& dot, const civector_slice& v1, const sivector_slice& v2) {
8911 fsl_vv_accu<cidotprecision,civector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
8912}
8913
8915
8918inline void accumulate(cidotprecision& dot, const civector_slice& v1, const scivector_slice& v2) {
8919 fsl_vv_accu<cidotprecision,civector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8920}
8921
8923
8926inline void accumulate(cidotprecision& dot, const rvector_slice& v1, const scivector_slice& v2) {
8927 fsl_vv_accu<cidotprecision,rvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8928}
8929
8931
8934inline void accumulate(cidotprecision& dot, const ivector_slice& v1, const scivector_slice& v2) {
8935 fsl_vv_accu<cidotprecision,ivector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8936}
8937
8939
8942inline void accumulate(cidotprecision& dot, const cvector_slice& v1, const scivector_slice& v2) {
8943 fsl_vv_accu<cidotprecision,cvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
8944}
8945
8947
8950inline void accumulate(cidotprecision& dot, const cvector_slice& v1, const sivector_slice& v2) {
8951 fsl_vv_accu<cidotprecision,cvector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
8952}
8953
8955
8958inline void accumulate(cidotprecision& dot, const ivector_slice& v1, const scvector_slice& v2) {
8959 fsl_vv_accu<cidotprecision,ivector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
8960}
8961
8963
8966inline void accumulate(cidotprecision& dot, const scivector& v1, const srvector_slice& v2) {
8967 spsl_vv_accu<cidotprecision,scivector,srvector_slice,sparse_cidot>(dot,v1,v2);
8968}
8969
8971
8974inline void accumulate(cidotprecision& dot, const scivector& v1, const scvector_slice& v2) {
8975 spsl_vv_accu<cidotprecision,scivector,scvector_slice,sparse_cidot>(dot,v1,v2);
8976}
8977
8979
8982inline void accumulate(cidotprecision& dot, const scivector& v1, const sivector_slice& v2) {
8983 spsl_vv_accu<cidotprecision,scivector,sivector_slice,sparse_cidot>(dot,v1,v2);
8984}
8985
8987
8990inline void accumulate(cidotprecision& dot, const scivector& v1, const scivector_slice& v2) {
8991 spsl_vv_accu<cidotprecision,scivector,scivector_slice,sparse_cidot>(dot,v1,v2);
8992}
8993
8995
8998inline void accumulate(cidotprecision& dot, const srvector& v1, const scivector_slice& v2) {
8999 spsl_vv_accu<cidotprecision,srvector,scivector_slice,sparse_cidot>(dot,v1,v2);
9000}
9001
9003
9006inline void accumulate(cidotprecision& dot, const scvector& v1, const scivector_slice& v2) {
9007 spsl_vv_accu<cidotprecision,scvector,scivector_slice,sparse_cidot>(dot,v1,v2);
9008}
9009
9011
9014inline void accumulate(cidotprecision& dot, const sivector& v1, const scivector_slice& v2) {
9015 spsl_vv_accu<cidotprecision,sivector,scivector_slice,sparse_cidot>(dot,v1,v2);
9016}
9017
9019
9022inline void accumulate(cidotprecision& dot, const scvector& v1, const sivector_slice& v2) {
9023 spsl_vv_accu<cidotprecision,scvector,sivector_slice,sparse_cidot>(dot,v1,v2);
9024}
9025
9027
9030inline void accumulate(cidotprecision& dot, const sivector& v1, const scvector_slice& v2) {
9031 spsl_vv_accu<cidotprecision,sivector,scvector_slice,sparse_cidot>(dot,v1,v2);
9032}
9033
9035
9038inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const srvector& v2) {
9039 slsp_vv_accu<cidotprecision,scivector_slice,srvector,sparse_cidot>(dot,v1,v2);
9040}
9041
9043
9046inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const scvector& v2) {
9047 slsp_vv_accu<cidotprecision,scivector_slice,scvector,sparse_cidot>(dot,v1,v2);
9048}
9049
9051
9054inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const sivector& v2) {
9055 slsp_vv_accu<cidotprecision,scivector_slice,sivector,sparse_cidot>(dot,v1,v2);
9056}
9057
9059
9062inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const scivector& v2) {
9063 slsp_vv_accu<cidotprecision,scivector_slice,scivector,sparse_cidot>(dot,v1,v2);
9064}
9065
9067
9070inline void accumulate(cidotprecision& dot, const srvector_slice& v1, const scivector& v2) {
9071 slsp_vv_accu<cidotprecision,srvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9072}
9073
9075
9078inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const scivector& v2) {
9079 slsp_vv_accu<cidotprecision,sivector_slice,scivector,sparse_cidot>(dot,v1,v2);
9080}
9081
9083
9086inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const scivector& v2) {
9087 slsp_vv_accu<cidotprecision,scvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9088}
9089
9091
9094inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const sivector& v2) {
9095 slsp_vv_accu<cidotprecision,scvector_slice,sivector,sparse_cidot>(dot,v1,v2);
9096}
9097
9099
9102inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const scvector& v2) {
9103 slsp_vv_accu<cidotprecision,sivector_slice,scvector,sparse_cidot>(dot,v1,v2);
9104}
9105
9107
9110inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const srvector_slice& v2) {
9111 slsl_vv_accu<cidotprecision,scivector_slice,srvector_slice,sparse_cidot>(dot,v1,v2);
9112}
9113
9115
9118inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const scvector_slice& v2) {
9119 slsl_vv_accu<cidotprecision,scivector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
9120}
9121
9123
9126inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const sivector_slice& v2) {
9127 slsl_vv_accu<cidotprecision,scivector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
9128}
9129
9131
9134inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const scivector_slice& v2) {
9135 slsl_vv_accu<cidotprecision,scivector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9136}
9137
9139
9142inline void accumulate(cidotprecision& dot, const srvector_slice& v1, const scivector_slice& v2) {
9143 slsl_vv_accu<cidotprecision,srvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9144}
9145
9147
9150inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const scivector_slice& v2) {
9151 slsl_vv_accu<cidotprecision,scvector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9152}
9153
9155
9158inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const scivector_slice& v2) {
9159 slsl_vv_accu<cidotprecision,sivector_slice,scivector_slice,sparse_cidot>(dot,v1,v2);
9160}
9161
9163
9166inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const scvector_slice& v2) {
9167 slsl_vv_accu<cidotprecision,sivector_slice,scvector_slice,sparse_cidot>(dot,v1,v2);
9168}
9169
9171
9174inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const sivector_slice& v2) {
9175 slsl_vv_accu<cidotprecision,scvector_slice,sivector_slice,sparse_cidot>(dot,v1,v2);
9176}
9177
9179
9182inline void accumulate(cidotprecision& dot, const scivector& v1, const cvector& v2) {
9183 spf_vv_accu<cidotprecision,scivector,cvector,sparse_cidot>(dot,v1,v2);
9184}
9185
9187
9190inline void accumulate(cidotprecision& dot, const scivector& v1, const rvector& v2) {
9191 spf_vv_accu<cidotprecision,scivector,rvector,sparse_cidot>(dot,v1,v2);
9192}
9193
9195
9198inline void accumulate(cidotprecision& dot, const scivector& v1, const ivector& v2) {
9199 spf_vv_accu<cidotprecision,scivector,ivector,sparse_cidot>(dot,v1,v2);
9200}
9201
9203
9206inline void accumulate(cidotprecision& dot, const scivector& v1, const civector& v2) {
9207 spf_vv_accu<cidotprecision,scivector,civector,sparse_cidot>(dot,v1,v2);
9208}
9209
9211
9214inline void accumulate(cidotprecision& dot, const scvector& v1, const civector& v2) {
9215 spf_vv_accu<cidotprecision,scvector,civector,sparse_cidot>(dot,v1,v2);
9216}
9217
9219
9222inline void accumulate(cidotprecision& dot, const srvector& v1, const civector& v2) {
9223 spf_vv_accu<cidotprecision,srvector,civector,sparse_cidot>(dot,v1,v2);
9224}
9225
9227
9230inline void accumulate(cidotprecision& dot, const sivector& v1, const civector& v2) {
9231 spf_vv_accu<cidotprecision,sivector,civector,sparse_cidot>(dot,v1,v2);
9232}
9233
9235
9238inline void accumulate(cidotprecision& dot, const scvector& v1, const ivector& v2) {
9239 spf_vv_accu<cidotprecision,scvector,ivector,sparse_cidot>(dot,v1,v2);
9240}
9241
9243
9246inline void accumulate(cidotprecision& dot, const sivector& v1, const cvector& v2) {
9247 spf_vv_accu<cidotprecision,sivector,cvector,sparse_cidot>(dot,v1,v2);
9248}
9249
9251
9254inline void accumulate(cidotprecision& dot, const rvector& v1, const scivector& v2) {
9255 fsp_vv_accu<cidotprecision,rvector,scivector,sparse_cidot>(dot,v1,v2);
9256}
9257
9259
9262inline void accumulate(cidotprecision& dot, const cvector& v1, const scivector& v2) {
9263 fsp_vv_accu<cidotprecision,cvector,scivector,sparse_cidot>(dot,v1,v2);
9264}
9265
9267
9270inline void accumulate(cidotprecision& dot, const ivector& v1, const scivector& v2) {
9271 fsp_vv_accu<cidotprecision,ivector,scivector,sparse_cidot>(dot,v1,v2);
9272}
9273
9275
9278inline void accumulate(cidotprecision& dot, const civector& v1, const scivector& v2) {
9279 fsp_vv_accu<cidotprecision,civector,scivector,sparse_cidot>(dot,v1,v2);
9280}
9281
9283
9286inline void accumulate(cidotprecision& dot, const civector& v1, const srvector& v2) {
9287 fsp_vv_accu<cidotprecision,civector,srvector,sparse_cidot>(dot,v1,v2);
9288}
9289
9291
9294inline void accumulate(cidotprecision& dot, const civector& v1, const scvector& v2) {
9295 fsp_vv_accu<cidotprecision,civector,scvector,sparse_cidot>(dot,v1,v2);
9296}
9297
9299
9302inline void accumulate(cidotprecision& dot, const civector& v1, const sivector& v2) {
9303 fsp_vv_accu<cidotprecision,civector,sivector,sparse_cidot>(dot,v1,v2);
9304}
9305
9307
9310inline void accumulate(cidotprecision& dot, const ivector& v1, const scvector& v2) {
9311 fsp_vv_accu<cidotprecision,ivector,scvector,sparse_cidot>(dot,v1,v2);
9312}
9313
9315
9318inline void accumulate(cidotprecision& dot, const cvector& v1, const sivector& v2) {
9319 fsp_vv_accu<cidotprecision,cvector,sivector,sparse_cidot>(dot,v1,v2);
9320}
9321
9323
9326inline void accumulate(cidotprecision& dot, const scivector& v1, const cvector_slice& v2) {
9327 spf_vv_accu<cidotprecision,scivector,cvector_slice,sparse_cidot>(dot,v1,v2);
9328}
9329
9331
9334inline void accumulate(cidotprecision& dot, const scivector& v1, const rvector_slice& v2) {
9335 spf_vv_accu<cidotprecision,scivector,rvector_slice,sparse_cidot>(dot,v1,v2);
9336}
9337
9339
9342inline void accumulate(cidotprecision& dot, const scivector& v1, const ivector_slice& v2) {
9343 spf_vv_accu<cidotprecision,scivector,ivector_slice,sparse_cidot>(dot,v1,v2);
9344}
9345
9347
9350inline void accumulate(cidotprecision& dot, const scivector& v1, const civector_slice& v2) {
9351 spf_vv_accu<cidotprecision,scivector,civector_slice,sparse_cidot>(dot,v1,v2);
9352}
9353
9355
9358inline void accumulate(cidotprecision& dot, const scvector& v1, const civector_slice& v2) {
9359 spf_vv_accu<cidotprecision,scvector,civector_slice,sparse_cidot>(dot,v1,v2);
9360}
9361
9363
9366inline void accumulate(cidotprecision& dot, const srvector& v1, const civector_slice& v2) {
9367 spf_vv_accu<cidotprecision,srvector,civector_slice,sparse_cidot>(dot,v1,v2);
9368}
9369
9371
9374inline void accumulate(cidotprecision& dot, const sivector& v1, const civector_slice& v2) {
9375 spf_vv_accu<cidotprecision,sivector,civector_slice,sparse_cidot>(dot,v1,v2);
9376}
9377
9379
9382inline void accumulate(cidotprecision& dot, const scvector& v1, const ivector_slice& v2) {
9383 spf_vv_accu<cidotprecision,scvector,ivector_slice,sparse_cidot>(dot,v1,v2);
9384}
9385
9387
9390inline void accumulate(cidotprecision& dot, const sivector& v1, const cvector_slice& v2) {
9391 spf_vv_accu<cidotprecision,sivector,cvector_slice,sparse_cidot>(dot,v1,v2);
9392}
9393
9395
9398inline void accumulate(cidotprecision& dot, const rvector_slice& v1, const scivector& v2) {
9399 fsp_vv_accu<cidotprecision,rvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9400}
9401
9403
9406inline void accumulate(cidotprecision& dot, const cvector_slice& v1, const scivector& v2) {
9407 fsp_vv_accu<cidotprecision,cvector_slice,scivector,sparse_cidot>(dot,v1,v2);
9408}
9409
9411
9414inline void accumulate(cidotprecision& dot, const ivector_slice& v1, const scivector& v2) {
9415 fsp_vv_accu<cidotprecision,ivector_slice,scivector,sparse_cidot>(dot,v1,v2);
9416}
9417
9419
9422inline void accumulate(cidotprecision& dot, const civector_slice& v1, const scivector& v2) {
9423 fsp_vv_accu<cidotprecision,civector_slice,scivector,sparse_cidot>(dot,v1,v2);
9424}
9425
9427
9430inline void accumulate(cidotprecision& dot, const civector_slice& v1, const srvector& v2) {
9431 fsp_vv_accu<cidotprecision,civector_slice,srvector,sparse_cidot>(dot,v1,v2);
9432}
9433
9435
9438inline void accumulate(cidotprecision& dot, const civector_slice& v1, const scvector& v2) {
9439 fsp_vv_accu<cidotprecision,civector_slice,scvector,sparse_cidot>(dot,v1,v2);
9440}
9441
9443
9446inline void accumulate(cidotprecision& dot, const civector_slice& v1, const sivector& v2) {
9447 fsp_vv_accu<cidotprecision,civector_slice,sivector,sparse_cidot>(dot,v1,v2);
9448}
9449
9451
9454inline void accumulate(cidotprecision& dot, const ivector_slice& v1, const scvector& v2) {
9455 fsp_vv_accu<cidotprecision,ivector_slice,scvector,sparse_cidot>(dot,v1,v2);
9456}
9457
9459
9462inline void accumulate(cidotprecision& dot, const cvector_slice& v1, const sivector& v2) {
9463 fsp_vv_accu<cidotprecision,cvector_slice,sivector,sparse_cidot>(dot,v1,v2);
9464}
9465
9467
9470inline void accumulate(cidotprecision& dot, const scivector& v1, const srvector& v2) {
9471 spsp_vv_accu<cidotprecision,scivector,srvector,sparse_cidot>(dot,v1,v2);
9472}
9473
9475
9478inline void accumulate(cidotprecision& dot, const scivector& v1, const scvector& v2) {
9479 spsp_vv_accu<cidotprecision,scivector,scvector,sparse_cidot>(dot,v1,v2);
9480}
9481
9483
9486inline void accumulate(cidotprecision& dot, const scivector& v1, const sivector& v2) {
9487 spsp_vv_accu<cidotprecision,scivector,sivector,sparse_cidot>(dot,v1,v2);
9488}
9489
9491
9494inline void accumulate(cidotprecision& dot, const scivector& v1, const scivector& v2) {
9495 spsp_vv_accu<cidotprecision,scivector,scivector,sparse_cidot>(dot,v1,v2);
9496}
9497
9499
9502inline void accumulate(cidotprecision& dot, const srvector& v1, const scivector& v2) {
9503 spsp_vv_accu<cidotprecision,srvector,scivector,sparse_cidot>(dot,v1,v2);
9504}
9505
9507
9510inline void accumulate(cidotprecision& dot, const scvector& v1, const scivector& v2) {
9511 spsp_vv_accu<cidotprecision,scvector,scivector,sparse_cidot>(dot,v1,v2);
9512}
9513
9515
9518inline void accumulate(cidotprecision& dot, const sivector& v1, const scivector& v2) {
9519 spsp_vv_accu<cidotprecision,sivector,scivector,sparse_cidot>(dot,v1,v2);
9520}
9521
9523
9526inline void accumulate(cidotprecision& dot, const scvector& v1, const sivector& v2) {
9527 spsp_vv_accu<cidotprecision,scvector,sivector,sparse_cidot>(dot,v1,v2);
9528}
9529
9531
9534inline void accumulate(cidotprecision& dot, const sivector& v1, const scvector& v2) {
9535 spsp_vv_accu<cidotprecision,sivector,scvector,sparse_cidot>(dot,v1,v2);
9536}
9537
9538} //namespace cxsc
9539
9540#include "sparsevector.inl"
9541
9542#endif
The Data Type cidotprecision.
Definition: cidot.hpp:58
The Scalar Type cinterval.
Definition: cinterval.hpp:55
The Data Type civector_slice.
Definition: civector.hpp:1015
civector_slice & operator|=(const civector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: civector.inl:994
civector_slice & operator&=(const civector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: civector.inl:1051
civector_slice & operator+=(const civector &rv) noexcept
Implementation of addition and allocation operation.
Definition: civector.inl:878
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
civector_slice & operator-=(const civector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: civector.inl:937
The Data Type civector.
Definition: civector.hpp:57
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
Definition: civector.inl:339
civector() noexcept
Constructor of class civector.
Definition: civector.inl:31
The Scalar Type complex.
Definition: complex.hpp:50
The Data Type cvector_slice.
Definition: cvector.hpp:845
The Data Type cvector.
Definition: cvector.hpp:58
The Scalar Type interval.
Definition: interval.hpp:55
The Data Type intmatrix.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector_slice.
Definition: ivector.hpp:963
The Data Type ivector.
Definition: ivector.hpp:55
The Scalar Type real.
Definition: real.hpp:114
The Data Type rvector_slice.
Definition: rvector.hpp:1064
The Data Type rvector.
Definition: rvector.hpp:58
Represents a row or column vector of a sparse matrix.
Definition: scimatrix.hpp:9628
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
scivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4411
scivector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4366
friend scvector Sup(const scivector_slice &)
Returns the supremum of the vector slice v.
Definition: scivector.hpp:4791
scivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4242
scivector_slice & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4351
scivector_slice & operator&=(const ivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4551
scivector_slice & operator&=(const scivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4566
friend srvector InfRe(const scivector_slice &)
Returns the real part of the infimum of the vector slice v.
Definition: scivector.hpp:4796
scivector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4426
scivector_slice & operator|=(const scivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4536
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.
Definition: scivector.hpp:4147
scivector_slice & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4386
scivector_slice & operator=(const scivector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4217
scivector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4187
friend int Lb(const scivector_slice &)
Returns the lower index bound of the vector slice v.
Definition: scivector.hpp:4766
scivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4202
scivector_slice & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4416
scivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4192
scivector_slice & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4431
friend srvector SupIm(const scivector_slice &)
Returns the imaginary part of the supremum of the vector slice v.
Definition: scivector.hpp:4811
friend sivector abs(const scivector_slice &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: scivector.hpp:4827
scivector_slice & operator&=(const sivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4571
scivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: scivector.hpp:4262
scivector_slice & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4356
scivector_slice & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4346
scivector_slice & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4331
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...
Definition: scivector.hpp:4282
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: scivector.hpp:4135
scivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4182
scivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4162
scivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4401
scivector_slice & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4316
scivector_slice & operator|=(const civector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4496
scivector_slice & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4406
friend srvector InfIm(const scivector_slice &)
Returns the imaginary part of the infimum of the vector slice v.
Definition: scivector.hpp:4801
friend scvector diam(const scivector_slice &)
Computes the diameter of v.
Definition: scivector.hpp:4849
scivector_slice & operator|=(const srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4501
friend sivector Re(const scivector_slice &)
Returns the real part of v.
Definition: scivector.hpp:4776
scivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
Definition: scivector.hpp:4272
scivector_slice & operator|=(const rvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4461
friend scvector mid(const scivector_slice &)
Computes the midpoint vector of v.
Definition: scivector.hpp:4838
scivector_slice & operator-=(const scvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4446
scivector_slice & operator+=(const sivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4371
scivector_slice & operator&=(const ivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4541
scivector_slice & operator|=(const scvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4526
scivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4172
scivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4531
scivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4451
scivector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4207
friend srvector SupRe(const scivector_slice &)
Returns the real part of the supremum of the vector slice v.
Definition: scivector.hpp:4806
friend scvector Inf(const scivector_slice &)
Returns the infimum vector slice v.
Definition: scivector.hpp:4786
scivector_slice & operator&=(const sivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4561
scivector_slice & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4391
scivector_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4481
scivector_slice & operator*=(const cinterval &s)
Operator for multiplication with a complex interval, result is assigned to the vector slice.
Definition: scivector.hpp:4277
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
Definition: scivector.hpp:4103
scivector_slice & operator-=(const scivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4456
scivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4222
scivector_slice & operator=(const cinterval &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4177
scivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4521
scivector_slice & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4336
scivector_slice & operator/=(const interval &s)
Operator for division of each element of the vector slice with an interval, result is assigned to the...
Definition: scivector.hpp:4291
scivector_slice & operator|=(const scvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4506
friend int VecLen(const scivector_slice &)
Returns the length of the vector slice.
Definition: scivector.hpp:4860
scivector_slice & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4306
scivector_slice & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4396
scivector_slice & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4486
scivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4441
scivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4421
scivector_slice & operator+=(const scivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4376
scivector_slice & operator&=(const scivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4576
scivector_slice & operator=(const scivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4197
scivector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4247
scivector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4341
scivector_slice & operator=(const civector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4257
scivector_slice & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4326
scivector_slice & operator|=(const cvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4471
scivector_slice & operator|=(const ivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4466
scivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4212
scivector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4227
friend scivector conj(const scivector_slice &)
Returns the conjugate complex of v.
Definition: scivector.hpp:4816
scivector_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4167
scivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4232
friend sivector Im(const scivector_slice &)
Returns the imaginary part of v.
Definition: scivector.hpp:4781
scivector_slice & operator=(const civector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4237
scivector_slice & operator&=(const civector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4556
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...
Definition: scivector.hpp:4287
scivector_slice & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4311
scivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4252
scivector_slice & operator&=(const civector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4546
scivector_slice & operator|=(const scivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4516
scivector_slice & operator/=(const cinterval &s)
Operator for division of each element of the vector slice with a complex interval,...
Definition: scivector.hpp:4296
scivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4381
scivector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4321
scivector_slice & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: scivector.hpp:4267
scivector_slice & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4491
scivector_slice & operator|=(const civector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4476
scivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4301
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
Definition: scivector.hpp:4112
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
Definition: scivector.hpp:4098
scivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4511
scivector_slice & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4436
friend int Ub(const scivector_slice &)
Returns the upper index bound of the vector slice v.
Definition: scivector.hpp:4771
scivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4361
A sparse complex interval vector.
Definition: scivector.hpp:62
friend scvector diam(const scivector &)
Computes the diameter of v.
Definition: scivector.hpp:897
scivector & operator|=(const srvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:628
scivector & operator/=(const complex &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition: scivector.hpp:453
scivector(const int s)
Constructor for creating an empty vector of size s.
Definition: scivector.hpp:76
scivector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:289
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...
Definition: scivector.hpp:129
scivector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:548
scivector & operator|=(const cvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:593
scivector(const srvector &v)
Creates a sparse complex interval vector out of a sparse real vector.
Definition: scivector.hpp:140
scivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:638
scivector & operator=(const scvector &v)
Assign a sparse complex vector to a sparse complex interval vector.
Definition: scivector.hpp:258
scivector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:274
scivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:488
friend srvector InfRe(const scivector &)
Returns the infimum of the real part of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:952
scivector & operator=(const civector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:304
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
Definition: scivector.hpp:221
std::vector< cinterval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: scivector.hpp:192
scivector()
Default constructor, creates an empty vector of size 0
Definition: scivector.hpp:72
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: scivector.hpp:202
friend int Ub(const scivector &)
Returns the upper index bound of the vector v.
Definition: scivector.hpp:837
scivector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:269
scivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition: scivector.hpp:417
friend sivector Re(const scivector &)
Returns the real part of the vector v.
Definition: scivector.hpp:908
scivector & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition: scivector.hpp:433
scivector(const scvector &v)
Creates a sparse complex interval vector out of a sparse complex vector.
Definition: scivector.hpp:147
scivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:588
scivector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:513
friend srvector SupRe(const scivector &)
Returns the supremum of the real part of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:974
friend int Lb(const scivector &)
Returns the lower index bound of the vector v.
Definition: scivector.hpp:832
scivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:528
friend void SetUb(scivector &, const int)
Sets the upper index bound of the vector v to i.
Definition: scivector.hpp:826
friend srvector SupIm(const scivector &)
Returns the supremum of the imaginary part of the complex interval vector as a new sparse point vecto...
Definition: scivector.hpp:985
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
Definition: scivector.hpp:886
scivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:578
scivector & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:503
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
Definition: scivector.hpp:342
friend scvector Sup(const scivector &)
Returns the supremum of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:941
scivector & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:533
scivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition: scivector.hpp:394
scivector & operator*=(const cinterval &s)
Operator for multiplication with an interval, result is assigned to the vector.
Definition: scivector.hpp:443
scivector & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:498
scivector & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:483
friend void SetLb(scivector &, const int)
Sets the lower index bound of the vector v to i.
Definition: scivector.hpp:817
scivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:598
scivector & operator=(const sivector &v)
Assign a sparse interval vector to a sparse complex interval vector.
Definition: scivector.hpp:247
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: scivector.hpp:216
scivector & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:613
scivector & operator=(const interval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:279
scivector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
Definition: scivector.hpp:82
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: scivector.hpp:183
scivector & operator|=(const scivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:643
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: scivector.hpp:376
scivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:558
scivector & operator=(const ivector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:299
scivector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:508
scivector & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:523
scivector & operator&=(const civector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:653
scivector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:473
scivector & operator|=(const civector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:623
friend srvector InfIm(const scivector &)
Returns the infimum of the imaginary part of the complex interval vector as a new sparse point vector...
Definition: scivector.hpp:963
friend sivector abs(const scivector &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: scivector.hpp:864
scivector & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:563
scivector & operator|=(const scvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:633
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:930
scivector & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:543
const std::vector< cinterval > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: scivector.hpp:211
scivector & operator=(const srvector &v)
Assign a sparse real vector to a sparse complex interval vector.
Definition: scivector.hpp:236
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.
Definition: scivector.hpp:319
scivector & operator/=(const interval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
Definition: scivector.hpp:458
scivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
Definition: scivector.hpp:438
scivector & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:583
scivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:568
scivector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: scivector.hpp:108
scivector & operator/=(const cinterval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
Definition: scivector.hpp:463
scivector & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:478
scivector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:468
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.
Definition: scivector.hpp:309
scivector & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:518
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.
Definition: scivector.hpp:324
scivector & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:553
scivector(const sivector &v)
Creates a sparse complex interval vector out of a sparse interval vector.
Definition: scivector.hpp:154
scivector & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:608
scivector & operator=(const cinterval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:284
friend scivector conj(const scivector &)
Returns the complex conjugate of v.
Definition: scivector.hpp:875
scivector & operator&=(const ivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:648
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...
Definition: scivector.hpp:118
scivector(const civector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: scivector.hpp:88
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
Definition: scivector.hpp:919
scivector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:573
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: scivector.hpp:364
scivector & operator&=(const civector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:663
scivector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:493
scivector(const cvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: scivector.hpp:98
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.
Definition: scivector.hpp:314
scivector & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:618
scivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:538
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: scivector.hpp:226
scivector & operator&=(const ivector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:658
scivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector
Definition: scivector.hpp:428
scivector & operator=(const cvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:294
scivector & operator&=(const sivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:668
scivector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition: scivector.hpp:448
friend int VecLen(const scivector &)
Returns the length of the vector (the dimension)
Definition: scivector.hpp:996
scivector & operator|=(const civector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:603
scivector & operator&=(const scivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:673
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: scvector.hpp:178
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
A sparse interval vector.
Definition: sivector.hpp:59
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: sivector.hpp:181
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
A sparse real vector.
Definition: srvector.hpp:58
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: srvector.hpp:160
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156