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.
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.
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.
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.
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.
Helper class for slices of sparse vectors.
friend sivector abs(const scivector_slice &)
Computes the component-wise absolute values as the interval hull of for a vector v.
scivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
friend srvector SupIm(const scivector_slice &)
Returns the imaginary part of the supremum of the vector slice v.
friend int Lb(const scivector_slice &)
Returns the lower index bound of the vector slice v.
scivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator&=(const ivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator&=(const scivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
friend scvector Sup(const scivector_slice &)
Returns the supremum of the vector slice v.
scivector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const scivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
scivector_slice & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend int VecLen(const scivector_slice &)
Returns the length of the vector slice.
scivector_slice & operator=(const scivector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator&=(const sivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
scivector_slice & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator/=(const real &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
scivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const civector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
friend scvector diam(const scivector_slice &)
Computes the diameter of v.
scivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
friend scvector Inf(const scivector_slice &)
Returns the infimum vector slice v.
scivector_slice & operator|=(const rvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const scvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const sivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator&=(const ivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const scvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator&=(const sivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator*=(const cinterval &s)
Operator for multiplication with a complex interval, result is assigned to the vector slice.
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
scivector_slice & operator-=(const scivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const cinterval &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
friend srvector SupRe(const scivector_slice &)
Returns the real part of the supremum of the vector slice v.
scivector_slice & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator/=(const interval &s)
Operator for division of each element of the vector slice with an interval, result is assigned to the...
friend int Ub(const scivector_slice &)
Returns the upper index bound of the vector slice v.
scivector_slice & operator|=(const scvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const scivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator&=(const scivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
friend sivector Re(const scivector_slice &)
Returns the real part of v.
scivector_slice & operator=(const scivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const civector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const cvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const ivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
scivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator=(const civector &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator&=(const civector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator/=(const complex &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
friend scivector conj(const scivector_slice &)
Returns the conjugate complex of v.
scivector_slice & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
scivector_slice & operator&=(const civector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const scivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator/=(const cinterval &s)
Operator for division of each element of the vector slice with a complex interval,...
scivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scivector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scivector_slice & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
scivector_slice & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator|=(const civector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
friend srvector InfRe(const scivector_slice &)
Returns the real part of the infimum of the vector slice v.
scivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
friend scvector mid(const scivector_slice &)
Computes the midpoint vector of v.
friend sivector Im(const scivector_slice &)
Returns the imaginary part of v.
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
scivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
scivector_slice & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend srvector InfIm(const scivector_slice &)
Returns the imaginary part of the infimum of the vector slice v.
scivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
A sparse complex interval vector.
Definition scivector.hpp:62
scivector & operator|=(const srvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator/=(const complex &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
scivector(const int s)
Constructor for creating an empty vector of size s.
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.
scivector(const int n, const int nnz, const int *index, const cinterval *values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
scivector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator|=(const cvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
scivector(const srvector &v)
Creates a sparse complex interval vector out of a sparse real vector.
scivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const scvector &v)
Assign a sparse complex vector to a sparse complex interval vector.
scivector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
scivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator=(const civector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
std::vector< cinterval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
scivector()
Default constructor, creates an empty vector of size 0
Definition scivector.hpp:72
friend void SetLb(scivector &, const int)
Sets the lower index bound of the vector v to i.
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
scivector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
scivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
scivector & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector.
scivector(const scvector &v)
Creates a sparse complex interval vector out of a sparse complex vector.
scivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
friend int Lb(const scivector &)
Returns the lower index bound of the vector v.
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
friend scvector diam(const scivector &)
Computes the diameter of v.
scivector & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
friend srvector SupIm(const scivector &)
Returns the supremum of the imaginary part of the complex interval vector as a new sparse point vecto...
scivector & operator*=(const cinterval &s)
Operator for multiplication with an interval, result is assigned to the vector.
scivector & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const sivector &v)
Assign a sparse interval vector to a sparse complex interval vector.
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
scivector & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const interval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
scivector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
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.
scivector & operator|=(const scivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
friend int Ub(const scivector &)
Returns the upper index bound of the vector v.
scivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator=(const ivector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
scivector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator&=(const civector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
scivector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator|=(const civector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator|=(const scvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
friend scvector Sup(const scivector &)
Returns the supremum of the complex interval vector as a new sparse point vector.
friend srvector SupRe(const scivector &)
Returns the supremum of the real part of the complex interval vector as a new sparse point vector.
const std::vector< cinterval > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
scivector & operator=(const srvector &v)
Assign a sparse real vector to a sparse complex interval vector.
scivector & operator=(const ivector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
scivector & operator/=(const interval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
scivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
scivector & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
scivector & operator/=(const cinterval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
scivector & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
friend int VecLen(const scivector &)
Returns the length of the vector (the dimension)
scivector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator=(const rvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
friend srvector InfRe(const scivector &)
Returns the infimum of the real part of the complex interval vector as a new sparse point vector.
scivector & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector & operator=(const civector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
scivector & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
scivector(const sivector &v)
Creates a sparse complex interval vector out of a sparse interval vector.
scivector & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator=(const cinterval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
scivector & operator&=(const ivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
scivector(const int n, const int nnz, const intvector &index, const civector &values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
scivector(const civector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition scivector.hpp:88
scivector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
scivector & operator&=(const civector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
friend sivector Re(const scivector &)
Returns the real part of the vector v.
friend scivector conj(const scivector &)
Returns the complex conjugate of v.
scivector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
scivector(const cvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
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.
scivector & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
friend void SetUb(scivector &, const int)
Sets the upper index bound of the vector v to i.
void dropzeros()
Erases explicitly stored zeros from the data structure.
scivector & operator&=(const ivector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
scivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector
scivector & operator=(const cvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
scivector & operator&=(const sivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
friend sivector abs(const scivector &)
Computes the component-wise absolute values as the interval hull of for a vector v.
friend srvector InfIm(const scivector &)
Returns the infimum of the imaginary part of the complex interval vector as a new sparse point vector...
scivector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
scivector & operator|=(const civector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
scivector & operator&=(const scivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
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.
Helper class for slices of sparse vectors.
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.
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.
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.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
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.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.