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 
39 namespace cxsc {
40 
41 class srvector_slice;
42 class srmatrix;
43 class srmatrix_slice;
44 class srmatrix_subv;
45 class scvector_slice;
46 class scmatrix;
47 class scmatrix_slice;
48 class scmatrix_subv;
49 class sivector_slice;
50 class simatrix;
51 class simatrix_slice;
52 class simatrix_subv;
53 class scivector_slice;
54 class scimatrix_slice;
55 class scimatrix_subv;
56 
58 
62 class 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 
161  scivector(const srvector_slice&);
163  scivector(const scvector_slice&);
165  scivector(const sivector_slice&);
167  scivector(const scivector_slice&);
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 
269  scivector& operator=(const real& v) {
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 
428  scivector& operator*=(const real& s) {
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 
448  scivector& operator/=(const real& s) {
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 
736 inline 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 
747 inline 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 
758 inline 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 
769 inline civector::civector(const scivector& v) {
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 
817 inline void SetLb(scivector& v, const int i) {
818  v.lb = i;
819  v.ub = v.lb + v.n - 1;
820 }
821 
823 
826 inline void SetUb(scivector& v, const int j) {
827  v.ub = j;
828  v.lb = v.ub - v.n + 1;
829 }
830 
832 inline int Lb(const scivector& v) {
833  return v.lb;
834 }
835 
837 inline int Ub(const scivector& v) {
838  return v.ub;
839 }
840 
842 inline void Resize(scivector& v) {
843  sp_v_resize(v);
844 }
845 
847 
850 inline void Resize(scivector& v, const int n) {
851  sp_v_resize(v,n);
852 }
853 
855 
859 inline void Resize(scivector& v, const int l, const int u) {
860  sp_v_resize(v,l,u);
861 }
862 
864 inline 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 
875 inline 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 
886 inline 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 
897 inline 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 
908 inline 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 
919 inline 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 
930 inline 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 
941 inline 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 
952 inline 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 
963 inline 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 
974 inline 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 
985 inline 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 
996 inline int VecLen(const scivector& v) {
997  return v.n;
998 }
999 
1001 inline 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 
1008 inline scivector operator-(const scivector& v) {
1009  return sp_v_negative(v);
1010 }
1011 
1013 
1019 inline cinterval operator*(const scivector& v1, const cvector& v2) {
1020  return spf_vv_mult<scivector,cvector,cinterval,sparse_cidot>(v1,v2);
1021 }
1022 
1024 
1030 inline cinterval operator*(const scivector& v1, const rvector& v2) {
1031  return spf_vv_mult<scivector,rvector,cinterval,sparse_cidot>(v1,v2);
1032 }
1033 
1035 
1041 inline cinterval operator*(const scivector& v1, const ivector& v2) {
1042  return spf_vv_mult<scivector,ivector,cinterval,sparse_cidot>(v1,v2);
1043 }
1044 
1046 
1052 inline cinterval operator*(const scivector& v1, const civector& v2) {
1053  return spf_vv_mult<scivector,civector,cinterval,sparse_cidot>(v1,v2);
1054 }
1055 
1057 
1063 inline cinterval operator*(const scvector& v1, const civector& v2) {
1064  return spf_vv_mult<scvector,civector,cinterval,sparse_cidot>(v1,v2);
1065 }
1066 
1068 
1074 inline cinterval operator*(const srvector& v1, const civector& v2) {
1075  return spf_vv_mult<srvector,civector,cinterval,sparse_cidot>(v1,v2);
1076 }
1077 
1079 
1085 inline cinterval operator*(const sivector& v1, const civector& v2) {
1086  return spf_vv_mult<sivector,civector,cinterval,sparse_cidot>(v1,v2);
1087 }
1088 
1090 
1096 inline cinterval operator*(const scvector& v1, const ivector& v2) {
1097  return spf_vv_mult<scvector,ivector,cinterval,sparse_cidot>(v1,v2);
1098 }
1099 
1101 
1107 inline cinterval operator*(const sivector& v1, const cvector& v2) {
1108  return spf_vv_mult<sivector,cvector,cinterval,sparse_cidot>(v1,v2);
1109 }
1110 
1112 
1118 inline cinterval operator*(const rvector& v1, const scivector& v2) {
1119  return fsp_vv_mult<rvector,scivector,cinterval,sparse_cidot>(v1,v2);
1120 }
1121 
1123 
1129 inline cinterval operator*(const cvector& v1, const scivector& v2) {
1130  return fsp_vv_mult<cvector,scivector,cinterval,sparse_cidot>(v1,v2);
1131 }
1132 
1134 
1140 inline cinterval operator*(const ivector& v1, const scivector& v2) {
1141  return fsp_vv_mult<ivector,scivector,cinterval,sparse_cidot>(v1,v2);
1142 }
1143 
1145 
1151 inline cinterval operator*(const civector& v1, const scivector& v2) {
1152  return fsp_vv_mult<civector,scivector,cinterval,sparse_cidot>(v1,v2);
1153 }
1154 
1156 
1162 inline cinterval operator*(const civector& v1, const srvector& v2) {
1163  return fsp_vv_mult<civector,srvector,cinterval,sparse_cidot>(v1,v2);
1164 }
1165 
1167 
1173 inline cinterval operator*(const civector& v1, const scvector& v2) {
1174  return fsp_vv_mult<civector,scvector,cinterval,sparse_cidot>(v1,v2);
1175 }
1176 
1178 
1184 inline cinterval operator*(const civector& v1, const sivector& v2) {
1185  return fsp_vv_mult<civector,sivector,cinterval,sparse_cidot>(v1,v2);
1186 }
1187 
1189 
1195 inline cinterval operator*(const ivector& v1, const scvector& v2) {
1196  return fsp_vv_mult<ivector,scvector,cinterval,sparse_cidot>(v1,v2);
1197 }
1198 
1200 
1206 inline cinterval operator*(const cvector& v1, const sivector& v2) {
1207  return fsp_vv_mult<cvector,sivector,cinterval,sparse_cidot>(v1,v2);
1208 }
1209 
1211 
1217 inline 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 
1228 inline 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 
1239 inline 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 
1250 inline 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 
1261 inline 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 
1272 inline 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 
1283 inline 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 
1294 inline 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 
1305 inline 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 
1316 inline 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 
1327 inline 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 
1338 inline 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 
1349 inline 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 
1360 inline 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 
1371 inline 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 
1382 inline 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 
1393 inline 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 
1404 inline 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 
1415 inline cinterval operator*(const scivector& v1, const srvector& v2) {
1416  return spsp_vv_mult<scivector,srvector,cinterval,sparse_cidot>(v1,v2);
1417 }
1418 
1420 
1426 inline cinterval operator*(const scivector& v1, const scvector& v2) {
1427  return spsp_vv_mult<scivector,scvector,cinterval,sparse_cidot>(v1,v2);
1428 }
1429 
1431 
1437 inline cinterval operator*(const scivector& v1, const sivector& v2) {
1438  return spsp_vv_mult<scivector,sivector,cinterval,sparse_cidot>(v1,v2);
1439 }
1440 
1442 
1448 inline cinterval operator*(const scivector& v1, const scivector& v2) {
1449  return spsp_vv_mult<scivector,scivector,cinterval,sparse_cidot>(v1,v2);
1450 }
1451 
1453 
1459 inline cinterval operator*(const srvector& v1, const scivector& v2) {
1460  return spsp_vv_mult<srvector,scivector,cinterval,sparse_cidot>(v1,v2);
1461 }
1462 
1464 
1470 inline cinterval operator*(const scvector& v1, const scivector& v2) {
1471  return spsp_vv_mult<scvector,scivector,cinterval,sparse_cidot>(v1,v2);
1472 }
1473 
1475 
1481 inline cinterval operator*(const sivector& v1, const scivector& v2) {
1482  return spsp_vv_mult<sivector,scivector,cinterval,sparse_cidot>(v1,v2);
1483 }
1484 
1486 
1492 inline cinterval operator*(const scvector& v1, const sivector& v2) {
1493  return spsp_vv_mult<scvector,sivector,cinterval,sparse_cidot>(v1,v2);
1494 }
1495 
1497 
1503 inline cinterval operator*(const sivector& v1, const scvector& v2) {
1504  return spsp_vv_mult<sivector,scvector,cinterval,sparse_cidot>(v1,v2);
1505 }
1506 
1508 inline scivector operator*(const scivector& v, const real& s) {
1509  return sp_vs_mult<scivector,real,scivector>(v,s);
1510 }
1511 
1513 inline scivector operator*(const scivector& v, const complex& s) {
1514  return sp_vs_mult<scivector,complex,scivector>(v,s);
1515 }
1516 
1518 inline scivector operator*(const scivector& v, const interval& s) {
1519  return sp_vs_mult<scivector,interval,scivector>(v,s);
1520 }
1521 
1523 inline scivector operator*(const scivector& v, const cinterval& s) {
1524  return sp_vs_mult<scivector,cinterval,scivector>(v,s);
1525 }
1526 
1528 inline scivector operator*(const scvector& v, const interval& s) {
1529  return sp_vs_mult<scvector,interval,scivector>(v,s);
1530 }
1531 
1533 inline scivector operator*(const sivector& v, const complex& s) {
1534  return sp_vs_mult<sivector,complex,scivector>(v,s);
1535 }
1536 
1538 inline scivector operator/(const scivector& v, const real& s) {
1539  return sp_vs_div<scivector,real,scivector>(v,s);
1540 }
1541 
1543 inline scivector operator/(const scivector& v, const complex& s) {
1544  return sp_vs_div<scivector,complex,scivector>(v,s);
1545 }
1546 
1548 inline scivector operator/(const scivector& v, const interval& s) {
1549  return sp_vs_div<scivector,interval,scivector>(v,s);
1550 }
1551 
1553 inline scivector operator/(const scivector& v, const cinterval& s) {
1554  return sp_vs_div<scivector,cinterval,scivector>(v,s);
1555 }
1556 
1558 inline scivector operator/(const srvector& v, const cinterval& s) {
1559  return sp_vs_div<srvector,cinterval,scivector>(v,s);
1560 }
1561 
1563 inline scivector operator/(const scvector& v, const cinterval& s) {
1564  return sp_vs_div<scvector,cinterval,scivector>(v,s);
1565 }
1566 
1568 inline scivector operator/(const sivector& v, const cinterval& s) {
1569  return sp_vs_div<sivector,cinterval,scivector>(v,s);
1570 }
1571 
1573 inline scivector operator/(const scvector& v, const interval& s) {
1574  return sp_vs_div<scvector,interval,scivector>(v,s);
1575 }
1576 
1578 inline scivector operator/(const sivector& v, const complex& s) {
1579  return sp_vs_div<sivector,complex,scivector>(v,s);
1580 }
1581 
1583 inline scivector operator*(const real& s, const scivector& v) {
1584  return sp_sv_mult<real,scivector,scivector>(s,v);
1585 }
1586 
1588 inline scivector operator*(const complex& s, const scivector& v) {
1589  return sp_sv_mult<complex,scivector,scivector>(s,v);
1590 }
1591 
1593 inline scivector operator*(const interval& s, const scivector& v) {
1594  return sp_sv_mult<interval,scivector,scivector>(s,v);
1595 }
1596 
1598 inline scivector operator*(const cinterval& s, const srvector& v) {
1599  return sp_sv_mult<cinterval,srvector,scivector>(s,v);
1600 }
1601 
1603 inline scivector operator*(const cinterval& s, const sivector& v) {
1604  return sp_sv_mult<cinterval,sivector,scivector>(s,v);
1605 }
1606 
1608 inline scivector operator*(const cinterval& s, const scvector& v) {
1609  return sp_sv_mult<cinterval,scvector,scivector>(s,v);
1610 }
1611 
1613 inline scivector operator*(const cinterval& s, const scivector& v) {
1614  return sp_sv_mult<cinterval,scivector,scivector>(s,v);
1615 }
1616 
1618 inline scivector operator*(const srvector& v, const cinterval& s) {
1619  return sp_sv_mult<cinterval,srvector,scivector>(s,v);
1620 }
1621 
1623 inline scivector operator*(const sivector& v, const cinterval& s) {
1624  return sp_sv_mult<cinterval,sivector,scivector>(s,v);
1625 }
1626 
1628 inline scivector operator*(const scvector& v, const cinterval& s) {
1629  return sp_sv_mult<cinterval,scvector,scivector>(s,v);
1630 }
1631 
1633 inline scivector operator*(const complex& s, const sivector& v) {
1634  return sp_sv_mult<complex,sivector,scivector>(s,v);
1635 }
1636 
1638 inline scivector operator*(const interval& s, const scvector& v) {
1639  return sp_sv_mult<interval,scvector,scivector>(s,v);
1640 }
1641 
1643 inline civector operator+(const civector& v1, const srvector& v2) {
1644  return fsp_vv_add<civector,srvector,civector>(v1,v2);
1645 }
1646 
1648 inline civector operator+(const civector& v1, const scvector& v2) {
1649  return fsp_vv_add<civector,scvector,civector>(v1,v2);
1650 }
1651 
1653 inline civector operator+(const civector& v1, const sivector& v2) {
1654  return fsp_vv_add<civector,sivector,civector>(v1,v2);
1655 }
1656 
1658 inline civector operator+(const civector& v1, const scivector& v2) {
1659  return fsp_vv_add<civector,scivector,civector>(v1,v2);
1660 }
1661 
1663 inline civector operator+(const rvector& v1, const scivector& v2) {
1664  return fsp_vv_add<rvector,scivector,civector>(v1,v2);
1665 }
1666 
1668 inline civector operator+(const cvector& v1, const scivector& v2) {
1669  return fsp_vv_add<cvector,scivector,civector>(v1,v2);
1670 }
1671 
1673 inline civector operator+(const ivector& v1, const scivector& v2) {
1674  return fsp_vv_add<ivector,scivector,civector>(v1,v2);
1675 }
1676 
1678 inline civector operator+(const cvector& v1, const sivector& v2) {
1679  return fsp_vv_add<cvector,sivector,civector>(v1,v2);
1680 }
1681 
1683 inline civector operator+(const ivector& v1, const scvector& v2) {
1684  return fsp_vv_add<ivector,scvector,civector>(v1,v2);
1685 }
1686 
1688 inline civector operator+(const scivector& v1, const rvector& v2) {
1689  return spf_vv_add<scivector,rvector,civector>(v1,v2);
1690 }
1691 
1693 inline civector operator+(const scivector& v1, const cvector& v2) {
1694  return spf_vv_add<scivector,cvector,civector>(v1,v2);
1695 }
1696 
1698 inline civector operator+(const scivector& v1, const ivector& v2) {
1699  return spf_vv_add<scivector,ivector,civector>(v1,v2);
1700 }
1701 
1703 inline civector operator+(const scivector& v1, const civector& v2) {
1704  return spf_vv_add<scivector,civector,civector>(v1,v2);
1705 }
1706 
1708 inline civector operator+(const srvector& v1, const civector& v2) {
1709  return spf_vv_add<srvector,civector,civector>(v1,v2);
1710 }
1711 
1713 inline civector operator+(const scvector& v1, const civector& v2) {
1714  return spf_vv_add<scvector,civector,civector>(v1,v2);
1715 }
1716 
1718 inline civector operator+(const sivector& v1, const civector& v2) {
1719  return spf_vv_add<sivector,civector,civector>(v1,v2);
1720 }
1721 
1723 inline civector operator+(const scvector& v1, const ivector& v2) {
1724  return spf_vv_add<scvector,ivector,civector>(v1,v2);
1725 }
1726 
1728 inline civector operator+(const sivector& v1, const cvector& v2) {
1729  return spf_vv_add<sivector,cvector,civector>(v1,v2);
1730 }
1731 
1733 inline civector operator+(const civector_slice& v1, const srvector& v2) {
1734  return fsp_vv_add<civector_slice,srvector,civector>(v1,v2);
1735 }
1736 
1738 inline civector operator+(const civector_slice& v1, const scvector& v2) {
1739  return fsp_vv_add<civector_slice,scvector,civector>(v1,v2);
1740 }
1741 
1743 inline civector operator+(const civector_slice& v1, const sivector& v2) {
1744  return fsp_vv_add<civector_slice,sivector,civector>(v1,v2);
1745 }
1746 
1748 inline civector operator+(const civector_slice& v1, const scivector& v2) {
1749  return fsp_vv_add<civector_slice,scivector,civector>(v1,v2);
1750 }
1751 
1753 inline civector operator+(const rvector_slice& v1, const scivector& v2) {
1754  return fsp_vv_add<rvector_slice,scivector,civector>(v1,v2);
1755 }
1756 
1758 inline civector operator+(const cvector_slice& v1, const scivector& v2) {
1759  return fsp_vv_add<cvector_slice,scivector,civector>(v1,v2);
1760 }
1761 
1763 inline civector operator+(const ivector_slice& v1, const scivector& v2) {
1764  return fsp_vv_add<ivector_slice,scivector,civector>(v1,v2);
1765 }
1766 
1768 inline civector operator+(const cvector_slice& v1, const sivector& v2) {
1769  return fsp_vv_add<cvector_slice,sivector,civector>(v1,v2);
1770 }
1771 
1773 inline civector operator+(const ivector_slice& v1, const scvector& v2) {
1774  return fsp_vv_add<ivector_slice,scvector,civector>(v1,v2);
1775 }
1776 
1778 inline civector operator+(const scivector& v1, const rvector_slice& v2) {
1779  return spf_vv_add<scivector,rvector_slice,civector>(v1,v2);
1780 }
1781 
1783 inline civector operator+(const scivector& v1, const cvector_slice& v2) {
1784  return spf_vv_add<scivector,cvector_slice,civector>(v1,v2);
1785 }
1786 
1788 inline civector operator+(const scivector& v1, const ivector_slice& v2) {
1789  return spf_vv_add<scivector,ivector_slice,civector>(v1,v2);
1790 }
1791 
1793 inline civector operator+(const scivector& v1, const civector_slice& v2) {
1794  return spf_vv_add<scivector,civector_slice,civector>(v1,v2);
1795 }
1796 
1798 inline civector operator+(const srvector& v1, const civector_slice& v2) {
1799  return spf_vv_add<srvector,civector_slice,civector>(v1,v2);
1800 }
1801 
1803 inline civector operator+(const scvector& v1, const civector_slice& v2) {
1804  return spf_vv_add<scvector,civector_slice,civector>(v1,v2);
1805 }
1806 
1808 inline civector operator+(const sivector& v1, const civector_slice& v2) {
1809  return spf_vv_add<sivector,civector_slice,civector>(v1,v2);
1810 }
1811 
1813 inline civector operator+(const scvector& v1, const ivector_slice& v2) {
1814  return spf_vv_add<scvector,ivector_slice,civector>(v1,v2);
1815 }
1816 
1818 inline civector operator+(const sivector& v1, const cvector_slice& v2) {
1819  return spf_vv_add<sivector,cvector_slice,civector>(v1,v2);
1820 }
1821 
1823 inline scivector operator+(const scivector& v1, const srvector& v2) {
1824  return spsp_vv_add<scivector,srvector,scivector,cinterval>(v1,v2);
1825 }
1826 
1828 inline scivector operator+(const scivector& v1, const scvector& v2) {
1829  return spsp_vv_add<scivector,scvector,scivector,cinterval>(v1,v2);
1830 }
1831 
1833 inline scivector operator+(const scivector& v1, const sivector& v2) {
1834  return spsp_vv_add<scivector,sivector,scivector,cinterval>(v1,v2);
1835 }
1836 
1838 inline scivector operator+(const scivector& v1, const scivector& v2) {
1839  return spsp_vv_add<scivector,scivector,scivector,cinterval>(v1,v2);
1840 }
1841 
1843 inline scivector operator+(const srvector& v1, const scivector& v2) {
1844  return spsp_vv_add<srvector,scivector,scivector,cinterval>(v1,v2);
1845 }
1846 
1848 inline scivector operator+(const scvector& v1, const scivector& v2) {
1849  return spsp_vv_add<scvector,scivector,scivector,cinterval>(v1,v2);
1850 }
1851 
1853 inline scivector operator+(const sivector& v1, const scivector& v2) {
1854  return spsp_vv_add<sivector,scivector,scivector,cinterval>(v1,v2);
1855 }
1856 
1858 inline scivector operator+(const scvector& v1, const sivector& v2) {
1859  return spsp_vv_add<scvector,sivector,scivector,cinterval>(v1,v2);
1860 }
1861 
1863 inline scivector operator+(const sivector& v1, const scvector& v2) {
1864  return spsp_vv_add<sivector,scvector,scivector,cinterval>(v1,v2);
1865 }
1866 
1868 inline civector operator-(const civector& v1, const srvector& v2) {
1869  return fsp_vv_sub<civector,srvector,civector>(v1,v2);
1870 }
1871 
1873 inline civector operator-(const civector& v1, const sivector& v2) {
1874  return fsp_vv_sub<civector,sivector,civector>(v1,v2);
1875 }
1876 
1878 inline civector operator-(const civector& v1, const scvector& v2) {
1879  return fsp_vv_sub<civector,scvector,civector>(v1,v2);
1880 }
1881 
1883 inline civector operator-(const civector& v1, const scivector& v2) {
1884  return fsp_vv_sub<civector,scivector,civector>(v1,v2);
1885 }
1886 
1888 inline civector operator-(const rvector& v1, const scivector& v2) {
1889  return fsp_vv_sub<rvector,scivector,civector>(v1,v2);
1890 }
1891 
1893 inline civector operator-(const cvector& v1, const scivector& v2) {
1894  return fsp_vv_sub<cvector,scivector,civector>(v1,v2);
1895 }
1896 
1898 inline civector operator-(const ivector& v1, const scivector& v2) {
1899  return fsp_vv_sub<ivector,scivector,civector>(v1,v2);
1900 }
1901 
1903 inline civector operator-(const cvector& v1, const sivector& v2) {
1904  return fsp_vv_sub<cvector,sivector,civector>(v1,v2);
1905 }
1906 
1908 inline civector operator-(const ivector& v1, const scvector& v2) {
1909  return fsp_vv_sub<ivector,scvector,civector>(v1,v2);
1910 }
1911 
1913 inline civector operator-(const scivector& v1, const rvector& v2) {
1914  return spf_vv_sub<scivector,rvector,civector>(v1,v2);
1915 }
1916 
1918 inline civector operator-(const scivector& v1, const cvector& v2) {
1919  return spf_vv_sub<scivector,cvector,civector>(v1,v2);
1920 }
1921 
1923 inline civector operator-(const scivector& v1, const ivector& v2) {
1924  return spf_vv_sub<scivector,ivector,civector>(v1,v2);
1925 }
1926 
1928 inline civector operator-(const scivector& v1, const civector& v2) {
1929  return spf_vv_sub<scivector,civector,civector>(v1,v2);
1930 }
1931 
1933 inline civector operator-(const srvector& v1, const civector& v2) {
1934  return spf_vv_sub<srvector,civector,civector>(v1,v2);
1935 }
1936 
1938 inline civector operator-(const scvector& v1, const civector& v2) {
1939  return spf_vv_sub<scvector,civector,civector>(v1,v2);
1940 }
1941 
1943 inline civector operator-(const sivector& v1, const civector& v2) {
1944  return spf_vv_sub<sivector,civector,civector>(v1,v2);
1945 }
1946 
1948 inline civector operator-(const scvector& v1, const ivector& v2) {
1949  return spf_vv_sub<scvector,ivector,civector>(v1,v2);
1950 }
1951 
1953 inline civector operator-(const sivector& v1, const cvector& v2) {
1954  return spf_vv_sub<sivector,cvector,civector>(v1,v2);
1955 }
1956 
1958 inline civector operator-(const civector_slice& v1, const srvector& v2) {
1959  return fsp_vv_sub<civector_slice,srvector,civector>(v1,v2);
1960 }
1961 
1963 inline civector operator-(const civector_slice& v1, const sivector& v2) {
1964  return fsp_vv_sub<civector_slice,sivector,civector>(v1,v2);
1965 }
1966 
1968 inline civector operator-(const civector_slice& v1, const scvector& v2) {
1969  return fsp_vv_sub<civector_slice,scvector,civector>(v1,v2);
1970 }
1971 
1973 inline civector operator-(const civector_slice& v1, const scivector& v2) {
1974  return fsp_vv_sub<civector_slice,scivector,civector>(v1,v2);
1975 }
1976 
1978 inline civector operator-(const rvector_slice& v1, const scivector& v2) {
1979  return fsp_vv_sub<rvector_slice,scivector,civector>(v1,v2);
1980 }
1981 
1983 inline civector operator-(const cvector_slice& v1, const scivector& v2) {
1984  return fsp_vv_sub<cvector_slice,scivector,civector>(v1,v2);
1985 }
1986 
1988 inline civector operator-(const ivector_slice& v1, const scivector& v2) {
1989  return fsp_vv_sub<ivector_slice,scivector,civector>(v1,v2);
1990 }
1991 
1993 inline civector operator-(const cvector_slice& v1, const sivector& v2) {
1994  return fsp_vv_sub<cvector_slice,sivector,civector>(v1,v2);
1995 }
1996 
1998 inline civector operator-(const ivector_slice& v1, const scvector& v2) {
1999  return fsp_vv_sub<ivector_slice,scvector,civector>(v1,v2);
2000 }
2001 
2003 inline civector operator-(const scivector& v1, const rvector_slice& v2) {
2004  return spf_vv_sub<scivector,rvector_slice,civector>(v1,v2);
2005 }
2006 
2008 inline civector operator-(const scivector& v1, const cvector_slice& v2) {
2009  return spf_vv_sub<scivector,cvector_slice,civector>(v1,v2);
2010 }
2011 
2013 inline civector operator-(const scivector& v1, const ivector_slice& v2) {
2014  return spf_vv_sub<scivector,ivector_slice,civector>(v1,v2);
2015 }
2016 
2018 inline civector operator-(const scivector& v1, const civector_slice& v2) {
2019  return spf_vv_sub<scivector,civector_slice,civector>(v1,v2);
2020 }
2021 
2023 inline civector operator-(const srvector& v1, const civector_slice& v2) {
2024  return spf_vv_sub<srvector,civector_slice,civector>(v1,v2);
2025 }
2026 
2028 inline civector operator-(const scvector& v1, const civector_slice& v2) {
2029  return spf_vv_sub<scvector,civector_slice,civector>(v1,v2);
2030 }
2031 
2033 inline civector operator-(const sivector& v1, const civector_slice& v2) {
2034  return spf_vv_sub<sivector,civector_slice,civector>(v1,v2);
2035 }
2036 
2038 inline civector operator-(const scvector& v1, const ivector_slice& v2) {
2039  return spf_vv_sub<scvector,ivector_slice,civector>(v1,v2);
2040 }
2041 
2043 inline civector operator-(const sivector& v1, const cvector_slice& v2) {
2044  return spf_vv_sub<sivector,cvector_slice,civector>(v1,v2);
2045 }
2046 
2048 inline scivector operator-(const scivector& v1, const srvector& v2) {
2049  return spsp_vv_sub<scivector,srvector,scivector,cinterval>(v1,v2);
2050 }
2051 
2053 inline scivector operator-(const scivector& v1, const scvector& v2) {
2054  return spsp_vv_sub<scivector,scvector,scivector,cinterval>(v1,v2);
2055 }
2056 
2058 inline scivector operator-(const scivector& v1, const sivector& v2) {
2059  return spsp_vv_sub<scivector,sivector,scivector,cinterval>(v1,v2);
2060 }
2061 
2063 inline scivector operator-(const scivector& v1, const scivector& v2) {
2064  return spsp_vv_sub<scivector,scivector,scivector,cinterval>(v1,v2);
2065 }
2066 
2068 inline scivector operator-(const srvector& v1, const scivector& v2) {
2069  return spsp_vv_sub<srvector,scivector,scivector,cinterval>(v1,v2);
2070 }
2071 
2073 inline scivector operator-(const scvector& v1, const scivector& v2) {
2074  return spsp_vv_sub<scvector,scivector,scivector,cinterval>(v1,v2);
2075 }
2076 
2078 inline scivector operator-(const sivector& v1, const scivector& v2) {
2079  return spsp_vv_sub<sivector,scivector,scivector,cinterval>(v1,v2);
2080 }
2081 
2083 inline scivector operator-(const scvector& v1, const sivector& v2) {
2084  return spsp_vv_sub<scvector,sivector,scivector,cinterval>(v1,v2);
2085 }
2086 
2088 inline scivector operator-(const sivector& v1, const scvector& v2) {
2089  return spsp_vv_sub<sivector,scvector,scivector,cinterval>(v1,v2);
2090 }
2091 
2093 inline civector operator|(const civector& v1, const srvector& v2) {
2094  return fsp_vv_hull<civector,srvector,civector>(v1,v2);
2095 }
2096 
2098 inline civector operator|(const civector& v1, const scvector& v2) {
2099  return fsp_vv_hull<civector,scvector,civector>(v1,v2);
2100 }
2101 
2103 inline civector operator|(const civector& v1, const sivector& v2) {
2104  return fsp_vv_hull<civector,sivector,civector>(v1,v2);
2105 }
2106 
2108 inline civector operator|(const civector& v1, const scivector& v2) {
2109  return fsp_vv_hull<civector,scivector,civector>(v1,v2);
2110 }
2111 
2113 inline civector operator|(const rvector& v1, const scivector& v2) {
2114  return fsp_vv_hull<rvector,scivector,civector>(v1,v2);
2115 }
2116 
2118 inline civector operator|(const cvector& v1, const scivector& v2) {
2119  return fsp_vv_hull<cvector,scivector,civector>(v1,v2);
2120 }
2121 
2123 inline civector operator|(const ivector& v1, const scivector& v2) {
2124  return fsp_vv_hull<ivector,scivector,civector>(v1,v2);
2125 }
2126 
2128 inline civector operator|(const cvector& v1, const sivector& v2) {
2129  return fsp_vv_hull<cvector,sivector,civector>(v1,v2);
2130 }
2131 
2133 inline civector operator|(const ivector& v1, const scvector& v2) {
2134  return fsp_vv_hull<ivector,scvector,civector>(v1,v2);
2135 }
2136 
2138 inline civector operator|(const scivector& v1, const rvector& v2) {
2139  return spf_vv_hull<scivector,rvector,civector>(v1,v2);
2140 }
2141 
2143 inline civector operator|(const scivector& v1, const cvector& v2) {
2144  return spf_vv_hull<scivector,cvector,civector>(v1,v2);
2145 }
2146 
2148 inline civector operator|(const scivector& v1, const ivector& v2) {
2149  return spf_vv_hull<scivector,ivector,civector>(v1,v2);
2150 }
2151 
2153 inline civector operator|(const scivector& v1, const civector& v2) {
2154  return spf_vv_hull<scivector,civector,civector>(v1,v2);
2155 }
2156 
2158 inline civector operator|(const srvector& v1, const civector& v2) {
2159  return spf_vv_hull<srvector,civector,civector>(v1,v2);
2160 }
2161 
2163 inline civector operator|(const scvector& v1, const civector& v2) {
2164  return spf_vv_hull<scvector,civector,civector>(v1,v2);
2165 }
2166 
2168 inline civector operator|(const sivector& v1, const civector& v2) {
2169  return spf_vv_hull<sivector,civector,civector>(v1,v2);
2170 }
2171 
2173 inline civector operator|(const scvector& v1, const ivector& v2) {
2174  return spf_vv_hull<scvector,ivector,civector>(v1,v2);
2175 }
2176 
2178 inline civector operator|(const sivector& v1, const cvector& v2) {
2179  return spf_vv_hull<sivector,cvector,civector>(v1,v2);
2180 }
2181 
2183 inline civector operator|(const civector_slice& v1, const srvector& v2) {
2184  return fsp_vv_hull<civector_slice,srvector,civector>(v1,v2);
2185 }
2186 
2188 inline civector operator|(const civector_slice& v1, const scvector& v2) {
2189  return fsp_vv_hull<civector_slice,scvector,civector>(v1,v2);
2190 }
2191 
2193 inline civector operator|(const civector_slice& v1, const sivector& v2) {
2194  return fsp_vv_hull<civector_slice,sivector,civector>(v1,v2);
2195 }
2196 
2198 inline civector operator|(const civector_slice& v1, const scivector& v2) {
2199  return fsp_vv_hull<civector_slice,scivector,civector>(v1,v2);
2200 }
2201 
2203 inline civector operator|(const rvector_slice& v1, const scivector& v2) {
2204  return fsp_vv_hull<rvector_slice,scivector,civector>(v1,v2);
2205 }
2206 
2208 inline civector operator|(const cvector_slice& v1, const scivector& v2) {
2209  return fsp_vv_hull<cvector_slice,scivector,civector>(v1,v2);
2210 }
2211 
2213 inline civector operator|(const ivector_slice& v1, const scivector& v2) {
2214  return fsp_vv_hull<ivector_slice,scivector,civector>(v1,v2);
2215 }
2216 
2218 inline civector operator|(const cvector_slice& v1, const sivector& v2) {
2219  return fsp_vv_hull<cvector_slice,sivector,civector>(v1,v2);
2220 }
2221 
2223 inline civector operator|(const ivector_slice& v1, const scvector& v2) {
2224  return fsp_vv_hull<ivector_slice,scvector,civector>(v1,v2);
2225 }
2226 
2228 inline civector operator|(const scivector& v1, const rvector_slice& v2) {
2229  return spf_vv_hull<scivector,rvector_slice,civector>(v1,v2);
2230 }
2231 
2233 inline civector operator|(const scivector& v1, const cvector_slice& v2) {
2234  return spf_vv_hull<scivector,cvector_slice,civector>(v1,v2);
2235 }
2236 
2238 inline civector operator|(const scivector& v1, const ivector_slice& v2) {
2239  return spf_vv_hull<scivector,ivector_slice,civector>(v1,v2);
2240 }
2241 
2243 inline civector operator|(const scivector& v1, const civector_slice& v2) {
2244  return spf_vv_hull<scivector,civector_slice,civector>(v1,v2);
2245 }
2246 
2248 inline civector operator|(const srvector& v1, const civector_slice& v2) {
2249  return spf_vv_hull<srvector,civector_slice,civector>(v1,v2);
2250 }
2251 
2253 inline civector operator|(const scvector& v1, const civector_slice& v2) {
2254  return spf_vv_hull<scvector,civector_slice,civector>(v1,v2);
2255 }
2256 
2258 inline civector operator|(const sivector& v1, const civector_slice& v2) {
2259  return spf_vv_hull<sivector,civector_slice,civector>(v1,v2);
2260 }
2261 
2263 inline civector operator|(const scvector& v1, const ivector_slice& v2) {
2264  return spf_vv_hull<scvector,ivector_slice,civector>(v1,v2);
2265 }
2266 
2268 inline civector operator|(const sivector& v1, const cvector_slice& v2) {
2269  return spf_vv_hull<sivector,cvector_slice,civector>(v1,v2);
2270 }
2271 
2273 inline scivector operator|(const scivector& v1, const srvector& v2) {
2274  return spsp_vv_hull<scivector,srvector,scivector,cinterval>(v1,v2);
2275 }
2276 
2278 inline scivector operator|(const scivector& v1, const scvector& v2) {
2279  return spsp_vv_hull<scivector,scvector,scivector,cinterval>(v1,v2);
2280 }
2281 
2283 inline scivector operator|(const scivector& v1, const sivector& v2) {
2284  return spsp_vv_hull<scivector,sivector,scivector,cinterval>(v1,v2);
2285 }
2286 
2288 inline scivector operator|(const scivector& v1, const scivector& v2) {
2289  return spsp_vv_hull<scivector,scivector,scivector,cinterval>(v1,v2);
2290 }
2291 
2293 inline scivector operator|(const srvector& v1, const scivector& v2) {
2294  return spsp_vv_hull<srvector,scivector,scivector,cinterval>(v1,v2);
2295 }
2296 
2298 inline scivector operator|(const scvector& v1, const scivector& v2) {
2299  return spsp_vv_hull<scvector,scivector,scivector,cinterval>(v1,v2);
2300 }
2301 
2303 inline scivector operator|(const sivector& v1, const scivector& v2) {
2304  return spsp_vv_hull<sivector,scivector,scivector,cinterval>(v1,v2);
2305 }
2306 
2308 inline scivector operator|(const scvector& v1, const sivector& v2) {
2309  return spsp_vv_hull<scvector,sivector,scivector,cinterval>(v1,v2);
2310 }
2311 
2313 inline scivector operator|(const sivector& v1, const scvector& v2) {
2314  return spsp_vv_hull<sivector,scvector,scivector,cinterval>(v1,v2);
2315 }
2316 
2318 inline civector operator|(const cvector& v1, const srvector& v2) {
2319  return fsp_vv_hull<cvector,srvector,civector>(v1,v2);
2320 }
2321 
2323 inline civector operator|(const rvector& v1, const scvector& v2) {
2324  return fsp_vv_hull<rvector,scvector,civector>(v1,v2);
2325 }
2326 
2328 inline civector operator|(const cvector& v1, const scvector& v2) {
2329  return fsp_vv_hull<cvector,scvector,civector>(v1,v2);
2330 }
2331 
2333 inline civector operator|(const scvector& v1, const rvector& v2) {
2334  return spf_vv_hull<scvector,rvector,civector>(v1,v2);
2335 }
2336 
2338 inline civector operator|(const srvector& v1, const cvector& v2) {
2339  return spf_vv_hull<srvector,cvector,civector>(v1,v2);
2340 }
2341 
2343 inline civector operator|(const scvector& v1, const cvector& v2) {
2344  return spf_vv_hull<scvector,cvector,civector>(v1,v2);
2345 }
2346 
2348 inline civector operator|(const cvector_slice& v1, const srvector& v2) {
2349  return fsp_vv_hull<cvector_slice,srvector,civector>(v1,v2);
2350 }
2351 
2353 inline civector operator|(const rvector_slice& v1, const scvector& v2) {
2354  return fsp_vv_hull<rvector_slice,scvector,civector>(v1,v2);
2355 }
2356 
2358 inline civector operator|(const cvector_slice& v1, const scvector& v2) {
2359  return fsp_vv_hull<cvector_slice,scvector,civector>(v1,v2);
2360 }
2361 
2363 inline civector operator|(const scvector& v1, const rvector_slice& v2) {
2364  return spf_vv_hull<scvector,rvector_slice,civector>(v1,v2);
2365 }
2366 
2368 inline civector operator|(const srvector& v1, const cvector_slice& v2) {
2369  return spf_vv_hull<srvector,cvector_slice,civector>(v1,v2);
2370 }
2371 
2373 inline civector operator|(const scvector& v1, const cvector_slice& v2) {
2374  return spf_vv_hull<scvector,cvector_slice,civector>(v1,v2);
2375 }
2376 
2378 inline scivector operator|(const scvector& v1, const srvector& v2) {
2379  return spsp_vv_hull<scvector,srvector,scivector,cinterval>(v1,v2);
2380 }
2381 
2383 inline scivector operator|(const srvector& v1, const scvector& v2) {
2384  return spsp_vv_hull<srvector,scvector,scivector,cinterval>(v1,v2);
2385 }
2386 
2388 inline scivector operator|(const scvector& v1, const scvector& v2) {
2389  return spsp_vv_hull<scvector,scvector,scivector,cinterval>(v1,v2);
2390 }
2391 
2393 inline civector operator|(const cvector& v1, const srvector_slice& v2) {
2394  return fsl_vv_hull<cvector,srvector_slice,civector>(v1,v2);
2395 }
2396 
2398 inline civector operator|(const rvector& v1, const scvector_slice& v2) {
2399  return fsl_vv_hull<rvector,scvector_slice,civector>(v1,v2);
2400 }
2401 
2403 inline civector operator|(const cvector& v1, const scvector_slice& v2) {
2404  return fsl_vv_hull<cvector,scvector_slice,civector>(v1,v2);
2405 }
2406 
2408 inline civector operator|(const scvector_slice& v1, const rvector& v2) {
2409  return slf_vv_hull<scvector_slice,rvector,civector>(v1,v2);
2410 }
2411 
2413 inline civector operator|(const srvector_slice& v1, const cvector& v2) {
2414  return slf_vv_hull<srvector_slice,cvector,civector>(v1,v2);
2415 }
2416 
2418 inline civector operator|(const scvector_slice& v1, const cvector& v2) {
2419  return slf_vv_hull<scvector_slice,cvector,civector>(v1,v2);
2420 }
2421 
2423 inline civector operator|(const cvector_slice& v1, const srvector_slice& v2) {
2424  return fsl_vv_hull<cvector_slice,srvector_slice,civector>(v1,v2);
2425 }
2426 
2428 inline civector operator|(const rvector_slice& v1, const scvector_slice& v2) {
2429  return fsl_vv_hull<rvector_slice,scvector_slice,civector>(v1,v2);
2430 }
2431 
2433 inline civector operator|(const cvector_slice& v1, const scvector_slice& v2) {
2434  return fsl_vv_hull<cvector_slice,scvector_slice,civector>(v1,v2);
2435 }
2436 
2438 inline civector operator|(const scvector_slice& v1, const rvector_slice& v2) {
2439  return slf_vv_hull<scvector_slice,rvector_slice,civector>(v1,v2);
2440 }
2441 
2443 inline civector operator|(const srvector_slice& v1, const cvector_slice& v2) {
2444  return slf_vv_hull<srvector_slice,cvector_slice,civector>(v1,v2);
2445 }
2446 
2448 inline civector operator|(const scvector_slice& v1, const cvector_slice& v2) {
2449  return slf_vv_hull<scvector_slice,cvector_slice,civector>(v1,v2);
2450 }
2451 
2453 inline 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 
2458 inline 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 
2463 inline 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 
2468 inline scivector operator|(const scvector& v1, const srvector_slice& v2) {
2469  return spsl_vv_hull<scvector,srvector_slice,scivector,cinterval>(v1,v2);
2470 }
2471 
2473 inline scivector operator|(const srvector& v1, const scvector_slice& v2) {
2474  return spsl_vv_hull<srvector,scvector_slice,scivector,cinterval>(v1,v2);
2475 }
2476 
2478 inline scivector operator|(const scvector& v1, const scvector_slice& v2) {
2479  return spsl_vv_hull<scvector,scvector_slice,scivector,cinterval>(v1,v2);
2480 }
2481 
2483 inline scivector operator|(const scvector_slice& v1, const srvector& v2) {
2484  return slsp_vv_hull<scvector_slice,srvector,scivector,cinterval>(v1,v2);
2485 }
2486 
2488 inline scivector operator|(const srvector_slice& v1, const scvector& v2) {
2489  return slsp_vv_hull<srvector_slice,scvector,scivector,cinterval>(v1,v2);
2490 }
2491 
2493 inline scivector operator|(const scvector_slice& v1, const scvector& v2) {
2494  return slsp_vv_hull<scvector_slice,scvector,scivector,cinterval>(v1,v2);
2495 }
2496 
2498 inline civector operator&(const civector& v1, const sivector& v2) {
2499  return fsp_vv_intersect<civector,sivector,civector>(v1,v2);
2500 }
2501 
2503 inline civector operator&(const civector& v1, const scivector& v2) {
2504  return fsp_vv_intersect<civector,scivector,civector>(v1,v2);
2505 }
2506 
2508 inline civector operator&(const ivector& v1, const scivector& v2) {
2509  return fsp_vv_intersect<ivector,scivector,civector>(v1,v2);
2510 }
2511 
2513 inline civector operator&(const scivector& v1, const ivector& v2) {
2514  return spf_vv_intersect<scivector,ivector,civector>(v1,v2);
2515 }
2516 
2518 inline civector operator&(const scivector& v1, const civector& v2) {
2519  return spf_vv_intersect<scivector,civector,civector>(v1,v2);
2520 }
2521 
2523 inline civector operator&(const sivector& v1, const civector& v2) {
2524  return spf_vv_intersect<sivector,civector,civector>(v1,v2);
2525 }
2526 
2528 inline civector operator&(const civector_slice& v1, const sivector& v2) {
2529  return fsp_vv_intersect<civector_slice,sivector,civector>(v1,v2);
2530 }
2531 
2533 inline civector operator&(const civector_slice& v1, const scivector& v2) {
2534  return fsp_vv_intersect<civector_slice,scivector,civector>(v1,v2);
2535 }
2536 
2538 inline civector operator&(const ivector_slice& v1, const scivector& v2) {
2539  return fsp_vv_intersect<ivector_slice,scivector,civector>(v1,v2);
2540 }
2541 
2543 inline civector operator&(const scivector& v1, const ivector_slice& v2) {
2544  return spf_vv_intersect<scivector,ivector_slice,civector>(v1,v2);
2545 }
2546 
2548 inline civector operator&(const scivector& v1, const civector_slice& v2) {
2549  return spf_vv_intersect<scivector,civector_slice,civector>(v1,v2);
2550 }
2551 
2553 inline civector operator&(const sivector& v1, const civector_slice& v2) {
2554  return spf_vv_intersect<sivector,civector_slice,civector>(v1,v2);
2555 }
2556 
2558 inline scivector operator&(const scivector& v1, const sivector& v2) {
2559  return spsp_vv_intersect<scivector,sivector,scivector,cinterval>(v1,v2);
2560 }
2561 
2563 inline scivector operator&(const scivector& v1, const scivector& v2) {
2564  return spsp_vv_intersect<scivector,scivector,scivector,cinterval>(v1,v2);
2565 }
2566 
2568 inline scivector operator&(const sivector& v1, const scivector& v2) {
2569  return spsp_vv_intersect<sivector,scivector,scivector,cinterval>(v1,v2);
2570 }
2571 
2572 inline civector& civector::operator+=(const srvector& v2) {
2573  return fsp_vv_addassign(*this,v2);
2574 }
2575 
2576 inline civector& civector::operator+=(const scvector& v2) {
2577  return fsp_vv_addassign(*this,v2);
2578 }
2579 
2580 inline civector& civector::operator+=(const sivector& v2) {
2581  return fsp_vv_addassign(*this,v2);
2582 }
2583 
2584 inline civector& civector::operator+=(const scivector& v2) {
2585  return fsp_vv_addassign(*this,v2);
2586 }
2587 
2588 inline civector_slice& civector_slice::operator+=(const srvector& v2) {
2589  return fsp_vv_addassign(*this,v2);
2590 }
2591 
2592 inline civector_slice& civector_slice::operator+=(const scvector& v2) {
2593  return fsp_vv_addassign(*this,v2);
2594 }
2595 
2596 inline civector_slice& civector_slice::operator+=(const sivector& v2) {
2597  return fsp_vv_addassign(*this,v2);
2598 }
2599 
2600 inline civector_slice& civector_slice::operator+=(const scivector& v2) {
2601  return fsp_vv_addassign(*this,v2);
2602 }
2603 
2604 inline civector& civector::operator-=(const srvector& v2) {
2605  return fsp_vv_subassign(*this,v2);
2606 }
2607 
2608 inline civector& civector::operator-=(const scvector& v2) {
2609  return fsp_vv_subassign(*this,v2);
2610 }
2611 
2612 inline civector& civector::operator-=(const sivector& v2) {
2613  return fsp_vv_subassign(*this,v2);
2614 }
2615 
2616 inline civector& civector::operator-=(const scivector& v2) {
2617  return fsp_vv_subassign(*this,v2);
2618 }
2619 
2620 inline civector_slice& civector_slice::operator-=(const srvector& v2) {
2621  return fsp_vv_subassign(*this,v2);
2622 }
2623 
2624 inline civector_slice& civector_slice::operator-=(const scvector& v2) {
2625  return fsp_vv_subassign(*this,v2);
2626 }
2627 
2628 inline civector_slice& civector_slice::operator-=(const sivector& v2) {
2629  return fsp_vv_subassign(*this,v2);
2630 }
2631 
2632 inline civector_slice& civector_slice::operator-=(const scivector& v2) {
2633  return fsp_vv_subassign(*this,v2);
2634 }
2635 
2636 inline civector& civector::operator|=(const srvector& v2) {
2637  return fsp_vv_hullassign(*this,v2);
2638 }
2639 
2640 inline civector& civector::operator|=(const scvector& v2) {
2641  return fsp_vv_hullassign(*this,v2);
2642 }
2643 
2644 inline civector& civector::operator|=(const sivector& v2) {
2645  return fsp_vv_hullassign(*this,v2);
2646 }
2647 
2648 inline civector& civector::operator|=(const scivector& v2) {
2649  return fsp_vv_hullassign(*this,v2);
2650 }
2651 
2652 inline civector_slice& civector_slice::operator|=(const srvector& v2) {
2653  return fsp_vv_hullassign(*this,v2);
2654 }
2655 
2656 inline civector_slice& civector_slice::operator|=(const scvector& v2) {
2657  return fsp_vv_hullassign(*this,v2);
2658 }
2659 
2660 inline civector_slice& civector_slice::operator|=(const sivector& v2) {
2661  return fsp_vv_hullassign(*this,v2);
2662 }
2663 
2664 inline civector_slice& civector_slice::operator|=(const scivector& v2) {
2665  return fsp_vv_hullassign(*this,v2);
2666 }
2667 
2668 inline civector& civector::operator&=(const sivector& v2) {
2669  return fsp_vv_intersectassign(*this,v2);
2670 }
2671 
2672 inline civector& civector::operator&=(const scivector& v2) {
2673  return fsp_vv_intersectassign(*this,v2);
2674 }
2675 
2676 inline civector_slice& civector_slice::operator&=(const sivector& v2) {
2677  return fsp_vv_intersectassign(*this,v2);
2678 }
2679 
2680 inline civector_slice& civector_slice::operator&=(const scivector& v2) {
2681  return fsp_vv_intersectassign(*this,v2);
2682 }
2683 
2685 
2688 inline bool operator==(const scivector& v1, const scivector& v2) {
2689  return spsp_vv_comp(v1,v2);
2690 }
2691 
2693 
2696 inline bool operator==(const scivector& v1, const srvector& v2) {
2697  return spsp_vv_comp(v1,v2);
2698 }
2699 
2701 
2704 inline bool operator==(const scivector& v1, const sivector& v2) {
2705  return spsp_vv_comp(v1,v2);
2706 }
2707 
2709 
2712 inline bool operator==(const scivector& v1, const scvector& v2) {
2713  return spsp_vv_comp(v1,v2);
2714 }
2715 
2717 
2720 inline bool operator==(const srvector& v1, const scivector& v2) {
2721  return spsp_vv_comp(v1,v2);
2722 }
2723 
2725 
2728 inline bool operator==(const scvector& v1, const scivector& v2) {
2729  return spsp_vv_comp(v1,v2);
2730 }
2731 
2733 
2736 inline bool operator==(const sivector& v1, const scivector& v2) {
2737  return spsp_vv_comp(v1,v2);
2738 }
2739 
2741 
2744 inline bool operator==(const scivector& v1, const rvector& v2) {
2745  return spf_vv_comp(v1,v2);
2746 }
2747 
2749 
2752 inline bool operator==(const scivector& v1, const cvector& v2) {
2753  return spf_vv_comp(v1,v2);
2754 }
2755 
2757 
2760 inline bool operator==(const scivector& v1, const ivector& v2) {
2761  return spf_vv_comp(v1,v2);
2762 }
2763 
2765 
2768 inline bool operator==(const scivector& v1, const civector& v2) {
2769  return spf_vv_comp(v1,v2);
2770 }
2771 
2773 
2776 inline bool operator==(const srvector& v1, const civector& v2) {
2777  return spf_vv_comp(v1,v2);
2778 }
2779 
2781 
2784 inline bool operator==(const scvector& v1, const civector& v2) {
2785  return spf_vv_comp(v1,v2);
2786 }
2787 
2789 
2792 inline bool operator==(const sivector& v1, const civector& v2) {
2793  return spf_vv_comp(v1,v2);
2794 }
2795 
2797 
2800 inline bool operator==(const civector& v1, const srvector& v2) {
2801  return fsp_vv_comp(v1,v2);
2802 }
2803 
2805 
2808 inline bool operator==(const civector& v1, const scvector& v2) {
2809  return fsp_vv_comp(v1,v2);
2810 }
2811 
2813 
2816 inline bool operator==(const civector& v1, const sivector& v2) {
2817  return fsp_vv_comp(v1,v2);
2818 }
2819 
2821 
2824 inline bool operator==(const civector& v1, const scivector& v2) {
2825  return fsp_vv_comp(v1,v2);
2826 }
2827 
2829 
2832 inline bool operator==(const rvector& v1, const scivector& v2) {
2833  return fsp_vv_comp(v1,v2);
2834 }
2835 
2837 
2840 inline bool operator==(const cvector& v1, const scivector& v2) {
2841  return fsp_vv_comp(v1,v2);
2842 }
2843 
2845 
2848 inline bool operator==(const ivector& v1, const scivector& v2) {
2849  return fsp_vv_comp(v1,v2);
2850 }
2851 
2853 
2856 inline bool operator==(const scivector& v1, const rvector_slice& v2) {
2857  return spf_vv_comp(v1,v2);
2858 }
2859 
2861 
2864 inline bool operator==(const scivector& v1, const ivector_slice& v2) {
2865  return spf_vv_comp(v1,v2);
2866 }
2867 
2869 
2872 inline bool operator==(const scivector& v1, const cvector_slice& v2) {
2873  return spf_vv_comp(v1,v2);
2874 }
2875 
2877 
2880 inline bool operator==(const srvector& v1, const civector_slice& v2) {
2881  return spf_vv_comp(v1,v2);
2882 }
2883 
2885 
2888 inline bool operator==(const scvector& v1, const civector_slice& v2) {
2889  return spf_vv_comp(v1,v2);
2890 }
2891 
2893 
2896 inline bool operator==(const sivector& v1, const civector_slice& v2) {
2897  return spf_vv_comp(v1,v2);
2898 }
2899 
2901 
2904 inline bool operator==(const scivector& v1, const civector_slice& v2) {
2905  return spf_vv_comp(v1,v2);
2906 }
2907 
2909 
2912 inline bool operator==(const civector_slice& v1, const srvector& v2) {
2913  return fsp_vv_comp(v1,v2);
2914 }
2915 
2917 
2920 inline bool operator==(const civector_slice& v1, const sivector& v2) {
2921  return fsp_vv_comp(v1,v2);
2922 }
2923 
2925 
2928 inline bool operator==(const civector_slice& v1, const scvector& v2) {
2929  return fsp_vv_comp(v1,v2);
2930 }
2931 
2933 
2936 inline bool operator==(const rvector_slice& v1, const scivector& v2) {
2937  return fsp_vv_comp(v1,v2);
2938 }
2939 
2941 
2944 inline bool operator==(const ivector_slice& v1, const scivector& v2) {
2945  return fsp_vv_comp(v1,v2);
2946 }
2947 
2949 
2952 inline bool operator==(const cvector_slice& v1, const scivector& v2) {
2953  return fsp_vv_comp(v1,v2);
2954 }
2955 
2957 
2960 inline bool operator==(const civector_slice& v1, const scivector& v2) {
2961  return fsp_vv_comp(v1,v2);
2962 }
2963 
2965 
2968 inline bool operator!=(const scivector& v1, const scivector& v2) {
2969  return !spsp_vv_comp(v1,v2);
2970 }
2971 
2973 
2976 inline bool operator!=(const scivector& v1, const srvector& v2) {
2977  return !spsp_vv_comp(v1,v2);
2978 }
2979 
2981 
2984 inline bool operator!=(const scivector& v1, const sivector& v2) {
2985  return !spsp_vv_comp(v1,v2);
2986 }
2987 
2989 
2992 inline bool operator!=(const scivector& v1, const scvector& v2) {
2993  return !spsp_vv_comp(v1,v2);
2994 }
2995 
2997 
3000 inline bool operator!=(const srvector& v1, const scivector& v2) {
3001  return !spsp_vv_comp(v1,v2);
3002 }
3003 
3005 
3008 inline bool operator!=(const scvector& v1, const scivector& v2) {
3009  return !spsp_vv_comp(v1,v2);
3010 }
3011 
3013 
3016 inline bool operator!=(const sivector& v1, const scivector& v2) {
3017  return !spsp_vv_comp(v1,v2);
3018 }
3019 
3021 
3024 inline bool operator!=(const scivector& v1, const rvector& v2) {
3025  return !spf_vv_comp(v1,v2);
3026 }
3027 
3029 
3032 inline bool operator!=(const scivector& v1, const cvector& v2) {
3033  return !spf_vv_comp(v1,v2);
3034 }
3035 
3037 
3040 inline bool operator!=(const scivector& v1, const ivector& v2) {
3041  return !spf_vv_comp(v1,v2);
3042 }
3043 
3045 
3048 inline bool operator!=(const scivector& v1, const civector& v2) {
3049  return !spf_vv_comp(v1,v2);
3050 }
3051 
3053 
3056 inline bool operator!=(const srvector& v1, const civector& v2) {
3057  return !spf_vv_comp(v1,v2);
3058 }
3059 
3061 
3064 inline bool operator!=(const scvector& v1, const civector& v2) {
3065  return !spf_vv_comp(v1,v2);
3066 }
3067 
3069 
3072 inline bool operator!=(const sivector& v1, const civector& v2) {
3073  return !spf_vv_comp(v1,v2);
3074 }
3075 
3077 
3080 inline bool operator!=(const civector& v1, const srvector& v2) {
3081  return !fsp_vv_comp(v1,v2);
3082 }
3083 
3085 
3088 inline bool operator!=(const civector& v1, const sivector& v2) {
3089  return !fsp_vv_comp(v1,v2);
3090 }
3091 
3093 
3096 inline bool operator!=(const civector& v1, const scivector& v2) {
3097  return !fsp_vv_comp(v1,v2);
3098 }
3099 
3101 
3104 inline bool operator!=(const rvector& v1, const scivector& v2) {
3105  return !fsp_vv_comp(v1,v2);
3106 }
3107 
3109 
3112 inline bool operator!=(const cvector& v1, const scivector& v2) {
3113  return !fsp_vv_comp(v1,v2);
3114 }
3115 
3117 
3120 inline bool operator!=(const ivector& v1, const scivector& v2) {
3121  return !fsp_vv_comp(v1,v2);
3122 }
3123 
3125 
3128 inline bool operator!=(const scivector& v1, const rvector_slice& v2) {
3129  return !spf_vv_comp(v1,v2);
3130 }
3131 
3133 
3136 inline bool operator!=(const scivector& v1, const ivector_slice& v2) {
3137  return !spf_vv_comp(v1,v2);
3138 }
3139 
3141 
3144 inline bool operator!=(const scivector& v1, const cvector_slice& v2) {
3145  return !spf_vv_comp(v1,v2);
3146 }
3147 
3149 
3152 inline bool operator!=(const srvector& v1, const civector_slice& v2) {
3153  return !spf_vv_comp(v1,v2);
3154 }
3155 
3157 
3160 inline bool operator!=(const scvector& v1, const civector_slice& v2) {
3161  return !spf_vv_comp(v1,v2);
3162 }
3163 
3165 
3168 inline bool operator!=(const sivector& v1, const civector_slice& v2) {
3169  return !spf_vv_comp(v1,v2);
3170 }
3171 
3173 
3176 inline bool operator!=(const scivector& v1, const civector_slice& v2) {
3177  return !spf_vv_comp(v1,v2);
3178 }
3179 
3181 
3184 inline bool operator!=(const civector_slice& v1, const srvector& v2) {
3185  return !fsp_vv_comp(v1,v2);
3186 }
3187 
3189 
3192 inline bool operator!=(const civector_slice& v1, const sivector& v2) {
3193  return !fsp_vv_comp(v1,v2);
3194 }
3195 
3197 
3200 inline bool operator!=(const civector_slice& v1, const scvector& v2) {
3201  return !fsp_vv_comp(v1,v2);
3202 }
3203 
3205 
3208 inline bool operator!=(const rvector_slice& v1, const scivector& v2) {
3209  return !fsp_vv_comp(v1,v2);
3210 }
3211 
3213 
3216 inline bool operator!=(const ivector_slice& v1, const scivector& v2) {
3217  return !fsp_vv_comp(v1,v2);
3218 }
3219 
3221 
3224 inline bool operator!=(const cvector_slice& v1, const scivector& v2) {
3225  return !fsp_vv_comp(v1,v2);
3226 }
3227 
3229 
3232 inline bool operator!=(const civector_slice& v1, const scivector& v2) {
3233  return !fsp_vv_comp(v1,v2);
3234 }
3235 
3237 
3240 inline bool operator<(const scivector& v1, const scivector& v2) {
3241  return spsp_vv_less<scivector,scivector,cinterval>(v1,v2);
3242 }
3243 
3245 
3248 inline bool operator<(const scivector& v1, const sivector& v2) {
3249  return spsp_vv_less<scivector,sivector,cinterval>(v1,v2);
3250 }
3251 
3253 
3256 inline bool operator<(const srvector& v1, const scivector& v2) {
3257  return spsp_vv_less<srvector,scivector,cinterval>(v1,v2);
3258 }
3259 
3261 
3264 inline bool operator<(const scvector& v1, const scivector& v2) {
3265  return spsp_vv_less<scvector,scivector,cinterval>(v1,v2);
3266 }
3267 
3269 
3272 inline bool operator<(const sivector& v1, const scivector& v2) {
3273  return spsp_vv_less<sivector,scivector,cinterval>(v1,v2);
3274 }
3275 
3277 
3280 inline bool operator<(const scivector& v1, const ivector& v2) {
3281  return spf_vv_less<scivector,ivector,cinterval>(v1,v2);
3282 }
3283 
3285 
3288 inline bool operator<(const scivector& v1, const civector& v2) {
3289  return spf_vv_less<scivector,civector,cinterval>(v1,v2);
3290 }
3291 
3293 
3296 inline bool operator<(const srvector& v1, const civector& v2) {
3297  return spf_vv_less<srvector,civector,cinterval>(v1,v2);
3298 }
3299 
3301 
3304 inline bool operator<(const scvector& v1, const civector& v2) {
3305  return spf_vv_less<scvector,civector,cinterval>(v1,v2);
3306 }
3307 
3309 
3312 inline bool operator<(const sivector& v1, const civector& v2) {
3313  return spf_vv_less<sivector,civector,cinterval>(v1,v2);
3314 }
3315 
3317 
3320 inline bool operator<(const civector& v1, const sivector& v2) {
3321  return fsp_vv_less<civector,sivector,cinterval>(v1,v2);
3322 }
3323 
3325 
3328 inline bool operator<(const civector& v1, const scivector& v2) {
3329  return fsp_vv_less<civector,scivector,cinterval>(v1,v2);
3330 }
3331 
3333 
3336 inline bool operator<(const rvector& v1, const scivector& v2) {
3337  return fsp_vv_less<rvector,scivector,cinterval>(v1,v2);
3338 }
3339 
3341 
3344 inline bool operator<(const cvector& v1, const scivector& v2) {
3345  return fsp_vv_less<cvector,scivector,cinterval>(v1,v2);
3346 }
3347 
3349 
3352 inline bool operator<(const ivector& v1, const scivector& v2) {
3353  return fsp_vv_less<ivector,scivector,cinterval>(v1,v2);
3354 }
3355 
3357 
3360 inline bool operator<(const scivector& v1, const ivector_slice& v2) {
3361  return spf_vv_less<scivector,ivector_slice,cinterval>(v1,v2);
3362 }
3363 
3365 
3368 inline bool operator<(const srvector& v1, const civector_slice& v2) {
3369  return spf_vv_less<srvector,civector_slice,cinterval>(v1,v2);
3370 }
3371 
3373 
3376 inline bool operator<(const scvector& v1, const civector_slice& v2) {
3377  return spf_vv_less<scvector,civector_slice,cinterval>(v1,v2);
3378 }
3379 
3381 
3384 inline bool operator<(const sivector& v1, const civector_slice& v2) {
3385  return spf_vv_less<sivector,civector_slice,cinterval>(v1,v2);
3386 }
3387 
3389 
3392 inline bool operator<(const scivector& v1, const civector_slice& v2) {
3393  return spf_vv_less<scivector,civector_slice,cinterval>(v1,v2);
3394 }
3395 
3397 
3400 inline bool operator<(const civector_slice& v1, const sivector& v2) {
3401  return fsp_vv_less<civector_slice,sivector,cinterval>(v1,v2);
3402 }
3403 
3405 
3408 inline bool operator<(const rvector_slice& v1, const scivector& v2) {
3409  return fsp_vv_less<rvector_slice,scivector,cinterval>(v1,v2);
3410 }
3411 
3413 
3416 inline bool operator<(const ivector_slice& v1, const scivector& v2) {
3417  return fsp_vv_less<ivector_slice,scivector,cinterval>(v1,v2);
3418 }
3419 
3421 
3424 inline bool operator<(const cvector_slice& v1, const scivector& v2) {
3425  return fsp_vv_less<cvector_slice,scivector,cinterval>(v1,v2);
3426 }
3427 
3429 
3432 inline bool operator<(const civector_slice& v1, const scivector& v2) {
3433  return fsp_vv_less<civector_slice,scivector,cinterval>(v1,v2);
3434 }
3435 
3437 
3440 inline bool operator<=(const scivector& v1, const scivector& v2) {
3441  return spsp_vv_leq<scivector,scivector,cinterval>(v1,v2);
3442 }
3443 
3445 
3448 inline bool operator<=(const scivector& v1, const sivector& v2) {
3449  return spsp_vv_leq<scivector,sivector,cinterval>(v1,v2);
3450 }
3451 
3453 
3456 inline bool operator<=(const srvector& v1, const scivector& v2) {
3457  return spsp_vv_leq<srvector,scivector,cinterval>(v1,v2);
3458 }
3459 
3461 
3464 inline bool operator<=(const scvector& v1, const scivector& v2) {
3465  return spsp_vv_leq<scvector,scivector,cinterval>(v1,v2);
3466 }
3467 
3469 
3472 inline bool operator<=(const sivector& v1, const scivector& v2) {
3473  return spsp_vv_leq<sivector,scivector,cinterval>(v1,v2);
3474 }
3475 
3477 
3480 inline bool operator<=(const scivector& v1, const ivector& v2) {
3481  return spf_vv_leq<scivector,ivector,cinterval>(v1,v2);
3482 }
3483 
3485 
3488 inline bool operator<=(const scivector& v1, const civector& v2) {
3489  return spf_vv_leq<scivector,civector,cinterval>(v1,v2);
3490 }
3491 
3493 
3496 inline bool operator<=(const srvector& v1, const civector& v2) {
3497  return spf_vv_leq<srvector,civector,cinterval>(v1,v2);
3498 }
3499 
3501 
3504 inline bool operator<=(const scvector& v1, const civector& v2) {
3505  return spf_vv_leq<scvector,civector,cinterval>(v1,v2);
3506 }
3507 
3509 
3512 inline bool operator<=(const sivector& v1, const civector& v2) {
3513  return spf_vv_leq<sivector,civector,cinterval>(v1,v2);
3514 }
3515 
3517 
3520 inline bool operator<=(const civector& v1, const sivector& v2) {
3521  return fsp_vv_leq<civector,sivector,cinterval>(v1,v2);
3522 }
3523 
3525 
3528 inline bool operator<=(const civector& v1, const scivector& v2) {
3529  return fsp_vv_leq<civector,scivector,cinterval>(v1,v2);
3530 }
3531 
3533 
3536 inline bool operator<=(const rvector& v1, const scivector& v2) {
3537  return fsp_vv_leq<rvector,scivector,cinterval>(v1,v2);
3538 }
3539 
3541 
3544 inline bool operator<=(const cvector& v1, const scivector& v2) {
3545  return fsp_vv_leq<cvector,scivector,cinterval>(v1,v2);
3546 }
3547 
3549 
3552 inline bool operator<=(const ivector& v1, const scivector& v2) {
3553  return fsp_vv_leq<ivector,scivector,cinterval>(v1,v2);
3554 }
3555 
3557 
3560 inline bool operator<=(const scivector& v1, const ivector_slice& v2) {
3561  return spf_vv_leq<scivector,ivector_slice,cinterval>(v1,v2);
3562 }
3563 
3565 
3568 inline bool operator<=(const srvector& v1, const civector_slice& v2) {
3569  return spf_vv_leq<srvector,civector_slice,cinterval>(v1,v2);
3570 }
3571 
3573 
3576 inline bool operator<=(const scvector& v1, const civector_slice& v2) {
3577  return spf_vv_leq<scvector,civector_slice,cinterval>(v1,v2);
3578 }
3579 
3581 
3584 inline bool operator<=(const sivector& v1, const civector_slice& v2) {
3585  return spf_vv_leq<sivector,civector_slice,cinterval>(v1,v2);
3586 }
3587 
3589 
3592 inline bool operator<=(const scivector& v1, const civector_slice& v2) {
3593  return spf_vv_leq<scivector,civector_slice,cinterval>(v1,v2);
3594 }
3595 
3597 
3600 inline bool operator<=(const civector_slice& v1, const sivector& v2) {
3601  return fsp_vv_leq<civector_slice,sivector,cinterval>(v1,v2);
3602 }
3603 
3605 
3608 inline bool operator<=(const rvector_slice& v1, const scivector& v2) {
3609  return fsp_vv_leq<rvector_slice,scivector,cinterval>(v1,v2);
3610 }
3611 
3613 
3616 inline bool operator<=(const ivector_slice& v1, const scivector& v2) {
3617  return fsp_vv_leq<ivector_slice,scivector,cinterval>(v1,v2);
3618 }
3619 
3621 
3624 inline bool operator<=(const cvector_slice& v1, const scivector& v2) {
3625  return fsp_vv_leq<cvector_slice,scivector,cinterval>(v1,v2);
3626 }
3627 
3629 
3632 inline bool operator<=(const civector_slice& v1, const scivector& v2) {
3633  return fsp_vv_leq<civector_slice,scivector,cinterval>(v1,v2);
3634 }
3635 
3637 
3640 inline bool operator>(const scivector& v1, const scivector& v2) {
3641  return spsp_vv_greater<scivector,scivector,cinterval>(v1,v2);
3642 }
3643 
3645 
3648 inline bool operator>(const scivector& v1, const srvector& v2) {
3649  return spsp_vv_greater<scivector,srvector,cinterval>(v1,v2);
3650 }
3651 
3653 
3656 inline bool operator>(const scivector& v1, const sivector& v2) {
3657  return spsp_vv_greater<scivector,sivector,cinterval>(v1,v2);
3658 }
3659 
3661 
3664 inline bool operator>(const scivector& v1, const scvector& v2) {
3665  return spsp_vv_greater<scivector,scvector,cinterval>(v1,v2);
3666 }
3667 
3669 
3672 inline bool operator>(const sivector& v1, const scivector& v2) {
3673  return spsp_vv_greater<sivector,scivector,cinterval>(v1,v2);
3674 }
3675 
3677 
3680 inline bool operator>(const scivector& v1, const rvector& v2) {
3681  return spf_vv_greater<scivector,rvector,cinterval>(v1,v2);
3682 }
3683 
3685 
3688 inline bool operator>(const scivector& v1, const cvector& v2) {
3689  return spf_vv_greater<scivector,cvector,cinterval>(v1,v2);
3690 }
3691 
3693 
3696 inline bool operator>(const scivector& v1, const ivector& v2) {
3697  return spf_vv_greater<scivector,ivector,cinterval>(v1,v2);
3698 }
3699 
3701 
3704 inline bool operator>(const scivector& v1, const civector& v2) {
3705  return spf_vv_greater<scivector,civector,cinterval>(v1,v2);
3706 }
3707 
3709 
3712 inline bool operator>(const sivector& v1, const civector& v2) {
3713  return spf_vv_greater<sivector,civector,cinterval>(v1,v2);
3714 }
3715 
3717 
3720 inline bool operator>(const civector& v1, const srvector& v2) {
3721  return fsp_vv_greater<civector,srvector,cinterval>(v1,v2);
3722 }
3723 
3725 
3728 inline bool operator>(const civector& v1, const scvector& v2) {
3729  return fsp_vv_greater<civector,scvector,cinterval>(v1,v2);
3730 }
3731 
3733 
3736 inline bool operator>(const civector& v1, const sivector& v2) {
3737  return fsp_vv_greater<civector,sivector,cinterval>(v1,v2);
3738 }
3739 
3741 
3744 inline bool operator>(const civector& v1, const scivector& v2) {
3745  return fsp_vv_greater<civector,scivector,cinterval>(v1,v2);
3746 }
3747 
3749 
3752 inline bool operator>(const ivector& v1, const scivector& v2) {
3753  return fsp_vv_greater<ivector,scivector,cinterval>(v1,v2);
3754 }
3755 
3757 
3760 inline bool operator>(const scivector& v1, const rvector_slice& v2) {
3761  return spf_vv_greater<scivector,rvector_slice,cinterval>(v1,v2);
3762 }
3763 
3765 
3768 inline bool operator>(const scivector& v1, const ivector_slice& v2) {
3769  return spf_vv_greater<scivector,ivector_slice,cinterval>(v1,v2);
3770 }
3771 
3773 
3776 inline bool operator>(const scivector& v1, const cvector_slice& v2) {
3777  return spf_vv_greater<scivector,cvector_slice,cinterval>(v1,v2);
3778 }
3779 
3781 
3784 inline bool operator>(const sivector& v1, const civector_slice& v2) {
3785  return spf_vv_greater<sivector,civector_slice,cinterval>(v1,v2);
3786 }
3787 
3789 
3792 inline bool operator>(const scivector& v1, const civector_slice& v2) {
3793  return spf_vv_greater<scivector,civector_slice,cinterval>(v1,v2);
3794 }
3795 
3797 
3800 inline bool operator>(const civector_slice& v1, const srvector& v2) {
3801  return fsp_vv_greater<civector_slice,srvector,cinterval>(v1,v2);
3802 }
3803 
3805 
3808 inline bool operator>(const civector_slice& v1, const sivector& v2) {
3809  return fsp_vv_greater<civector_slice,sivector,cinterval>(v1,v2);
3810 }
3811 
3813 
3816 inline bool operator>(const civector_slice& v1, const scvector& v2) {
3817  return fsp_vv_greater<civector_slice,scvector,cinterval>(v1,v2);
3818 }
3819 
3821 
3824 inline bool operator>(const ivector_slice& v1, const scivector& v2) {
3825  return fsp_vv_greater<ivector_slice,scivector,cinterval>(v1,v2);
3826 }
3827 
3829 
3832 inline bool operator>(const civector_slice& v1, const scivector& v2) {
3833  return fsp_vv_greater<civector_slice,scivector,cinterval>(v1,v2);
3834 }
3835 
3837 
3840 inline bool operator>=(const scivector& v1, const scivector& v2) {
3841  return spsp_vv_geq<scivector,scivector,cinterval>(v1,v2);
3842 }
3843 
3845 
3848 inline bool operator>=(const scivector& v1, const srvector& v2) {
3849  return spsp_vv_geq<scivector,srvector,cinterval>(v1,v2);
3850 }
3851 
3853 
3856 inline bool operator>=(const scivector& v1, const sivector& v2) {
3857  return spsp_vv_geq<scivector,sivector,cinterval>(v1,v2);
3858 }
3859 
3861 
3864 inline bool operator>=(const scivector& v1, const scvector& v2) {
3865  return spsp_vv_geq<scivector,scvector,cinterval>(v1,v2);
3866 }
3867 
3869 
3872 inline bool operator>=(const sivector& v1, const scivector& v2) {
3873  return spsp_vv_geq<sivector,scivector,cinterval>(v1,v2);
3874 }
3875 
3877 
3880 inline bool operator>=(const scivector& v1, const rvector& v2) {
3881  return spf_vv_geq<scivector,rvector,cinterval>(v1,v2);
3882 }
3883 
3885 
3888 inline bool operator>=(const scivector& v1, const cvector& v2) {
3889  return spf_vv_geq<scivector,cvector,cinterval>(v1,v2);
3890 }
3891 
3893 
3896 inline bool operator>=(const scivector& v1, const ivector& v2) {
3897  return spf_vv_geq<scivector,ivector,cinterval>(v1,v2);
3898 }
3899 
3901 
3904 inline bool operator>=(const scivector& v1, const civector& v2) {
3905  return spf_vv_geq<scivector,civector,cinterval>(v1,v2);
3906 }
3907 
3909 
3912 inline bool operator>=(const sivector& v1, const civector& v2) {
3913  return spf_vv_geq<sivector,civector,cinterval>(v1,v2);
3914 }
3915 
3917 
3920 inline bool operator>=(const civector& v1, const srvector& v2) {
3921  return fsp_vv_geq<civector,srvector,cinterval>(v1,v2);
3922 }
3923 
3925 
3928 inline bool operator>=(const civector& v1, const scvector& v2) {
3929  return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
3930 }
3931 
3933 
3936 inline bool operator>=(const civector& v1, const sivector& v2) {
3937  return fsp_vv_geq<civector,sivector,cinterval>(v1,v2);
3938 }
3939 
3941 
3944 inline bool operator>=(const civector& v1, const scivector& v2) {
3945  return fsp_vv_geq<civector,scivector,cinterval>(v1,v2);
3946 }
3947 
3949 
3952 inline bool operator>=(const ivector& v1, const scivector& v2) {
3953  return fsp_vv_geq<ivector,scivector,cinterval>(v1,v2);
3954 }
3955 
3957 
3960 inline bool operator>=(const scivector& v1, const rvector_slice& v2) {
3961  return spf_vv_geq<scivector,rvector_slice,cinterval>(v1,v2);
3962 }
3963 
3965 
3968 inline bool operator>=(const scivector& v1, const ivector_slice& v2) {
3969  return spf_vv_geq<scivector,ivector_slice,cinterval>(v1,v2);
3970 }
3971 
3973 
3976 inline bool operator>=(const scivector& v1, const cvector_slice& v2) {
3977  return spf_vv_geq<scivector,cvector_slice,cinterval>(v1,v2);
3978 }
3979 
3981 
3984 inline bool operator>=(const sivector& v1, const civector_slice& v2) {
3985  return spf_vv_geq<sivector,civector_slice,cinterval>(v1,v2);
3986 }
3987 
3989 
3992 inline bool operator>=(const scivector& v1, const civector_slice& v2) {
3993  return spf_vv_geq<scivector,civector_slice,cinterval>(v1,v2);
3994 }
3995 
3997 
4000 inline bool operator>=(const civector_slice& v1, const srvector& v2) {
4001  return fsp_vv_geq<civector_slice,srvector,cinterval>(v1,v2);
4002 }
4003 
4005 
4008 inline bool operator>=(const civector_slice& v1, const sivector& v2) {
4009  return fsp_vv_geq<civector_slice,sivector,cinterval>(v1,v2);
4010 }
4011 
4013 
4016 inline bool operator>=(const civector_slice& v1, const scvector& v2) {
4017  return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
4018 }
4019 
4021 
4024 inline bool operator>=(const ivector_slice& v1, const scivector& v2) {
4025  return fsp_vv_geq<ivector_slice,scivector,cinterval>(v1,v2);
4026 }
4027 
4029 
4032 inline bool operator>=(const civector_slice& v1, const scivector& v2) {
4033  return fsp_vv_geq<civector_slice,scivector,cinterval>(v1,v2);
4034 }
4035 
4037 
4042 inline std::ostream& operator<<(std::ostream& os, const scivector& v) {
4043  return sp_v_output<scivector,cinterval>(os,v);
4044 }
4045 
4047 
4052 inline 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 
4693 inline 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 
4704 inline 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 
4715 inline 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 
4726 inline 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 
4753 inline 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 
4761 inline scivector operator-(const scivector_slice& v) {
4762  return sl_v_negative<scivector_slice,scivector>(v);
4763 }
4764 
4766 inline int Lb(const scivector_slice& v) {
4767  return v.lb;
4768 }
4769 
4771 inline int Ub(const scivector_slice& v) {
4772  return v.ub;
4773 }
4774 
4776 inline sivector Re(const scivector_slice& v) {
4777  return Re(scivector(v));
4778 }
4779 
4781 inline sivector Im(const scivector_slice& v) {
4782  return Im(scivector(v));
4783 }
4784 
4786 inline scvector Inf(const scivector_slice& v) {
4787  return Inf(scivector(v));
4788 }
4789 
4791 inline scvector Sup(const scivector_slice& v) {
4792  return Sup(scivector(v));
4793 }
4794 
4796 inline srvector InfRe(const scivector_slice& v) {
4797  return InfRe(scivector(v));
4798 }
4799 
4801 inline srvector InfIm(const scivector_slice& v) {
4802  return InfIm(scivector(v));
4803 }
4804 
4806 inline srvector SupRe(const scivector_slice& v) {
4807  return SupRe(scivector(v));
4808 }
4809 
4811 inline srvector SupIm(const scivector_slice& v) {
4812  return SupIm(scivector(v));
4813 }
4814 
4816 inline 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 
4827 inline 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 
4838 inline 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 
4849 inline scvector diam(const scivector_slice& v) {
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 
4860 inline int VecLen(const scivector_slice& v) {
4861  return v.n;
4862 }
4863 
4865 
4871 inline 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 
4882 inline 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 
4893 inline 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 
4904 inline 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 
4915 inline 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 
4926 inline 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 
4937 inline 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 
4948 inline 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 
4959 inline 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 
4970 inline 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 
4981 inline 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 
4992 inline 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 
5003 inline 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 
5014 inline 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 
5025 inline 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 
5036 inline 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 
5047 inline 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 
5058 inline 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 
5069 inline 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 
5080 inline 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 
5091 inline 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 
5102 inline cinterval operator*(const scivector_slice& v1, const civector_slice& v2) {
5103  return slf_vv_mult<scivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
5104 }
5105 
5107 
5113 inline 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 
5124 inline 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 
5135 inline 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 
5146 inline 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 
5157 inline 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 
5168 inline 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 
5179 inline 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 
5190 inline 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 
5201 inline cinterval operator*(const civector_slice& v1, const scivector_slice& v2) {
5202  return fsl_vv_mult<civector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5203 }
5204 
5206 
5212 inline 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 
5223 inline 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 
5234 inline 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 
5245 inline 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 
5256 inline 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 
5267 inline 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 
5278 inline 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 
5289 inline 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 
5300 inline 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 
5311 inline 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 
5322 inline 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 
5333 inline 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 
5344 inline 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 
5355 inline 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 
5366 inline 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 
5377 inline 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 
5388 inline 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 
5399 inline 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 
5410 inline 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 
5421 inline 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 
5432 inline 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 
5443 inline 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 
5454 inline 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 
5465 inline cinterval operator*(const scivector_slice& v1, const srvector_slice& v2) {
5466  return slsl_vv_mult<scivector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
5467 }
5468 
5470 
5476 inline cinterval operator*(const scivector_slice& v1, const scvector_slice& v2) {
5477  return slsl_vv_mult<scivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
5478 }
5479 
5481 
5487 inline cinterval operator*(const scivector_slice& v1, const sivector_slice& v2) {
5488  return slsl_vv_mult<scivector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
5489 }
5490 
5492 
5498 inline cinterval operator*(const scivector_slice& v1, const scivector_slice& v2) {
5499  return slsl_vv_mult<scivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5500 }
5501 
5503 
5509 inline cinterval operator*(const srvector_slice& v1, const scivector_slice& v2) {
5510  return slsl_vv_mult<srvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5511 }
5512 
5514 
5520 inline cinterval operator*(const scvector_slice& v1, const scivector_slice& v2) {
5521  return slsl_vv_mult<scvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5522 }
5523 
5525 
5531 inline cinterval operator*(const sivector_slice& v1, const scivector_slice& v2) {
5532  return slsl_vv_mult<sivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
5533 }
5534 
5536 
5542 inline 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 
5553 inline 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 
5558 inline scivector operator*(const scivector_slice& v, const real& s) {
5559  return sp_vs_mult<scivector_slice,real,scivector>(v,s);
5560 }
5561 
5563 inline scivector operator*(const scivector_slice& v, const complex& s) {
5564  return sp_vs_mult<scivector_slice,complex,scivector>(v,s);
5565 }
5566 
5568 inline scivector operator*(const scivector_slice& v, const interval& s) {
5569  return sp_vs_mult<scivector_slice,interval,scivector>(v,s);
5570 }
5571 
5573 inline scivector operator*(const scivector_slice& v, const cinterval& s) {
5574  return sp_vs_mult<scivector_slice,cinterval,scivector>(v,s);
5575 }
5576 
5578 inline scivector operator*(const srvector_slice& v, const cinterval& s) {
5579  return sp_vs_mult<srvector_slice,cinterval,scivector>(v,s);
5580 }
5581 
5583 inline scivector operator*(const scvector_slice& v, const cinterval& s) {
5584  return sp_vs_mult<scvector_slice,cinterval,scivector>(v,s);
5585 }
5586 
5588 inline scivector operator*(const sivector_slice& v, const cinterval& s) {
5589  return sp_vs_mult<sivector_slice,cinterval,scivector>(v,s);
5590 }
5591 
5593 inline scivector operator*(const scvector_slice& v, const interval& s) {
5594  return sp_vs_mult<scvector_slice,interval,scivector>(v,s);
5595 }
5596 
5598 inline scivector operator*(const sivector_slice& v, const complex& s) {
5599  return sp_vs_mult<sivector_slice,complex,scivector>(v,s);
5600 }
5601 
5603 inline scivector operator/(const scivector_slice& v, const real& s) {
5604  return sp_vs_div<scivector_slice,real,scivector>(v,s);
5605 }
5606 
5608 inline scivector operator/(const scivector_slice& v, const complex& s) {
5609  return sp_vs_div<scivector_slice,complex,scivector>(v,s);
5610 }
5611 
5613 inline scivector operator/(const scivector_slice& v, const interval& s) {
5614  return sp_vs_div<scivector_slice,interval,scivector>(v,s);
5615 }
5616 
5618 inline scivector operator/(const scivector_slice& v, const cinterval& s) {
5619  return sp_vs_div<scivector_slice,cinterval,scivector>(v,s);
5620 }
5621 
5623 inline scivector operator/(const srvector_slice& v, const cinterval& s) {
5624  return sp_vs_div<srvector_slice,cinterval,scivector>(v,s);
5625 }
5626 
5628 inline scivector operator/(const scvector_slice& v, const cinterval& s) {
5629  return sp_vs_div<scvector_slice,cinterval,scivector>(v,s);
5630 }
5631 
5633 inline scivector operator/(const sivector_slice& v, const cinterval& s) {
5634  return sp_vs_div<sivector_slice,cinterval,scivector>(v,s);
5635 }
5636 
5638 inline scivector operator/(const scvector_slice& v, const interval& s) {
5639  return sp_vs_div<scvector_slice,interval,scivector>(v,s);
5640 }
5641 
5643 inline scivector operator/(const sivector_slice& v, const complex& s) {
5644  return sp_vs_div<sivector_slice,complex,scivector>(v,s);
5645 }
5646 
5648 inline scivector operator*(const real& s, const scivector_slice& v) {
5649  return sp_sv_mult<real,scivector_slice,scivector>(s,v);
5650 }
5651 
5653 inline scivector operator*(const complex& s, const scivector_slice& v) {
5654  return sp_sv_mult<complex,scivector_slice,scivector>(s,v);
5655 }
5656 
5658 inline scivector operator*(const interval& s, const scivector_slice& v) {
5659  return sp_sv_mult<interval,scivector_slice,scivector>(s,v);
5660 }
5661 
5663 inline scivector operator*(const cinterval& s, const scivector_slice& v) {
5664  return sp_sv_mult<cinterval,scivector_slice,scivector>(s,v);
5665 }
5666 
5668 inline scivector operator*(const cinterval& s, const srvector_slice& v) {
5669  return sp_sv_mult<cinterval,srvector_slice,scivector>(s,v);
5670 }
5671 
5673 inline scivector operator*(const cinterval& s, const scvector_slice& v) {
5674  return sp_sv_mult<cinterval,scvector_slice,scivector>(s,v);
5675 }
5676 
5678 inline scivector operator*(const cinterval& s, const sivector_slice& v) {
5679  return sp_sv_mult<cinterval,sivector_slice,scivector>(s,v);
5680 }
5681 
5683 inline scivector operator*(const complex& s, const sivector_slice& v) {
5684  return sp_sv_mult<complex,sivector_slice,scivector>(s,v);
5685 }
5686 
5688 inline scivector operator*(const interval& s, const scvector_slice& v) {
5689  return sp_sv_mult<interval,scvector_slice,scivector>(s,v);
5690 }
5691 
5693 inline civector operator+(const civector& v1, const srvector_slice& v2) {
5694  return fsl_vv_add<civector,srvector_slice,civector>(v1,v2);
5695 }
5696 
5698 inline civector operator+(const civector& v1, const scvector_slice& v2) {
5699  return fsl_vv_add<civector,scvector_slice,civector>(v1,v2);
5700 }
5701 
5703 inline civector operator+(const civector& v1, const sivector_slice& v2) {
5704  return fsl_vv_add<civector,sivector_slice,civector>(v1,v2);
5705 }
5706 
5708 inline civector operator+(const civector& v1, const scivector_slice& v2) {
5709  return fsl_vv_add<civector,scivector_slice,civector>(v1,v2);
5710 }
5711 
5713 inline civector operator+(const rvector& v1, const scivector_slice& v2) {
5714  return fsl_vv_add<rvector,scivector_slice,civector>(v1,v2);
5715 }
5716 
5718 inline civector operator+(const cvector& v1, const scivector_slice& v2) {
5719  return fsl_vv_add<cvector,scivector_slice,civector>(v1,v2);
5720 }
5721 
5723 inline civector operator+(const ivector& v1, const scivector_slice& v2) {
5724  return fsl_vv_add<ivector,scivector_slice,civector>(v1,v2);
5725 }
5726 
5728 inline civector operator+(const cvector& v1, const sivector_slice& v2) {
5729  return fsl_vv_add<cvector,sivector_slice,civector>(v1,v2);
5730 }
5731 
5733 inline civector operator+(const ivector& v1, const scvector_slice& v2) {
5734  return fsl_vv_add<ivector,scvector_slice,civector>(v1,v2);
5735 }
5736 
5738 inline civector operator+(const scivector_slice& v1, const rvector& v2) {
5739  return slf_vv_add<scivector_slice,rvector,civector>(v1,v2);
5740 }
5741 
5743 inline civector operator+(const scivector_slice& v1, const cvector& v2) {
5744  return slf_vv_add<scivector_slice,cvector,civector>(v1,v2);
5745 }
5746 
5748 inline civector operator+(const scivector_slice& v1, const ivector& v2) {
5749  return slf_vv_add<scivector_slice,ivector,civector>(v1,v2);
5750 }
5751 
5753 inline civector operator+(const scivector_slice& v1, const civector& v2) {
5754  return slf_vv_add<scivector_slice,civector,civector>(v1,v2);
5755 }
5756 
5758 inline civector operator+(const srvector_slice& v1, const civector& v2) {
5759  return slf_vv_add<srvector_slice,civector,civector>(v1,v2);
5760 }
5761 
5763 inline civector operator+(const scvector_slice& v1, const civector& v2) {
5764  return slf_vv_add<scvector_slice,civector,civector>(v1,v2);
5765 }
5766 
5768 inline civector operator+(const sivector_slice& v1, const civector& v2) {
5769  return slf_vv_add<sivector_slice,civector,civector>(v1,v2);
5770 }
5771 
5773 inline civector operator+(const scvector_slice& v1, const ivector& v2) {
5774  return slf_vv_add<scvector_slice,ivector,civector>(v1,v2);
5775 }
5776 
5778 inline civector operator+(const sivector_slice& v1, const cvector& v2) {
5779  return slf_vv_add<sivector_slice,cvector,civector>(v1,v2);
5780 }
5781 
5783 inline civector operator+(const civector_slice& v1, const srvector_slice& v2) {
5784  return fsl_vv_add<civector_slice,srvector_slice,civector>(v1,v2);
5785 }
5786 
5788 inline civector operator+(const civector_slice& v1, const scvector_slice& v2) {
5789  return fsl_vv_add<civector_slice,scvector_slice,civector>(v1,v2);
5790 }
5791 
5793 inline civector operator+(const civector_slice& v1, const sivector_slice& v2) {
5794  return fsl_vv_add<civector_slice,sivector_slice,civector>(v1,v2);
5795 }
5796 
5798 inline civector operator+(const civector_slice& v1, const scivector_slice& v2) {
5799  return fsl_vv_add<civector_slice,scivector_slice,civector>(v1,v2);
5800 }
5801 
5803 inline civector operator+(const rvector_slice& v1, const scivector_slice& v2) {
5804  return fsl_vv_add<rvector_slice,scivector_slice,civector>(v1,v2);
5805 }
5806 
5808 inline civector operator+(const cvector_slice& v1, const scivector_slice& v2) {
5809  return fsl_vv_add<cvector_slice,scivector_slice,civector>(v1,v2);
5810 }
5811 
5813 inline civector operator+(const ivector_slice& v1, const scivector_slice& v2) {
5814  return fsl_vv_add<ivector_slice,scivector_slice,civector>(v1,v2);
5815 }
5816 
5818 inline civector operator+(const ivector_slice& v1, const scvector_slice& v2) {
5819  return fsl_vv_add<ivector_slice,scvector_slice,civector>(v1,v2);
5820 }
5821 
5823 inline civector operator+(const cvector_slice& v1, const sivector_slice& v2) {
5824  return fsl_vv_add<cvector_slice,sivector_slice,civector>(v1,v2);
5825 }
5826 
5828 inline civector operator+(const scivector_slice& v1, const rvector_slice& v2) {
5829  return slf_vv_add<scivector_slice,rvector_slice,civector>(v1,v2);
5830 }
5831 
5833 inline civector operator+(const scivector_slice& v1, const ivector_slice& v2) {
5834  return slf_vv_add<scivector_slice,ivector_slice,civector>(v1,v2);
5835 }
5836 
5838 inline civector operator+(const scivector_slice& v1, const cvector_slice& v2) {
5839  return slf_vv_add<scivector_slice,cvector_slice,civector>(v1,v2);
5840 }
5841 
5843 inline civector operator+(const scivector_slice& v1, const civector_slice& v2) {
5844  return slf_vv_add<scivector_slice,civector_slice,civector>(v1,v2);
5845 }
5846 
5848 inline civector operator+(const srvector_slice& v1, const civector_slice& v2) {
5849  return slf_vv_add<srvector_slice,civector_slice,civector>(v1,v2);
5850 }
5851 
5853 inline civector operator+(const sivector_slice& v1, const civector_slice& v2) {
5854  return slf_vv_add<sivector_slice,civector_slice,civector>(v1,v2);
5855 }
5856 
5858 inline civector operator+(const scvector_slice& v1, const civector_slice& v2) {
5859  return slf_vv_add<scvector_slice,civector_slice,civector>(v1,v2);
5860 }
5861 
5863 inline civector operator+(const scvector_slice& v1, const ivector_slice& v2) {
5864  return slf_vv_add<scvector_slice,ivector_slice,civector>(v1,v2);
5865 }
5866 
5868 inline civector operator+(const sivector_slice& v1, const cvector_slice& v2) {
5869  return slf_vv_add<sivector_slice,cvector_slice,civector>(v1,v2);
5870 }
5871 
5873 inline 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 
5878 inline 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 
5883 inline 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 
5888 inline 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 
5893 inline 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 
5898 inline 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 
5903 inline 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 
5908 inline 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 
5913 inline 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 
5918 inline scivector operator+(const scivector& v1, const srvector_slice& v2) {
5919  return spsl_vv_add<scivector,srvector_slice,scivector,cinterval>(v1,v2);
5920 }
5921 
5923 inline scivector operator+(const scivector& v1, const scvector_slice& v2) {
5924  return spsl_vv_add<scivector,scvector_slice,scivector,cinterval>(v1,v2);
5925 }
5926 
5928 inline scivector operator+(const scivector& v1, const sivector_slice& v2) {
5929  return spsl_vv_add<scivector,sivector_slice,scivector,cinterval>(v1,v2);
5930 }
5931 
5933 inline scivector operator+(const scivector& v1, const scivector_slice& v2) {
5934  return spsl_vv_add<scivector,scivector_slice,scivector,cinterval>(v1,v2);
5935 }
5936 
5938 inline scivector operator+(const srvector& v1, const scivector_slice& v2) {
5939  return spsl_vv_add<srvector,scivector_slice,scivector,cinterval>(v1,v2);
5940 }
5941 
5943 inline scivector operator+(const scvector& v1, const scivector_slice& v2) {
5944  return spsl_vv_add<scvector,scivector_slice,scivector,cinterval>(v1,v2);
5945 }
5946 
5948 inline scivector operator+(const sivector& v1, const scivector_slice& v2) {
5949  return spsl_vv_add<sivector,scivector_slice,scivector,cinterval>(v1,v2);
5950 }
5951 
5953 inline scivector operator+(const scvector& v1, const sivector_slice& v2) {
5954  return spsl_vv_add<scvector,sivector_slice,scivector,cinterval>(v1,v2);
5955 }
5956 
5958 inline scivector operator+(const sivector& v1, const scvector_slice& v2) {
5959  return spsl_vv_add<sivector,scvector_slice,scivector,cinterval>(v1,v2);
5960 }
5961 
5963 inline scivector operator+(const scivector_slice& v1, const srvector& v2) {
5964  return slsp_vv_add<scivector_slice,srvector,scivector,cinterval>(v1,v2);
5965 }
5966 
5968 inline scivector operator+(const scivector_slice& v1, const scvector& v2) {
5969  return slsp_vv_add<scivector_slice,scvector,scivector,cinterval>(v1,v2);
5970 }
5971 
5973 inline scivector operator+(const scivector_slice& v1, const sivector& v2) {
5974  return slsp_vv_add<scivector_slice,sivector,scivector,cinterval>(v1,v2);
5975 }
5976 
5978 inline scivector operator+(const scivector_slice& v1, const scivector& v2) {
5979  return slsp_vv_add<scivector_slice,scivector,scivector,cinterval>(v1,v2);
5980 }
5981 
5983 inline scivector operator+(const srvector_slice& v1, const scivector& v2) {
5984  return slsp_vv_add<srvector_slice,scivector,scivector,cinterval>(v1,v2);
5985 }
5986 
5988 inline scivector operator+(const scvector_slice& v1, const scivector& v2) {
5989  return slsp_vv_add<scvector_slice,scivector,scivector,cinterval>(v1,v2);
5990 }
5991 
5993 inline scivector operator+(const sivector_slice& v1, const scivector& v2) {
5994  return slsp_vv_add<sivector_slice,scivector,scivector,cinterval>(v1,v2);
5995 }
5996 
5998 inline scivector operator+(const scvector_slice& v1, const sivector& v2) {
5999  return slsp_vv_add<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6000 }
6001 
6003 inline scivector operator+(const sivector_slice& v1, const scvector& v2) {
6004  return slsp_vv_add<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6005 }
6006 
6008 inline civector operator-(const civector& v1, const srvector_slice& v2) {
6009  return fsl_vv_sub<civector,srvector_slice,civector>(v1,v2);
6010 }
6011 
6013 inline civector operator-(const civector& v1, const scvector_slice& v2) {
6014  return fsl_vv_sub<civector,scvector_slice,civector>(v1,v2);
6015 }
6016 
6018 inline civector operator-(const civector& v1, const sivector_slice& v2) {
6019  return fsl_vv_sub<civector,sivector_slice,civector>(v1,v2);
6020 }
6021 
6023 inline civector operator-(const civector& v1, const scivector_slice& v2) {
6024  return fsl_vv_sub<civector,scivector_slice,civector>(v1,v2);
6025 }
6026 
6028 inline civector operator-(const rvector& v1, const scivector_slice& v2) {
6029  return fsl_vv_sub<rvector,scivector_slice,civector>(v1,v2);
6030 }
6031 
6033 inline civector operator-(const cvector& v1, const scivector_slice& v2) {
6034  return fsl_vv_sub<cvector,scivector_slice,civector>(v1,v2);
6035 }
6036 
6038 inline civector operator-(const ivector& v1, const scivector_slice& v2) {
6039  return fsl_vv_sub<ivector,scivector_slice,civector>(v1,v2);
6040 }
6041 
6043 inline civector operator-(const cvector& v1, const sivector_slice& v2) {
6044  return fsl_vv_sub<cvector,sivector_slice,civector>(v1,v2);
6045 }
6046 
6048 inline civector operator-(const ivector& v1, const scvector_slice& v2) {
6049  return fsl_vv_sub<ivector,scvector_slice,civector>(v1,v2);
6050 }
6051 
6053 inline civector operator-(const scivector_slice& v1, const rvector& v2) {
6054  return slf_vv_sub<scivector_slice,rvector,civector>(v1,v2);
6055 }
6056 
6058 inline civector operator-(const scivector_slice& v1, const cvector& v2) {
6059  return slf_vv_sub<scivector_slice,cvector,civector>(v1,v2);
6060 }
6061 
6063 inline civector operator-(const scivector_slice& v1, const ivector& v2) {
6064  return slf_vv_sub<scivector_slice,ivector,civector>(v1,v2);
6065 }
6066 
6068 inline civector operator-(const scivector_slice& v1, const civector& v2) {
6069  return slf_vv_sub<scivector_slice,civector,civector>(v1,v2);
6070 }
6071 
6073 inline civector operator-(const srvector_slice& v1, const civector& v2) {
6074  return slf_vv_sub<srvector_slice,civector,civector>(v1,v2);
6075 }
6076 
6078 inline civector operator-(const scvector_slice& v1, const civector& v2) {
6079  return slf_vv_sub<scvector_slice,civector,civector>(v1,v2);
6080 }
6081 
6083 inline civector operator-(const sivector_slice& v1, const civector& v2) {
6084  return slf_vv_sub<sivector_slice,civector,civector>(v1,v2);
6085 }
6086 
6088 inline civector operator-(const scvector_slice& v1, const ivector& v2) {
6089  return slf_vv_sub<scvector_slice,ivector,civector>(v1,v2);
6090 }
6091 
6093 inline civector operator-(const sivector_slice& v1, const cvector& v2) {
6094  return slf_vv_sub<sivector_slice,cvector,civector>(v1,v2);
6095 }
6096 
6098 inline civector operator-(const civector_slice& v1, const srvector_slice& v2) {
6099  return fsl_vv_sub<civector_slice,srvector_slice,civector>(v1,v2);
6100 }
6101 
6103 inline civector operator-(const civector_slice& v1, const scvector_slice& v2) {
6104  return fsl_vv_sub<civector_slice,scvector_slice,civector>(v1,v2);
6105 }
6106 
6108 inline civector operator-(const civector_slice& v1, const sivector_slice& v2) {
6109  return fsl_vv_sub<civector_slice,sivector_slice,civector>(v1,v2);
6110 }
6111 
6113 inline civector operator-(const civector_slice& v1, const scivector_slice& v2) {
6114  return fsl_vv_sub<civector_slice,scivector_slice,civector>(v1,v2);
6115 }
6116 
6118 inline civector operator-(const rvector_slice& v1, const scivector_slice& v2) {
6119  return fsl_vv_sub<rvector_slice,scivector_slice,civector>(v1,v2);
6120 }
6121 
6123 inline civector operator-(const cvector_slice& v1, const scivector_slice& v2) {
6124  return fsl_vv_sub<cvector_slice,scivector_slice,civector>(v1,v2);
6125 }
6126 
6128 inline civector operator-(const ivector_slice& v1, const scivector_slice& v2) {
6129  return fsl_vv_sub<ivector_slice,scivector_slice,civector>(v1,v2);
6130 }
6131 
6133 inline civector operator-(const ivector_slice& v1, const scvector_slice& v2) {
6134  return fsl_vv_sub<ivector_slice,scvector_slice,civector>(v1,v2);
6135 }
6136 
6138 inline civector operator-(const cvector_slice& v1, const sivector_slice& v2) {
6139  return fsl_vv_sub<cvector_slice,sivector_slice,civector>(v1,v2);
6140 }
6141 
6143 inline civector operator-(const scivector_slice& v1, const rvector_slice& v2) {
6144  return slf_vv_sub<scivector_slice,rvector_slice,civector>(v1,v2);
6145 }
6146 
6148 inline civector operator-(const scivector_slice& v1, const ivector_slice& v2) {
6149  return slf_vv_sub<scivector_slice,ivector_slice,civector>(v1,v2);
6150 }
6151 
6153 inline civector operator-(const scivector_slice& v1, const cvector_slice& v2) {
6154  return slf_vv_sub<scivector_slice,cvector_slice,civector>(v1,v2);
6155 }
6156 
6158 inline civector operator-(const scivector_slice& v1, const civector_slice& v2) {
6159  return slf_vv_sub<scivector_slice,civector_slice,civector>(v1,v2);
6160 }
6161 
6163 inline civector operator-(const srvector_slice& v1, const civector_slice& v2) {
6164  return slf_vv_sub<srvector_slice,civector_slice,civector>(v1,v2);
6165 }
6166 
6168 inline civector operator-(const sivector_slice& v1, const civector_slice& v2) {
6169  return slf_vv_sub<sivector_slice,civector_slice,civector>(v1,v2);
6170 }
6171 
6173 inline civector operator-(const scvector_slice& v1, const civector_slice& v2) {
6174  return slf_vv_sub<scvector_slice,civector_slice,civector>(v1,v2);
6175 }
6176 
6178 inline civector operator-(const scvector_slice& v1, const ivector_slice& v2) {
6179  return slf_vv_sub<scvector_slice,ivector_slice,civector>(v1,v2);
6180 }
6181 
6183 inline civector operator-(const sivector_slice& v1, const cvector_slice& v2) {
6184  return slf_vv_sub<sivector_slice,cvector_slice,civector>(v1,v2);
6185 }
6186 
6188 inline 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 
6193 inline 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 
6198 inline 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 
6203 inline 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 
6208 inline 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 
6213 inline 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 
6218 inline 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 
6223 inline 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 
6228 inline 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 
6233 inline scivector operator-(const scivector& v1, const srvector_slice& v2) {
6234  return spsl_vv_sub<scivector,srvector_slice,scivector,cinterval>(v1,v2);
6235 }
6236 
6238 inline scivector operator-(const scivector& v1, const scvector_slice& v2) {
6239  return spsl_vv_sub<scivector,scvector_slice,scivector,cinterval>(v1,v2);
6240 }
6241 
6243 inline scivector operator-(const scivector& v1, const sivector_slice& v2) {
6244  return spsl_vv_sub<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6245 }
6246 
6248 inline scivector operator-(const scivector& v1, const scivector_slice& v2) {
6249  return spsl_vv_sub<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6250 }
6251 
6253 inline scivector operator-(const srvector& v1, const scivector_slice& v2) {
6254  return spsl_vv_sub<srvector,scivector_slice,scivector,cinterval>(v1,v2);
6255 }
6256 
6258 inline scivector operator-(const scvector& v1, const scivector_slice& v2) {
6259  return spsl_vv_sub<scvector,scivector_slice,scivector,cinterval>(v1,v2);
6260 }
6261 
6263 inline scivector operator-(const sivector& v1, const scivector_slice& v2) {
6264  return spsl_vv_sub<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6265 }
6266 
6268 inline scivector operator-(const scvector& v1, const sivector_slice& v2) {
6269  return spsl_vv_sub<scvector,sivector_slice,scivector,cinterval>(v1,v2);
6270 }
6271 
6273 inline scivector operator-(const sivector& v1, const scvector_slice& v2) {
6274  return spsl_vv_sub<sivector,scvector_slice,scivector,cinterval>(v1,v2);
6275 }
6276 
6278 inline scivector operator-(const scivector_slice& v1, const srvector& v2) {
6279  return slsp_vv_sub<scivector_slice,srvector,scivector,cinterval>(v1,v2);
6280 }
6281 
6283 inline scivector operator-(const scivector_slice& v1, const scvector& v2) {
6284  return slsp_vv_sub<scivector_slice,scvector,scivector,cinterval>(v1,v2);
6285 }
6286 
6288 inline scivector operator-(const scivector_slice& v1, const sivector& v2) {
6289  return slsp_vv_sub<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6290 }
6291 
6293 inline scivector operator-(const scivector_slice& v1, const scivector& v2) {
6294  return slsp_vv_sub<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6295 }
6296 
6298 inline scivector operator-(const srvector_slice& v1, const scivector& v2) {
6299  return slsp_vv_sub<srvector_slice,scivector,scivector,cinterval>(v1,v2);
6300 }
6301 
6303 inline scivector operator-(const scvector_slice& v1, const scivector& v2) {
6304  return slsp_vv_sub<scvector_slice,scivector,scivector,cinterval>(v1,v2);
6305 }
6306 
6308 inline scivector operator-(const sivector_slice& v1, const scivector& v2) {
6309  return slsp_vv_sub<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6310 }
6311 
6313 inline scivector operator-(const scvector_slice& v1, const sivector& v2) {
6314  return slsp_vv_sub<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6315 }
6316 
6318 inline scivector operator-(const sivector_slice& v1, const scvector& v2) {
6319  return slsp_vv_sub<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6320 }
6321 
6323 inline civector operator|(const civector& v1, const srvector_slice& v2) {
6324  return fsl_vv_hull<civector,srvector_slice,civector>(v1,v2);
6325 }
6326 
6328 inline civector operator|(const civector& v1, const scvector_slice& v2) {
6329  return fsl_vv_hull<civector,scvector_slice,civector>(v1,v2);
6330 }
6331 
6333 inline civector operator|(const civector& v1, const sivector_slice& v2) {
6334  return fsl_vv_hull<civector,sivector_slice,civector>(v1,v2);
6335 }
6336 
6338 inline civector operator|(const civector& v1, const scivector_slice& v2) {
6339  return fsl_vv_hull<civector,scivector_slice,civector>(v1,v2);
6340 }
6341 
6343 inline civector operator|(const rvector& v1, const scivector_slice& v2) {
6344  return fsl_vv_hull<rvector,scivector_slice,civector>(v1,v2);
6345 }
6346 
6348 inline civector operator|(const cvector& v1, const scivector_slice& v2) {
6349  return fsl_vv_hull<cvector,scivector_slice,civector>(v1,v2);
6350 }
6351 
6353 inline civector operator|(const ivector& v1, const scivector_slice& v2) {
6354  return fsl_vv_hull<ivector,scivector_slice,civector>(v1,v2);
6355 }
6356 
6358 inline civector operator|(const cvector& v1, const sivector_slice& v2) {
6359  return fsl_vv_hull<cvector,sivector_slice,civector>(v1,v2);
6360 }
6361 
6363 inline civector operator|(const ivector& v1, const scvector_slice& v2) {
6364  return fsl_vv_hull<ivector,scvector_slice,civector>(v1,v2);
6365 }
6366 
6368 inline civector operator|(const scivector_slice& v1, const rvector& v2) {
6369  return slf_vv_hull<scivector_slice,rvector,civector>(v1,v2);
6370 }
6371 
6373 inline civector operator|(const scivector_slice& v1, const cvector& v2) {
6374  return slf_vv_hull<scivector_slice,cvector,civector>(v1,v2);
6375 }
6376 
6378 inline civector operator|(const scivector_slice& v1, const ivector& v2) {
6379  return slf_vv_hull<scivector_slice,ivector,civector>(v1,v2);
6380 }
6381 
6383 inline civector operator|(const scivector_slice& v1, const civector& v2) {
6384  return slf_vv_hull<scivector_slice,civector,civector>(v1,v2);
6385 }
6386 
6388 inline civector operator|(const srvector_slice& v1, const civector& v2) {
6389  return slf_vv_hull<srvector_slice,civector,civector>(v1,v2);
6390 }
6391 
6393 inline civector operator|(const scvector_slice& v1, const civector& v2) {
6394  return slf_vv_hull<scvector_slice,civector,civector>(v1,v2);
6395 }
6396 
6398 inline civector operator|(const sivector_slice& v1, const civector& v2) {
6399  return slf_vv_hull<sivector_slice,civector,civector>(v1,v2);
6400 }
6401 
6403 inline civector operator|(const scvector_slice& v1, const ivector& v2) {
6404  return slf_vv_hull<scvector_slice,ivector,civector>(v1,v2);
6405 }
6406 
6408 inline civector operator|(const sivector_slice& v1, const cvector& v2) {
6409  return slf_vv_hull<sivector_slice,cvector,civector>(v1,v2);
6410 }
6411 
6413 inline civector operator|(const civector_slice& v1, const srvector_slice& v2) {
6414  return fsl_vv_hull<civector_slice,srvector_slice,civector>(v1,v2);
6415 }
6416 
6418 inline civector operator|(const civector_slice& v1, const scvector_slice& v2) {
6419  return fsl_vv_hull<civector_slice,scvector_slice,civector>(v1,v2);
6420 }
6421 
6423 inline civector operator|(const civector_slice& v1, const sivector_slice& v2) {
6424  return fsl_vv_hull<civector_slice,sivector_slice,civector>(v1,v2);
6425 }
6426 
6428 inline civector operator|(const civector_slice& v1, const scivector_slice& v2) {
6429  return fsl_vv_hull<civector_slice,scivector_slice,civector>(v1,v2);
6430 }
6431 
6433 inline civector operator|(const rvector_slice& v1, const scivector_slice& v2) {
6434  return fsl_vv_hull<rvector_slice,scivector_slice,civector>(v1,v2);
6435 }
6436 
6438 inline civector operator|(const cvector_slice& v1, const scivector_slice& v2) {
6439  return fsl_vv_hull<cvector_slice,scivector_slice,civector>(v1,v2);
6440 }
6441 
6443 inline civector operator|(const ivector_slice& v1, const scivector_slice& v2) {
6444  return fsl_vv_hull<ivector_slice,scivector_slice,civector>(v1,v2);
6445 }
6446 
6448 inline civector operator|(const ivector_slice& v1, const scvector_slice& v2) {
6449  return fsl_vv_hull<ivector_slice,scvector_slice,civector>(v1,v2);
6450 }
6451 
6453 inline civector operator|(const cvector_slice& v1, const sivector_slice& v2) {
6454  return fsl_vv_hull<cvector_slice,sivector_slice,civector>(v1,v2);
6455 }
6456 
6458 inline civector operator|(const scivector_slice& v1, const rvector_slice& v2) {
6459  return slf_vv_hull<scivector_slice,rvector_slice,civector>(v1,v2);
6460 }
6461 
6463 inline civector operator|(const scivector_slice& v1, const ivector_slice& v2) {
6464  return slf_vv_hull<scivector_slice,ivector_slice,civector>(v1,v2);
6465 }
6466 
6468 inline civector operator|(const scivector_slice& v1, const cvector_slice& v2) {
6469  return slf_vv_hull<scivector_slice,cvector_slice,civector>(v1,v2);
6470 }
6471 
6473 inline civector operator|(const scivector_slice& v1, const civector_slice& v2) {
6474  return slf_vv_hull<scivector_slice,civector_slice,civector>(v1,v2);
6475 }
6476 
6478 inline civector operator|(const srvector_slice& v1, const civector_slice& v2) {
6479  return slf_vv_hull<srvector_slice,civector_slice,civector>(v1,v2);
6480 }
6481 
6483 inline civector operator|(const sivector_slice& v1, const civector_slice& v2) {
6484  return slf_vv_hull<sivector_slice,civector_slice,civector>(v1,v2);
6485 }
6486 
6488 inline civector operator|(const scvector_slice& v1, const civector_slice& v2) {
6489  return slf_vv_hull<scvector_slice,civector_slice,civector>(v1,v2);
6490 }
6491 
6493 inline civector operator|(const scvector_slice& v1, const ivector_slice& v2) {
6494  return slf_vv_hull<scvector_slice,ivector_slice,civector>(v1,v2);
6495 }
6496 
6498 inline civector operator|(const sivector_slice& v1, const cvector_slice& v2) {
6499  return slf_vv_hull<sivector_slice,cvector_slice,civector>(v1,v2);
6500 }
6501 
6503 inline 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 
6508 inline 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 
6513 inline 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 
6518 inline 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 
6523 inline 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 
6528 inline 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 
6533 inline 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 
6538 inline 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 
6543 inline 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 
6548 inline scivector operator|(const scivector& v1, const srvector_slice& v2) {
6549  return spsl_vv_hull<scivector,srvector_slice,scivector,cinterval>(v1,v2);
6550 }
6551 
6553 inline scivector operator|(const scivector& v1, const scvector_slice& v2) {
6554  return spsl_vv_hull<scivector,scvector_slice,scivector,cinterval>(v1,v2);
6555 }
6556 
6558 inline scivector operator|(const scivector& v1, const sivector_slice& v2) {
6559  return spsl_vv_hull<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6560 }
6561 
6563 inline scivector operator|(const scivector& v1, const scivector_slice& v2) {
6564  return spsl_vv_hull<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6565 }
6566 
6568 inline scivector operator|(const srvector& v1, const scivector_slice& v2) {
6569  return spsl_vv_hull<srvector,scivector_slice,scivector,cinterval>(v1,v2);
6570 }
6571 
6573 inline scivector operator|(const scvector& v1, const scivector_slice& v2) {
6574  return spsl_vv_hull<scvector,scivector_slice,scivector,cinterval>(v1,v2);
6575 }
6576 
6578 inline scivector operator|(const sivector& v1, const scivector_slice& v2) {
6579  return spsl_vv_hull<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6580 }
6581 
6583 inline scivector operator|(const scvector& v1, const sivector_slice& v2) {
6584  return spsl_vv_hull<scvector,sivector_slice,scivector,cinterval>(v1,v2);
6585 }
6586 
6588 inline scivector operator|(const sivector& v1, const scvector_slice& v2) {
6589  return spsl_vv_hull<sivector,scvector_slice,scivector,cinterval>(v1,v2);
6590 }
6591 
6593 inline scivector operator|(const scivector_slice& v1, const srvector& v2) {
6594  return slsp_vv_hull<scivector_slice,srvector,scivector,cinterval>(v1,v2);
6595 }
6596 
6598 inline scivector operator|(const scivector_slice& v1, const scvector& v2) {
6599  return slsp_vv_hull<scivector_slice,scvector,scivector,cinterval>(v1,v2);
6600 }
6601 
6603 inline scivector operator|(const scivector_slice& v1, const sivector& v2) {
6604  return slsp_vv_hull<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6605 }
6606 
6608 inline scivector operator|(const scivector_slice& v1, const scivector& v2) {
6609  return slsp_vv_hull<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6610 }
6611 
6613 inline scivector operator|(const srvector_slice& v1, const scivector& v2) {
6614  return slsp_vv_hull<srvector_slice,scivector,scivector,cinterval>(v1,v2);
6615 }
6616 
6618 inline scivector operator|(const scvector_slice& v1, const scivector& v2) {
6619  return slsp_vv_hull<scvector_slice,scivector,scivector,cinterval>(v1,v2);
6620 }
6621 
6623 inline scivector operator|(const sivector_slice& v1, const scivector& v2) {
6624  return slsp_vv_hull<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6625 }
6626 
6628 inline scivector operator|(const scvector_slice& v1, const sivector& v2) {
6629  return slsp_vv_hull<scvector_slice,sivector,scivector,cinterval>(v1,v2);
6630 }
6631 
6633 inline scivector operator|(const sivector_slice& v1, const scvector& v2) {
6634  return slsp_vv_hull<sivector_slice,scvector,scivector,cinterval>(v1,v2);
6635 }
6636 
6638 inline civector operator&(const civector& v1, const sivector_slice& v2) {
6639  return fsl_vv_intersect<civector,sivector_slice,civector>(v1,v2);
6640 }
6641 
6643 inline civector operator&(const civector& v1, const scivector_slice& v2) {
6644  return fsl_vv_intersect<civector,scivector_slice,civector>(v1,v2);
6645 }
6646 
6648 inline civector operator&(const ivector& v1, const scivector_slice& v2) {
6649  return fsl_vv_intersect<ivector,scivector_slice,civector>(v1,v2);
6650 }
6651 
6653 inline civector operator&(const scivector_slice& v1, const ivector& v2) {
6654  return slf_vv_intersect<scivector_slice,ivector,civector>(v1,v2);
6655 }
6656 
6658 inline civector operator&(const scivector_slice& v1, const civector& v2) {
6659  return slf_vv_intersect<scivector_slice,civector,civector>(v1,v2);
6660 }
6661 
6663 inline civector operator&(const sivector_slice& v1, const civector& v2) {
6664  return slf_vv_intersect<sivector_slice,civector,civector>(v1,v2);
6665 }
6666 
6668 inline civector operator&(const civector_slice& v1, const sivector_slice& v2) {
6669  return fsl_vv_intersect<civector_slice,sivector_slice,civector>(v1,v2);
6670 }
6671 
6673 inline civector operator&(const civector_slice& v1, const scivector_slice& v2) {
6674  return fsl_vv_intersect<civector_slice,scivector_slice,civector>(v1,v2);
6675 }
6676 
6678 inline civector operator&(const ivector_slice& v1, const scivector_slice& v2) {
6679  return fsl_vv_intersect<ivector_slice,scivector_slice,civector>(v1,v2);
6680 }
6681 
6683 inline civector operator&(const scivector_slice& v1, const ivector_slice& v2) {
6684  return slf_vv_intersect<scivector_slice,ivector_slice,civector>(v1,v2);
6685 }
6686 
6688 inline civector operator&(const scivector_slice& v1, const civector_slice& v2) {
6689  return slf_vv_intersect<scivector_slice,civector_slice,civector>(v1,v2);
6690 }
6691 
6693 inline civector operator&(const sivector_slice& v1, const civector_slice& v2) {
6694  return slf_vv_intersect<sivector_slice,civector_slice,civector>(v1,v2);
6695 }
6696 
6698 inline 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 
6703 inline 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 
6708 inline 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 
6713 inline scivector operator&(const scivector& v1, const sivector_slice& v2) {
6714  return spsl_vv_intersect<scivector,sivector_slice,scivector,cinterval>(v1,v2);
6715 }
6716 
6718 inline scivector operator&(const scivector& v1, const scivector_slice& v2) {
6719  return spsl_vv_intersect<scivector,scivector_slice,scivector,cinterval>(v1,v2);
6720 }
6721 
6723 inline scivector operator&(const sivector& v1, const scivector_slice& v2) {
6724  return spsl_vv_intersect<sivector,scivector_slice,scivector,cinterval>(v1,v2);
6725 }
6726 
6728 inline scivector operator&(const scivector_slice& v1, const sivector& v2) {
6729  return slsp_vv_intersect<scivector_slice,sivector,scivector,cinterval>(v1,v2);
6730 }
6731 
6733 inline scivector operator&(const scivector_slice& v1, const scivector& v2) {
6734  return slsp_vv_intersect<scivector_slice,scivector,scivector,cinterval>(v1,v2);
6735 }
6736 
6738 inline scivector operator&(const sivector_slice& v1, const scivector& v2) {
6739  return slsp_vv_intersect<sivector_slice,scivector,scivector,cinterval>(v1,v2);
6740 }
6741 
6742 inline civector& civector::operator+=(const srvector_slice& v2) {
6743  return fsl_vv_addassign(*this,v2);
6744 }
6745 
6746 inline civector& civector::operator+=(const scvector_slice& v2) {
6747  return fsl_vv_addassign(*this,v2);
6748 }
6749 
6750 inline civector& civector::operator+=(const sivector_slice& v2) {
6751  return fsl_vv_addassign(*this,v2);
6752 }
6753 
6754 inline civector& civector::operator+=(const scivector_slice& v2) {
6755  return fsl_vv_addassign(*this,v2);
6756 }
6757 
6758 inline civector_slice& civector_slice::operator+=(const srvector_slice& v2) {
6759  return fsl_vv_addassign(*this,v2);
6760 }
6761 
6762 inline civector_slice& civector_slice::operator+=(const scvector_slice& v2) {
6763  return fsl_vv_addassign(*this,v2);
6764 }
6765 
6766 inline civector_slice& civector_slice::operator+=(const sivector_slice& v2) {
6767  return fsl_vv_addassign(*this,v2);
6768 }
6769 
6770 inline 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 
6790 inline civector& civector::operator-=(const srvector_slice& v2) {
6791  return fsl_vv_subassign(*this,v2);
6792 }
6793 
6794 inline civector& civector::operator-=(const scvector_slice& v2) {
6795  return fsl_vv_subassign(*this,v2);
6796 }
6797 
6798 inline civector& civector::operator-=(const sivector_slice& v2) {
6799  return fsl_vv_subassign(*this,v2);
6800 }
6801 
6802 inline civector& civector::operator-=(const scivector_slice& v2) {
6803  return fsl_vv_subassign(*this,v2);
6804 }
6805 
6806 inline civector_slice& civector_slice::operator-=(const srvector_slice& v2) {
6807  return fsl_vv_subassign(*this,v2);
6808 }
6809 
6810 inline civector_slice& civector_slice::operator-=(const scvector_slice& v2) {
6811  return fsl_vv_subassign(*this,v2);
6812 }
6813 
6814 inline civector_slice& civector_slice::operator-=(const sivector_slice& v2) {
6815  return fsl_vv_subassign(*this,v2);
6816 }
6817 
6818 inline 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 
6838 inline civector& civector::operator|=(const srvector_slice& v2) {
6839  return fsl_vv_hullassign(*this,v2);
6840 }
6841 
6842 inline civector& civector::operator|=(const scvector_slice& v2) {
6843  return fsl_vv_hullassign(*this,v2);
6844 }
6845 
6846 inline civector& civector::operator|=(const sivector_slice& v2) {
6847  return fsl_vv_hullassign(*this,v2);
6848 }
6849 
6850 inline civector& civector::operator|=(const scivector_slice& v2) {
6851  return fsl_vv_hullassign(*this,v2);
6852 }
6853 
6854 inline civector_slice& civector_slice::operator|=(const srvector_slice& v2) {
6855  return fsl_vv_hullassign(*this,v2);
6856 }
6857 
6858 inline civector_slice& civector_slice::operator|=(const scvector_slice& v2) {
6859  return fsl_vv_hullassign(*this,v2);
6860 }
6861 
6862 inline civector_slice& civector_slice::operator|=(const sivector_slice& v2) {
6863  return fsl_vv_hullassign(*this,v2);
6864 }
6865 
6866 inline 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 
6886 inline civector& civector::operator&=(const sivector_slice& v2) {
6887  return fsl_vv_intersectassign(*this,v2);
6888 }
6889 
6890 inline civector& civector::operator&=(const scivector_slice& v2) {
6891  return fsl_vv_intersectassign(*this,v2);
6892 }
6893 
6894 inline civector_slice& civector_slice::operator&=(const sivector_slice& v2) {
6895  return fsl_vv_intersectassign(*this,v2);
6896 }
6897 
6898 inline 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 
6914 inline bool operator==(const scivector_slice& v1, const srvector_slice& v2) {
6915  return slsl_vv_comp(v1,v2);
6916 }
6917 
6919 
6922 inline bool operator==(const scivector_slice& v1, const scvector_slice& v2) {
6923  return slsl_vv_comp(v1,v2);
6924 }
6925 
6927 
6930 inline bool operator==(const scivector_slice& v1, const sivector_slice& v2) {
6931  return slsl_vv_comp(v1,v2);
6932 }
6933 
6935 
6938 inline bool operator==(const scivector_slice& v1, const scivector_slice& v2) {
6939  return slsl_vv_comp(v1,v2);
6940 }
6941 
6943 
6946 inline bool operator==(const srvector_slice& v1, const scivector_slice& v2) {
6947  return slsl_vv_comp(v1,v2);
6948 }
6949 
6951 
6954 inline bool operator==(const scvector_slice& v1, const scivector_slice& v2) {
6955  return slsl_vv_comp(v1,v2);
6956 }
6957 
6959 
6962 inline bool operator==(const sivector_slice& v1, const scivector_slice& v2) {
6963  return slsl_vv_comp(v1,v2);
6964 }
6965 
6967 
6970 inline bool operator==(const scivector_slice& v1, const srvector& v2) {
6971  return slsp_vv_comp(v1,v2);
6972 }
6973 
6975 
6978 inline bool operator==(const scivector_slice& v1, const scvector& v2) {
6979  return slsp_vv_comp(v1,v2);
6980 }
6981 
6983 
6986 inline bool operator==(const scivector_slice& v1, const sivector& v2) {
6987  return slsp_vv_comp(v1,v2);
6988 }
6989 
6991 
6994 inline bool operator==(const scivector_slice& v1, const scivector& v2) {
6995  return slsp_vv_comp(v1,v2);
6996 }
6997 
6999 
7002 inline bool operator==(const srvector_slice& v1, const scivector& v2) {
7003  return slsp_vv_comp(v1,v2);
7004 }
7005 
7007 
7010 inline bool operator==(const scvector_slice& v1, const scivector& v2) {
7011  return slsp_vv_comp(v1,v2);
7012 }
7013 
7015 
7018 inline bool operator==(const sivector_slice& v1, const scivector& v2) {
7019  return slsp_vv_comp(v1,v2);
7020 }
7021 
7023 
7026 inline bool operator==(const scivector& v1, const srvector_slice& v2) {
7027  return spsl_vv_comp(v1,v2);
7028 }
7029 
7031 
7034 inline bool operator==(const scivector& v1, const scvector_slice& v2) {
7035  return spsl_vv_comp(v1,v2);
7036 }
7037 
7039 
7042 inline bool operator==(const scivector& v1, const sivector_slice& v2) {
7043  return spsl_vv_comp(v1,v2);
7044 }
7045 
7047 
7050 inline bool operator==(const scivector& v1, const scivector_slice& v2) {
7051  return spsl_vv_comp(v1,v2);
7052 }
7053 
7055 
7058 inline bool operator==(const srvector& v1, const scivector_slice& v2) {
7059  return spsl_vv_comp(v1,v2);
7060 }
7061 
7063 
7066 inline bool operator==(const scvector& v1, const scivector_slice& v2) {
7067  return spsl_vv_comp(v1,v2);
7068 }
7069 
7071 
7074 inline bool operator==(const sivector& v1, const scivector_slice& v2) {
7075  return spsl_vv_comp(v1,v2);
7076 }
7077 
7079 
7082 inline bool operator==(const scivector_slice& v1, const rvector& v2) {
7083  return slf_vv_comp(v1,v2);
7084 }
7085 
7087 
7090 inline bool operator==(const scivector_slice& v1, const cvector& v2) {
7091  return slf_vv_comp(v1,v2);
7092 }
7093 
7095 
7098 inline bool operator==(const scivector_slice& v1, const ivector& v2) {
7099  return slf_vv_comp(v1,v2);
7100 }
7101 
7103 
7106 inline bool operator==(const scivector_slice& v1, const civector& v2) {
7107  return slf_vv_comp(v1,v2);
7108 }
7109 
7111 
7114 inline bool operator==(const srvector_slice& v1, const civector& v2) {
7115  return slf_vv_comp(v1,v2);
7116 }
7117 
7119 
7122 inline bool operator==(const sivector_slice& v1, const civector& v2) {
7123  return slf_vv_comp(v1,v2);
7124 }
7125 
7127 
7130 inline bool operator==(const scvector_slice& v1, const civector& v2) {
7131  return slf_vv_comp(v1,v2);
7132 }
7133 
7135 
7138 inline bool operator==(const civector& v1, const srvector_slice& v2) {
7139  return fsl_vv_comp(v1,v2);
7140 }
7141 
7143 
7146 inline bool operator==(const civector& v1, const scvector_slice& v2) {
7147  return fsl_vv_comp(v1,v2);
7148 }
7149 
7151 
7154 inline bool operator==(const civector& v1, const sivector_slice& v2) {
7155  return fsl_vv_comp(v1,v2);
7156 }
7157 
7159 
7162 inline bool operator==(const civector& v1, const scivector_slice& v2) {
7163  return fsl_vv_comp(v1,v2);
7164 }
7165 
7167 
7170 inline bool operator==(const rvector& v1, const scivector_slice& v2) {
7171  return fsl_vv_comp(v1,v2);
7172 }
7173 
7175 
7178 inline bool operator==(const cvector& v1, const scivector_slice& v2) {
7179  return fsl_vv_comp(v1,v2);
7180 }
7181 
7183 
7186 inline bool operator==(const ivector& v1, const scivector_slice& v2) {
7187  return fsl_vv_comp(v1,v2);
7188 }
7189 
7191 
7194 inline bool operator==(const scivector_slice& v1, const rvector_slice& v2) {
7195  return slf_vv_comp(v1,v2);
7196 }
7197 
7199 
7202 inline bool operator==(const scivector_slice& v1, const ivector_slice& v2) {
7203  return slf_vv_comp(v1,v2);
7204 }
7205 
7207 
7210 inline bool operator==(const scivector_slice& v1, const cvector_slice& v2) {
7211  return slf_vv_comp(v1,v2);
7212 }
7213 
7215 
7218 inline bool operator==(const scivector_slice& v1, const civector_slice& v2) {
7219  return slf_vv_comp(v1,v2);
7220 }
7221 
7223 
7226 inline bool operator==(const srvector_slice& v1, const civector_slice& v2) {
7227  return slf_vv_comp(v1,v2);
7228 }
7229 
7231 
7234 inline bool operator==(const sivector_slice& v1, const civector_slice& v2) {
7235  return slf_vv_comp(v1,v2);
7236 }
7237 
7239 
7242 inline bool operator==(const scvector_slice& v1, const civector_slice& v2) {
7243  return slf_vv_comp(v1,v2);
7244 }
7245 
7247 
7250 inline bool operator==(const civector_slice& v1, const srvector_slice& v2) {
7251  return fsl_vv_comp(v1,v2);
7252 }
7253 
7255 
7258 inline bool operator==(const civector_slice& v1, const scvector_slice& v2) {
7259  return fsl_vv_comp(v1,v2);
7260 }
7261 
7263 
7266 inline bool operator==(const civector_slice& v1, const sivector_slice& v2) {
7267  return fsl_vv_comp(v1,v2);
7268 }
7269 
7271 
7274 inline bool operator==(const civector_slice& v1, const scivector_slice& v2) {
7275  return fsl_vv_comp(v1,v2);
7276 }
7277 
7279 
7282 inline bool operator==(const rvector_slice& v1, const scivector_slice& v2) {
7283  return fsl_vv_comp(v1,v2);
7284 }
7285 
7287 
7290 inline bool operator==(const cvector_slice& v1, const scivector_slice& v2) {
7291  return fsl_vv_comp(v1,v2);
7292 }
7293 
7295 
7298 inline bool operator==(const ivector_slice& v1, const scivector_slice& v2) {
7299  return fsl_vv_comp(v1,v2);
7300 }
7301 
7303 
7306 inline bool operator!=(const scivector_slice& v1, const srvector_slice& v2) {
7307  return !slsl_vv_comp(v1,v2);
7308 }
7309 
7311 
7314 inline bool operator!=(const scivector_slice& v1, const scvector_slice& v2) {
7315  return !slsl_vv_comp(v1,v2);
7316 }
7317 
7319 
7322 inline bool operator!=(const scivector_slice& v1, const sivector_slice& v2) {
7323  return !slsl_vv_comp(v1,v2);
7324 }
7325 
7327 
7330 inline bool operator!=(const scivector_slice& v1, const scivector_slice& v2) {
7331  return !slsl_vv_comp(v1,v2);
7332 }
7333 
7335 
7338 inline bool operator!=(const srvector_slice& v1, const scivector_slice& v2) {
7339  return !slsl_vv_comp(v1,v2);
7340 }
7341 
7343 
7346 inline bool operator!=(const scvector_slice& v1, const scivector_slice& v2) {
7347  return !slsl_vv_comp(v1,v2);
7348 }
7349 
7351 
7354 inline bool operator!=(const sivector_slice& v1, const scivector_slice& v2) {
7355  return !slsl_vv_comp(v1,v2);
7356 }
7357 
7359 
7362 inline bool operator!=(const scivector_slice& v1, const srvector& v2) {
7363  return !slsp_vv_comp(v1,v2);
7364 }
7365 
7367 
7370 inline bool operator!=(const scivector_slice& v1, const scvector& v2) {
7371  return !slsp_vv_comp(v1,v2);
7372 }
7373 
7375 
7378 inline bool operator!=(const scivector_slice& v1, const sivector& v2) {
7379  return !slsp_vv_comp(v1,v2);
7380 }
7381 
7383 
7386 inline bool operator!=(const scivector_slice& v1, const scivector& v2) {
7387  return !slsp_vv_comp(v1,v2);
7388 }
7389 
7391 
7394 inline bool operator!=(const srvector_slice& v1, const scivector& v2) {
7395  return !slsp_vv_comp(v1,v2);
7396 }
7397 
7399 
7402 inline bool operator!=(const scvector_slice& v1, const scivector& v2) {
7403  return !slsp_vv_comp(v1,v2);
7404 }
7405 
7407 
7410 inline bool operator!=(const sivector_slice& v1, const scivector& v2) {
7411  return !slsp_vv_comp(v1,v2);
7412 }
7413 
7415 
7418 inline bool operator!=(const scivector& v1, const srvector_slice& v2) {
7419  return !spsl_vv_comp(v1,v2);
7420 }
7421 
7423 
7426 inline bool operator!=(const scivector& v1, const scvector_slice& v2) {
7427  return !spsl_vv_comp(v1,v2);
7428 }
7429 
7431 
7434 inline bool operator!=(const scivector& v1, const sivector_slice& v2) {
7435  return !spsl_vv_comp(v1,v2);
7436 }
7437 
7439 
7442 inline bool operator!=(const scivector& v1, const scivector_slice& v2) {
7443  return !spsl_vv_comp(v1,v2);
7444 }
7445 
7447 
7450 inline bool operator!=(const srvector& v1, const scivector_slice& v2) {
7451  return !spsl_vv_comp(v1,v2);
7452 }
7453 
7455 
7458 inline bool operator!=(const scvector& v1, const scivector_slice& v2) {
7459  return !spsl_vv_comp(v1,v2);
7460 }
7461 
7463 
7466 inline bool operator!=(const sivector& v1, const scivector_slice& v2) {
7467  return !spsl_vv_comp(v1,v2);
7468 }
7469 
7471 
7474 inline bool operator!=(const scivector_slice& v1, const rvector& v2) {
7475  return !slf_vv_comp(v1,v2);
7476 }
7477 
7479 
7482 inline bool operator!=(const scivector_slice& v1, const cvector& v2) {
7483  return !slf_vv_comp(v1,v2);
7484 }
7485 
7487 
7490 inline bool operator!=(const scivector_slice& v1, const ivector& v2) {
7491  return !slf_vv_comp(v1,v2);
7492 }
7493 
7495 
7498 inline bool operator!=(const scivector_slice& v1, const civector& v2) {
7499  return !slf_vv_comp(v1,v2);
7500 }
7501 
7503 
7506 inline bool operator!=(const srvector_slice& v1, const civector& v2) {
7507  return !slf_vv_comp(v1,v2);
7508 }
7509 
7511 
7514 inline bool operator!=(const sivector_slice& v1, const civector& v2) {
7515  return !slf_vv_comp(v1,v2);
7516 }
7517 
7519 
7522 inline bool operator!=(const scvector_slice& v1, const civector& v2) {
7523  return !slf_vv_comp(v1,v2);
7524 }
7525 
7527 
7530 inline bool operator!=(const civector& v1, const srvector_slice& v2) {
7531  return !fsl_vv_comp(v1,v2);
7532 }
7533 
7535 
7538 inline bool operator!=(const civector& v1, const scvector_slice& v2) {
7539  return !fsl_vv_comp(v1,v2);
7540 }
7541 
7543 
7546 inline bool operator!=(const civector& v1, const sivector_slice& v2) {
7547  return !fsl_vv_comp(v1,v2);
7548 }
7549 
7551 
7554 inline bool operator!=(const civector& v1, const scivector_slice& v2) {
7555  return !fsl_vv_comp(v1,v2);
7556 }
7557 
7559 
7562 inline bool operator!=(const rvector& v1, const scivector_slice& v2) {
7563  return !fsl_vv_comp(v1,v2);
7564 }
7565 
7567 
7570 inline bool operator!=(const cvector& v1, const scivector_slice& v2) {
7571  return !fsl_vv_comp(v1,v2);
7572 }
7573 
7575 
7578 inline bool operator!=(const ivector& v1, const scivector_slice& v2) {
7579  return !fsl_vv_comp(v1,v2);
7580 }
7581 
7583 
7586 inline bool operator!=(const scivector_slice& v1, const rvector_slice& v2) {
7587  return !slf_vv_comp(v1,v2);
7588 }
7589 
7591 
7594 inline bool operator!=(const scivector_slice& v1, const ivector_slice& v2) {
7595  return !slf_vv_comp(v1,v2);
7596 }
7597 
7599 
7602 inline bool operator!=(const scivector_slice& v1, const cvector_slice& v2) {
7603  return !slf_vv_comp(v1,v2);
7604 }
7605 
7607 
7610 inline bool operator!=(const scivector_slice& v1, const civector_slice& v2) {
7611  return !slf_vv_comp(v1,v2);
7612 }
7613 
7615 
7618 inline bool operator!=(const srvector_slice& v1, const civector_slice& v2) {
7619  return !slf_vv_comp(v1,v2);
7620 }
7621 
7623 
7626 inline bool operator!=(const sivector_slice& v1, const civector_slice& v2) {
7627  return !slf_vv_comp(v1,v2);
7628 }
7629 
7631 
7634 inline bool operator!=(const scvector_slice& v1, const civector_slice& v2) {
7635  return !slf_vv_comp(v1,v2);
7636 }
7637 
7639 
7642 inline bool operator!=(const civector_slice& v1, const srvector_slice& v2) {
7643  return !fsl_vv_comp(v1,v2);
7644 }
7645 
7647 
7650 inline bool operator!=(const civector_slice& v1, const scvector_slice& v2) {
7651  return !fsl_vv_comp(v1,v2);
7652 }
7653 
7655 
7658 inline bool operator!=(const civector_slice& v1, const sivector_slice& v2) {
7659  return !fsl_vv_comp(v1,v2);
7660 }
7661 
7663 
7666 inline bool operator!=(const civector_slice& v1, const scivector_slice& v2) {
7667  return !fsl_vv_comp(v1,v2);
7668 }
7669 
7671 
7674 inline bool operator!=(const rvector_slice& v1, const scivector_slice& v2) {
7675  return !fsl_vv_comp(v1,v2);
7676 }
7677 
7679 
7682 inline bool operator!=(const cvector_slice& v1, const scivector_slice& v2) {
7683  return !fsl_vv_comp(v1,v2);
7684 }
7685 
7687 
7690 inline bool operator!=(const ivector_slice& v1, const scivector_slice& v2) {
7691  return !fsl_vv_comp(v1,v2);
7692 }
7693 
7695 
7698 inline 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 
7706 inline 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 
7714 inline 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 
7722 inline 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 
7730 inline 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 
7738 inline bool operator<(const scivector_slice& v1, const sivector& v2) {
7739  return slsp_vv_less<scivector_slice,sivector,cinterval>(v1,v2);
7740 }
7741 
7743 
7746 inline bool operator<(const scivector_slice& v1, const scivector& v2) {
7747  return slsp_vv_less<scivector_slice,scivector,cinterval>(v1,v2);
7748 }
7749 
7751 
7754 inline bool operator<(const srvector_slice& v1, const scivector& v2) {
7755  return slsp_vv_less<srvector_slice,scivector,cinterval>(v1,v2);
7756 }
7757 
7759 
7762 inline bool operator<(const scvector_slice& v1, const scivector& v2) {
7763  return slsp_vv_less<scvector_slice,scivector,cinterval>(v1,v2);
7764 }
7765 
7767 
7770 inline bool operator<(const sivector_slice& v1, const scivector& v2) {
7771  return slsp_vv_less<sivector_slice,scivector,cinterval>(v1,v2);
7772 }
7773 
7775 
7778 inline bool operator<(const scivector& v1, const sivector_slice& v2) {
7779  return spsl_vv_less<scivector,sivector_slice,cinterval>(v1,v2);
7780 }
7781 
7783 
7786 inline bool operator<(const scivector& v1, const scivector_slice& v2) {
7787  return spsl_vv_less<scivector,scivector_slice,cinterval>(v1,v2);
7788 }
7789 
7791 
7794 inline bool operator<(const srvector& v1, const scivector_slice& v2) {
7795  return spsl_vv_less<srvector,scivector_slice,cinterval>(v1,v2);
7796 }
7797 
7799 
7802 inline bool operator<(const scvector& v1, const scivector_slice& v2) {
7803  return spsl_vv_less<scvector,scivector_slice,cinterval>(v1,v2);
7804 }
7805 
7807 
7810 inline bool operator<(const sivector& v1, const scivector_slice& v2) {
7811  return spsl_vv_less<sivector,scivector_slice,cinterval>(v1,v2);
7812 }
7813 
7815 
7818 inline bool operator<(const scivector_slice& v1, const ivector& v2) {
7819  return slf_vv_less<scivector_slice,ivector,cinterval>(v1,v2);
7820 }
7821 
7823 
7826 inline bool operator<(const scivector_slice& v1, const civector& v2) {
7827  return slf_vv_less<scivector_slice,civector,cinterval>(v1,v2);
7828 }
7829 
7831 
7834 inline bool operator<(const srvector_slice& v1, const civector& v2) {
7835  return slf_vv_less<srvector_slice,civector,cinterval>(v1,v2);
7836 }
7837 
7839 
7842 inline bool operator<(const sivector_slice& v1, const civector& v2) {
7843  return slf_vv_less<sivector_slice,civector,cinterval>(v1,v2);
7844 }
7845 
7847 
7850 inline bool operator<(const scvector_slice& v1, const civector& v2) {
7851  return slf_vv_less<scvector_slice,civector,cinterval>(v1,v2);
7852 }
7853 
7855 
7858 inline bool operator<(const civector& v1, const sivector_slice& v2) {
7859  return fsl_vv_less<civector,sivector_slice,cinterval>(v1,v2);
7860 }
7861 
7863 
7866 inline bool operator<(const civector& v1, const scivector_slice& v2) {
7867  return fsl_vv_less<civector,scivector_slice,cinterval>(v1,v2);
7868 }
7869 
7871 
7874 inline bool operator<(const rvector& v1, const scivector_slice& v2) {
7875  return fsl_vv_less<rvector,scivector_slice,cinterval>(v1,v2);
7876 }
7877 
7879 
7882 inline bool operator<(const cvector& v1, const scivector_slice& v2) {
7883  return fsl_vv_less<cvector,scivector_slice,cinterval>(v1,v2);
7884 }
7885 
7887 
7890 inline bool operator<(const ivector& v1, const scivector_slice& v2) {
7891  return fsl_vv_less<ivector,scivector_slice,cinterval>(v1,v2);
7892 }
7893 
7895 
7898 inline 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 
7906 inline 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 
7914 inline 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 
7922 inline 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 
7930 inline 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 
7938 inline bool operator<=(const scivector_slice& v1, const sivector& v2) {
7939  return slsp_vv_leq<scivector_slice,sivector,cinterval>(v1,v2);
7940 }
7941 
7943 
7946 inline bool operator<=(const scivector_slice& v1, const scivector& v2) {
7947  return slsp_vv_leq<scivector_slice,scivector,cinterval>(v1,v2);
7948 }
7949 
7951 
7954 inline bool operator<=(const srvector_slice& v1, const scivector& v2) {
7955  return slsp_vv_leq<srvector_slice,scivector,cinterval>(v1,v2);
7956 }
7957 
7959 
7962 inline bool operator<=(const scvector_slice& v1, const scivector& v2) {
7963  return slsp_vv_leq<scvector_slice,scivector,cinterval>(v1,v2);
7964 }
7965 
7967 
7970 inline bool operator<=(const sivector_slice& v1, const scivector& v2) {
7971  return slsp_vv_leq<sivector_slice,scivector,cinterval>(v1,v2);
7972 }
7973 
7975 
7978 inline bool operator<=(const scivector& v1, const sivector_slice& v2) {
7979  return spsl_vv_leq<scivector,sivector_slice,cinterval>(v1,v2);
7980 }
7981 
7983 
7986 inline bool operator<=(const scivector& v1, const scivector_slice& v2) {
7987  return spsl_vv_leq<scivector,scivector_slice,cinterval>(v1,v2);
7988 }
7989 
7991 
7994 inline bool operator<=(const srvector& v1, const scivector_slice& v2) {
7995  return spsl_vv_leq<srvector,scivector_slice,cinterval>(v1,v2);
7996 }
7997 
7999 
8002 inline bool operator<=(const scvector& v1, const scivector_slice& v2) {
8003  return spsl_vv_leq<scvector,scivector_slice,cinterval>(v1,v2);
8004 }
8005 
8007 
8010 inline bool operator<=(const sivector& v1, const scivector_slice& v2) {
8011  return spsl_vv_leq<sivector,scivector_slice,cinterval>(v1,v2);
8012 }
8013 
8015 
8018 inline bool operator<=(const scivector_slice& v1, const ivector& v2) {
8019  return slf_vv_leq<scivector_slice,ivector,cinterval>(v1,v2);
8020 }
8021 
8023 
8026 inline bool operator<=(const scivector_slice& v1, const civector& v2) {
8027  return slf_vv_leq<scivector_slice,civector,cinterval>(v1,v2);
8028 }
8029 
8031 
8034 inline bool operator<=(const srvector_slice& v1, const civector& v2) {
8035  return slf_vv_leq<srvector_slice,civector,cinterval>(v1,v2);
8036 }
8037 
8039 
8042 inline bool operator<=(const sivector_slice& v1, const civector& v2) {
8043  return slf_vv_leq<sivector_slice,civector,cinterval>(v1,v2);
8044 }
8045 
8047 
8050 inline bool operator<=(const scvector_slice& v1, const civector& v2) {
8051  return slf_vv_leq<scvector_slice,civector,cinterval>(v1,v2);
8052 }
8053 
8055 
8058 inline bool operator<=(const civector& v1, const sivector_slice& v2) {
8059  return fsl_vv_leq<civector,sivector_slice,cinterval>(v1,v2);
8060 }
8061 
8063 
8066 inline bool operator<=(const civector& v1, const scivector_slice& v2) {
8067  return fsl_vv_leq<civector,scivector_slice,cinterval>(v1,v2);
8068 }
8069 
8071 
8074 inline bool operator<=(const rvector& v1, const scivector_slice& v2) {
8075  return fsl_vv_leq<rvector,scivector_slice,cinterval>(v1,v2);
8076 }
8077 
8079 
8082 inline bool operator<=(const cvector& v1, const scivector_slice& v2) {
8083  return fsl_vv_leq<cvector,scivector_slice,cinterval>(v1,v2);
8084 }
8085 
8087 
8090 inline bool operator<=(const ivector& v1, const scivector_slice& v2) {
8091  return fsl_vv_leq<ivector,scivector_slice,cinterval>(v1,v2);
8092 }
8093 
8095 
8098 inline 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 
8106 inline 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 
8114 inline 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 
8122 inline 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 
8130 inline 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 
8138 inline bool operator>(const scivector_slice& v1, const srvector& v2) {
8139  return slsp_vv_greater<scivector_slice,srvector,cinterval>(v1,v2);
8140 }
8141 
8143 
8146 inline bool operator>(const scivector_slice& v1, const scvector& v2) {
8147  return slsp_vv_greater<scivector_slice,scvector,cinterval>(v1,v2);
8148 }
8149 
8151 
8154 inline bool operator>(const scivector_slice& v1, const sivector& v2) {
8155  return slsp_vv_greater<scivector_slice,sivector,cinterval>(v1,v2);
8156 }
8157 
8159 
8162 inline bool operator>(const scivector_slice& v1, const scivector& v2) {
8163  return slsp_vv_greater<scivector_slice,scivector,cinterval>(v1,v2);
8164 }
8165 
8167 
8170 inline bool operator>(const sivector_slice& v1, const scivector& v2) {
8171  return slsp_vv_greater<sivector_slice,scivector,cinterval>(v1,v2);
8172 }
8173 
8175 
8178 inline bool operator>(const scivector& v1, const srvector_slice& v2) {
8179  return spsl_vv_greater<scivector,srvector_slice,cinterval>(v1,v2);
8180 }
8181 
8183 
8186 inline bool operator>(const scivector& v1, const scvector_slice& v2) {
8187  return spsl_vv_greater<scivector,scvector_slice,cinterval>(v1,v2);
8188 }
8189 
8191 
8194 inline bool operator>(const scivector& v1, const sivector_slice& v2) {
8195  return spsl_vv_greater<scivector,sivector_slice,cinterval>(v1,v2);
8196 }
8197 
8199 
8202 inline bool operator>(const scivector& v1, const scivector_slice& v2) {
8203  return spsl_vv_greater<scivector,scivector_slice,cinterval>(v1,v2);
8204 }
8205 
8207 
8210 inline bool operator>(const sivector& v1, const scivector_slice& v2) {
8211  return spsl_vv_greater<sivector,scivector_slice,cinterval>(v1,v2);
8212 }
8213 
8215 
8218 inline bool operator>(const scivector_slice& v1, const rvector& v2) {
8219  return slf_vv_greater<scivector_slice,rvector,cinterval>(v1,v2);
8220 }
8221 
8223 
8226 inline bool operator>(const scivector_slice& v1, const cvector& v2) {
8227  return slf_vv_greater<scivector_slice,cvector,cinterval>(v1,v2);
8228 }
8229 
8231 
8234 inline bool operator>(const scivector_slice& v1, const ivector& v2) {
8235  return slf_vv_greater<scivector_slice,ivector,cinterval>(v1,v2);
8236 }
8237 
8239 
8242 inline bool operator>(const scivector_slice& v1, const civector& v2) {
8243  return slf_vv_greater<scivector_slice,civector,cinterval>(v1,v2);
8244 }
8245 
8247 
8250 inline bool operator>(const sivector_slice& v1, const civector& v2) {
8251  return slf_vv_greater<sivector_slice,civector,cinterval>(v1,v2);
8252 }
8253 
8255 
8258 inline bool operator>(const civector& v1, const srvector_slice& v2) {
8259  return fsl_vv_greater<civector,srvector_slice,cinterval>(v1,v2);
8260 }
8261 
8263 
8266 inline bool operator>(const civector& v1, const scvector_slice& v2) {
8267  return fsl_vv_greater<civector,scvector_slice,cinterval>(v1,v2);
8268 }
8269 
8271 
8274 inline bool operator>(const civector& v1, const sivector_slice& v2) {
8275  return fsl_vv_greater<civector,sivector_slice,cinterval>(v1,v2);
8276 }
8277 
8279 
8282 inline bool operator>(const civector& v1, const scivector_slice& v2) {
8283  return fsl_vv_greater<civector,scivector_slice,cinterval>(v1,v2);
8284 }
8285 
8287 
8290 inline bool operator>(const ivector& v1, const scivector_slice& v2) {
8291  return fsl_vv_greater<ivector,scivector_slice,cinterval>(v1,v2);
8292 }
8293 
8295 
8298 inline 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 
8306 inline 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 
8314 inline 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 
8322 inline 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 
8330 inline 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 
8338 inline 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 
8346 inline 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 
8354 inline 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 
8362 inline 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 
8370 inline 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 
8378 inline 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 
8386 inline 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 
8394 inline 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 
8402 inline 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 
8410 inline 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 
8418 inline bool operator>=(const scivector_slice& v1, const srvector& v2) {
8419  return slsp_vv_geq<scivector_slice,srvector,cinterval>(v1,v2);
8420 }
8421 
8423 
8426 inline bool operator>=(const scivector_slice& v1, const scvector& v2) {
8427  return slsp_vv_geq<scivector_slice,scvector,cinterval>(v1,v2);
8428 }
8429 
8431 
8434 inline bool operator>=(const scivector_slice& v1, const sivector& v2) {
8435  return slsp_vv_geq<scivector_slice,sivector,cinterval>(v1,v2);
8436 }
8437 
8439 
8442 inline bool operator>=(const scivector_slice& v1, const scivector& v2) {
8443  return slsp_vv_geq<scivector_slice,scivector,cinterval>(v1,v2);
8444 }
8445 
8447 
8450 inline bool operator>=(const sivector_slice& v1, const scivector& v2) {
8451  return slsp_vv_geq<sivector_slice,scivector,cinterval>(v1,v2);
8452 }
8453 
8455 
8458 inline bool operator>=(const scivector& v1, const srvector_slice& v2) {
8459  return spsl_vv_geq<scivector,srvector_slice,cinterval>(v1,v2);
8460 }
8461 
8463 
8466 inline bool operator>=(const scivector& v1, const scvector_slice& v2) {
8467  return spsl_vv_geq<scivector,scvector_slice,cinterval>(v1,v2);
8468 }
8469 
8471 
8474 inline bool operator>=(const scivector& v1, const sivector_slice& v2) {
8475  return spsl_vv_geq<scivector,sivector_slice,cinterval>(v1,v2);
8476 }
8477 
8479 
8482 inline bool operator>=(const scivector& v1, const scivector_slice& v2) {
8483  return spsl_vv_geq<scivector,scivector_slice,cinterval>(v1,v2);
8484 }
8485 
8487 
8490 inline bool operator>=(const sivector& v1, const scivector_slice& v2) {
8491  return spsl_vv_geq<sivector,scivector_slice,cinterval>(v1,v2);
8492 }
8493 
8495 
8498 inline bool operator>=(const scivector_slice& v1, const rvector& v2) {
8499  return slf_vv_geq<scivector_slice,rvector,cinterval>(v1,v2);
8500 }
8501 
8503 
8506 inline bool operator>=(const scivector_slice& v1, const cvector& v2) {
8507  return slf_vv_geq<scivector_slice,cvector,cinterval>(v1,v2);
8508 }
8509 
8511 
8514 inline bool operator>=(const scivector_slice& v1, const ivector& v2) {
8515  return slf_vv_geq<scivector_slice,ivector,cinterval>(v1,v2);
8516 }
8517 
8519 
8522 inline bool operator>=(const scivector_slice& v1, const civector& v2) {
8523  return slf_vv_geq<scivector_slice,civector,cinterval>(v1,v2);
8524 }
8525 
8527 
8530 inline bool operator>=(const sivector_slice& v1, const civector& v2) {
8531  return slf_vv_geq<sivector_slice,civector,cinterval>(v1,v2);
8532 }
8533 
8535 
8538 inline bool operator>=(const civector& v1, const srvector_slice& v2) {
8539  return fsl_vv_geq<civector,srvector_slice,cinterval>(v1,v2);
8540 }
8541 
8543 
8546 inline bool operator>=(const civector& v1, const scvector_slice& v2) {
8547  return fsl_vv_geq<civector,scvector_slice,cinterval>(v1,v2);
8548 }
8549 
8551 
8554 inline bool operator>=(const civector& v1, const sivector_slice& v2) {
8555  return fsl_vv_geq<civector,sivector_slice,cinterval>(v1,v2);
8556 }
8557 
8559 
8562 inline bool operator>=(const civector& v1, const scivector_slice& v2) {
8563  return fsl_vv_geq<civector,scivector_slice,cinterval>(v1,v2);
8564 }
8565 
8567 
8570 inline bool operator>=(const ivector& v1, const scivector_slice& v2) {
8571  return fsl_vv_geq<ivector,scivector_slice,cinterval>(v1,v2);
8572 }
8573 
8575 
8578 inline 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 
8586 inline 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 
8594 inline 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 
8602 inline 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 
8610 inline 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 
8618 inline 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 
8626 inline 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 
8634 inline 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 
8642 inline 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 
8650 inline 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 
8660 inline std::ostream& operator<<(std::ostream& os, const scivector_slice& v) {
8661  return sl_v_output<scivector_slice,cinterval>(os,v);
8662 }
8663 
8665 
8670 inline std::istream& operator>>(std::istream& is, scivector_slice& v) {
8671  return sl_v_input<scivector_slice,cinterval>(is,v);
8672 }
8673 
8675 
8678 inline 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 
8686 inline 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 
8694 inline 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 
8702 inline 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 
8710 inline 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 
8718 inline 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 
8726 inline 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 
8734 inline 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 
8742 inline 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 
8750 inline 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 
8758 inline 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 
8766 inline 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 
8774 inline 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 
8782 inline 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 
8790 inline 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 
8798 inline 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 
8806 inline 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 
8814 inline 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 
8822 inline 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 
8830 inline 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 
8838 inline 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 
8846 inline 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 
8854 inline 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 
8862 inline 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 
8870 inline 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 
8878 inline 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 
8886 inline 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 
8894 inline 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 
8902 inline 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 
8910 inline 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 
8918 inline 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 
8926 inline 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 
8934 inline 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 
8942 inline 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 
8950 inline 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 
8958 inline 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 
8966 inline 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 
8974 inline 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 
8982 inline 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 
8990 inline 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 
8998 inline 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 
9006 inline 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 
9014 inline 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 
9022 inline 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 
9030 inline 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 
9038 inline 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 
9046 inline 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 
9054 inline 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 
9062 inline 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 
9070 inline 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 
9078 inline 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 
9086 inline 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 
9094 inline 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 
9102 inline 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 
9110 inline 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 
9118 inline 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 
9126 inline 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 
9134 inline 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 
9142 inline 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 
9150 inline 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 
9158 inline 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 
9166 inline 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 
9174 inline 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 
9182 inline 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 
9190 inline 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 
9198 inline 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 
9206 inline 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 
9214 inline 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 
9222 inline 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 
9230 inline 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 
9238 inline 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 
9246 inline 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 
9254 inline 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 
9262 inline 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 
9270 inline 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 
9278 inline 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 
9286 inline 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 
9294 inline 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 
9302 inline 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 
9310 inline 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 
9318 inline 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 
9326 inline 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 
9334 inline 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 
9342 inline 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 
9350 inline 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 
9358 inline 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 
9366 inline 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 
9374 inline 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 
9382 inline 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 
9390 inline 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 
9398 inline 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 
9406 inline 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 
9414 inline 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 
9422 inline 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 
9430 inline 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 
9438 inline 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 
9446 inline 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 
9454 inline 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 
9462 inline 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 
9470 inline 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 
9478 inline 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 
9486 inline 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 
9494 inline 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 
9502 inline 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 
9510 inline 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 
9518 inline 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 
9526 inline 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 
9534 inline void accumulate(cidotprecision& dot, const sivector& v1, const scvector& v2) {
9535  spsp_vv_accu<cidotprecision,sivector,scvector,sparse_cidot>(dot,v1,v2);
9536 }
9537 
9538 } //namespace cxsc
9539 
9540 #include "sparsevector.inl"
9541 
9542 #endif
The Data Type cidotprecision.
Definition: cidot.hpp:58
The Scalar Type cinterval.
Definition: cinterval.hpp:55
The Data Type civector_slice.
Definition: civector.hpp:1015
civector_slice & operator|=(const civector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: civector.inl:994
civector_slice & operator&=(const civector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: civector.inl:1051
civector_slice & operator+=(const civector &rv) noexcept
Implementation of addition and allocation operation.
Definition: civector.inl:878
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
civector_slice & operator-=(const civector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: civector.inl:937
The Data Type civector.
Definition: civector.hpp:57
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
Definition: civector.inl:339
civector() noexcept
Constructor of class civector.
Definition: civector.inl:31
The Scalar Type complex.
Definition: complex.hpp:50
The Data Type cvector_slice.
Definition: cvector.hpp:845
The Data Type cvector.
Definition: cvector.hpp:58
The Scalar Type interval.
Definition: interval.hpp:55
The Data Type intmatrix.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector_slice.
Definition: ivector.hpp:963
The Data Type ivector.
Definition: ivector.hpp:55
The Scalar Type real.
Definition: real.hpp:114
The Data Type rvector_slice.
Definition: rvector.hpp:1064
The Data Type rvector.
Definition: rvector.hpp:58
Represents a row or column vector of a sparse matrix.
Definition: scimatrix.hpp:9628
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
scivector_slice & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4396
scivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4531
friend scvector Sup(const scivector_slice &)
Returns the supremum of the vector slice v.
Definition: scivector.hpp:4791
scivector_slice & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4431
scivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4172
scivector_slice & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4351
scivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4212
scivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4361
friend srvector InfRe(const scivector_slice &)
Returns the real part of the infimum of the vector slice v.
Definition: scivector.hpp:4796
scivector_slice & operator&=(const scivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4566
scivector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4247
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: scivector.hpp:4147
scivector_slice & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4346
friend int Lb(const scivector_slice &)
Returns the lower index bound of the vector slice v.
Definition: scivector.hpp:4766
scivector_slice & operator|=(const civector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4476
scivector_slice & operator|=(const rvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4461
scivector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4227
scivector_slice & operator-=(const scvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4446
scivector_slice & operator/=(const cinterval &s)
Operator for division of each element of the vector slice with a complex interval,...
Definition: scivector.hpp:4296
scivector_slice & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4316
scivector_slice & operator&=(const civector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4556
scivector_slice & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4486
friend srvector SupIm(const scivector_slice &)
Returns the imaginary part of the supremum of the vector slice v.
Definition: scivector.hpp:4811
scivector_slice & operator|=(const civector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4496
friend sivector abs(const scivector_slice &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: scivector.hpp:4827
scivector_slice & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4356
scivector_slice & operator|=(const cvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4471
scivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4202
scivector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4207
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: scivector.hpp:4135
scivector_slice & operator=(const scivector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4217
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
Definition: scivector.hpp:4112
scivector_slice & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4416
friend srvector InfIm(const scivector_slice &)
Returns the imaginary part of the infimum of the vector slice v.
Definition: scivector.hpp:4801
scivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: scivector.hpp:4262
friend scvector diam(const scivector_slice &)
Computes the diameter of v.
Definition: scivector.hpp:4849
scivector_slice & operator|=(const scivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4536
scivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4192
scivector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4341
scivector_slice & operator|=(const scvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4526
scivector_slice & operator|=(const scivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4516
scivector_slice & operator=(const civector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4257
scivector_slice & operator|=(const ivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4466
scivector_slice & operator*=(const cinterval &s)
Operator for multiplication with a complex interval, result is assigned to the vector slice.
Definition: scivector.hpp:4277
friend sivector Re(const scivector_slice &)
Returns the real part of v.
Definition: scivector.hpp:4776
scivector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4187
friend scvector mid(const scivector_slice &)
Computes the midpoint vector of v.
Definition: scivector.hpp:4838
scivector_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4481
scivector_slice & operator+=(const sivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4371
scivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4411
scivector_slice & operator|=(const srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4501
friend srvector SupRe(const scivector_slice &)
Returns the real part of the supremum of the vector slice v.
Definition: scivector.hpp:4806
friend scvector Inf(const scivector_slice &)
Returns the infimum vector slice v.
Definition: scivector.hpp:4786
scivector_slice & operator+=(const scivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4376
scivector_slice & operator&=(const scivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4576
scivector_slice & operator&=(const civector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4546
scivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4232
scivector_slice & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: scivector.hpp:4267
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
Definition: scivector.hpp:4103
scivector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4321
scivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4511
scivector_slice & operator&=(const sivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4561
scivector_slice & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4386
scivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4381
friend int VecLen(const scivector_slice &)
Returns the length of the vector slice.
Definition: scivector.hpp:4860
scivector_slice & operator=(const civector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4237
scivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4162
scivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4222
scivector_slice & operator=(const scivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4197
scivector_slice & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4331
scivector_slice & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4406
scivector_slice & operator=(const cinterval &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4177
scivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4301
scivector_slice & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4491
scivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4521
scivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4441
scivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4451
scivector_slice & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4306
scivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4252
scivector_slice & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4311
scivector_slice & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4391
scivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4401
friend scivector conj(const scivector_slice &)
Returns the conjugate complex of v.
Definition: scivector.hpp:4816
scivector_slice & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4336
scivector_slice & operator/=(const complex &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
Definition: scivector.hpp:4287
scivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4182
friend sivector Im(const scivector_slice &)
Returns the imaginary part of v.
Definition: scivector.hpp:4781
scivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4421
scivector_slice & operator&=(const ivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4551
scivector_slice & operator-=(const scivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4456
scivector_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
Definition: scivector.hpp:4167
scivector_slice & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4326
scivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scivector.hpp:4242
scivector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4426
scivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
Definition: scivector.hpp:4272
scivector_slice & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4436
scivector_slice & operator|=(const scvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4506
scivector_slice & operator&=(const sivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4571
scivector_slice & operator/=(const real &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
Definition: scivector.hpp:4282
scivector_slice & operator/=(const interval &s)
Operator for division of each element of the vector slice with an interval, result is assigned to the...
Definition: scivector.hpp:4291
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
Definition: scivector.hpp:4098
friend int Ub(const scivector_slice &)
Returns the upper index bound of the vector slice v.
Definition: scivector.hpp:4771
scivector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4366
scivector_slice & operator&=(const ivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: scivector.hpp:4541
A sparse complex interval vector.
Definition: scivector.hpp:62
scivector & operator=(const srvector &v)
Assign a sparse real vector to a sparse complex interval vector.
Definition: scivector.hpp:236
friend scvector diam(const scivector &)
Computes the diameter of v.
Definition: scivector.hpp:897
scivector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition: scivector.hpp:448
scivector & operator|=(const scivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:643
scivector(const int s)
Constructor for creating an empty vector of size s.
Definition: scivector.hpp:76
scivector(const int n, const int nnz, const int *index, const cinterval *values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition: scivector.hpp:129
scivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:538
scivector & operator=(const civector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:304
scivector(const srvector &v)
Creates a sparse complex interval vector out of a sparse real vector.
Definition: scivector.hpp:140
scivector & operator=(const sivector &v)
Assign a sparse interval vector to a sparse complex interval vector.
Definition: scivector.hpp:247
friend srvector InfRe(const scivector &)
Returns the infimum of the real part of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:952
std::vector< cinterval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: scivector.hpp:192
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
Definition: scivector.hpp:221
scivector & operator&=(const ivector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:658
scivector()
Default constructor, creates an empty vector of size 0
Definition: scivector.hpp:72
friend int Ub(const scivector &)
Returns the upper index bound of the vector v.
Definition: scivector.hpp:837
scivector & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:553
scivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition: scivector.hpp:417
scivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:588
friend sivector Re(const scivector &)
Returns the real part of the vector v.
Definition: scivector.hpp:908
scivector(const scvector &v)
Creates a sparse complex interval vector out of a sparse complex vector.
Definition: scivector.hpp:147
scivector & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:533
scivector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:548
friend srvector SupRe(const scivector &)
Returns the supremum of the real part of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:974
friend int Lb(const scivector &)
Returns the lower index bound of the vector v.
Definition: scivector.hpp:832
friend void SetUb(scivector &, const int)
Sets the upper index bound of the vector v to i.
Definition: scivector.hpp:826
scivector & operator+=(const civector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:503
friend srvector SupIm(const scivector &)
Returns the supremum of the imaginary part of the complex interval vector as a new sparse point vecto...
Definition: scivector.hpp:985
scivector & operator-=(const civector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:563
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
Definition: scivector.hpp:886
scivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector
Definition: scivector.hpp:428
scivector & operator=(const civector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:324
scivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:528
scivector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:508
scivector & operator&=(const civector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:653
const std::vector< cinterval > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: scivector.hpp:211
friend scvector Sup(const scivector &)
Returns the supremum of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:941
cinterval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
Definition: scivector.hpp:342
scivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition: scivector.hpp:394
scivector & operator-=(const civector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:543
scivector & operator&=(const ivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:648
friend void SetLb(scivector &, const int)
Sets the lower index bound of the vector v to i.
Definition: scivector.hpp:817
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: scivector.hpp:216
scivector & operator+=(const civector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:483
scivector & operator+=(const scivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:523
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
scivector & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:478
scivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:488
scivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:558
const cinterval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: scivector.hpp:376
scivector & operator/=(const complex &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition: scivector.hpp:453
scivector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:573
scivector & operator=(const rvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:309
scivector & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:608
scivector & operator=(const ivector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:319
scivector & operator=(const cvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:294
scivector & operator=(const interval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:279
scivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
Definition: scivector.hpp:438
friend srvector InfIm(const scivector &)
Returns the infimum of the imaginary part of the complex interval vector as a new sparse point vector...
Definition: scivector.hpp:963
friend sivector abs(const scivector &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: scivector.hpp:864
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:930
scivector & operator*=(const cinterval &s)
Operator for multiplication with an interval, result is assigned to the vector.
Definition: scivector.hpp:443
scivector & operator|=(const cvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:613
scivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:598
scivector & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:618
scivector & operator/=(const interval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
Definition: scivector.hpp:458
scivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:568
scivector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:468
scivector & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:518
scivector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: scivector.hpp:108
scivector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:473
scivector & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:498
scivector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:274
scivector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:493
scivector & operator|=(const civector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:603
scivector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:269
scivector & operator&=(const sivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:668
scivector & operator-=(const scivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:583
scivector(const sivector &v)
Creates a sparse complex interval vector out of a sparse interval vector.
Definition: scivector.hpp:154
scivector & operator|=(const cvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:593
scivector & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition: scivector.hpp:433
scivector & operator|=(const civector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:623
scivector & operator=(const scvector &v)
Assign a sparse complex vector to a sparse complex interval vector.
Definition: scivector.hpp:258
friend scivector conj(const scivector &)
Returns the complex conjugate of v.
Definition: scivector.hpp:875
scivector & operator&=(const civector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:663
scivector(const int n, const int nnz, const intvector &index, const civector &values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition: scivector.hpp:118
scivector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scivector.hpp:513
scivector(const civector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: scivector.hpp:88
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
Definition: scivector.hpp:919
scivector & operator|=(const srvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:628
scivector & operator/=(const cinterval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
Definition: scivector.hpp:463
cinterval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: scivector.hpp:364
scivector & operator=(const cinterval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scivector.hpp:284
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
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: scivector.hpp:202
scivector & operator|=(const scvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:633
scivector & operator&=(const scivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: scivector.hpp:673
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: scivector.hpp:226
scivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scivector.hpp:578
scivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: scivector.hpp:638
scivector & operator=(const cvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:314
scivector & operator=(const ivector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:299
friend int VecLen(const scivector &)
Returns the length of the vector (the dimension)
Definition: scivector.hpp:996
scivector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: scivector.hpp:289
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: scivector.hpp:183
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: scvector.hpp:178
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
A sparse interval vector.
Definition: sivector.hpp:59
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: sivector.hpp:181
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
A sparse real vector.
Definition: srvector.hpp:58
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: srvector.hpp:160
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156