C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
sivector.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: sivector.hpp,v 1.15 2014/01/30 17:23:48 cxsc Exp $ */
25 
26 #ifndef _CXSC_SIVECTOR_HPP_INCLUDED
27 #define _CXSC_SIVECTOR_HPP_INCLUDED
28 
29 #include <interval.hpp>
30 #include <ivector.hpp>
31 #include <vector>
32 #include <iostream>
33 #include <cidot.hpp>
34 #include <srvector.hpp>
35 #include <sparseidot.hpp>
36 #include <sparsevector.hpp>
37 
38 namespace cxsc {
39 
40 class srvector_slice;
41 class srmatrix;
42 class srmatrix_slice;
43 class srmatrix_subv;
44 class sivector_slice;
45 class simatrix;
46 class simatrix_slice;
47 class simatrix_subv;
48 class scivector;
49 class scivector_slice;
50 class scimatrix;
51 class scimatrix_slice;
52 class scimatrix_subv;
53 
55 
59 class sivector {
60  private:
61  std::vector<int> p;
62  std::vector<interval> x;
63  int lb;
64  int ub;
65  int n;
66 
67  public:
69  sivector() : lb(0), ub(-1) , n(0) {
70  }
71 
73  explicit sivector(const int s) : lb(1), ub(s), n(s) {
74  p.reserve((int)(s*0.1));
75  x.reserve((int)(s*0.1));
76  }
77 
79  sivector(const int s, const int b) : lb(1), ub(s), n(s) {
80  p.reserve(b);
81  x.reserve(b);
82  }
83 
85  sivector(const ivector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
86  for(int i=lb ; i<=ub ; i++) {
87  if(v[i] != 0.0) {
88  p.push_back(i-lb);
89  x.push_back(v[i]);
90  }
91  }
92  }
93 
95  sivector(const rvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
96  for(int i=lb ; i<=ub ; i++) {
97  if(v[i] != 0.0) {
98  p.push_back(i-lb);
99  x.push_back(interval(v[i]));
100  }
101  }
102  }
103 
105  sivector(const int n, const int nnz, const intvector& index, const ivector& values) : lb(1), ub(n) {
106  this->n = n;
107  for(int i=0 ; i<nnz ; i++) {
108  if(values[Lb(values)+i] != 0.0) {
109  p.push_back(index[Lb(index)+i]);
110  x.push_back(values[Lb(values)+i]);
111  }
112  }
113  }
114 
116  sivector(const int n, const int nnz, const int* index, const interval* values) : lb(1), ub(n) {
117  this->n = n;
118  for(int i=0 ; i<nnz ; i++) {
119  if(values[i] != 0.0) {
120  p.push_back(index[i]);
121  x.push_back(values[i]);
122  }
123  }
124  }
125 
127  sivector(const srvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
128  x.reserve(v.get_nnz());
129  for(int i=0 ; i<v.get_nnz() ; i++)
130  x.push_back(interval(v.x[i]));
131  }
132 
134  sivector(const srvector_slice&);
136  sivector(const sivector_slice&);
140  sivector(const simatrix_subv& A);
141 
143 
148  std::vector<int>& row_indices() {
149  return p;
150  }
151 
153 
157  std::vector<interval>& values() {
158  return x;
159  }
160 
162 
167  const std::vector<int>& row_indices() const {
168  return p;
169  }
170 
172 
176  const std::vector<interval>& values() const {
177  return x;
178  }
179 
181  int get_nnz() const {
182  return x.size();
183  }
184 
186  real density() const {
187  return (double)x.size()/n;
188  }
189 
191  void dropzeros() {
192  for(int i=0 ; i<get_nnz() ; i++) {
193  if(x[i] == 0.0) {
194  x.erase(x.begin()+i);
195  p.erase(p.begin()+i);
196  }
197  }
198  }
199 
200 
201  /* sivector& operator=(const sivector& v) {
202  p = v.p;
203  x = v.x;
204  return *this;
205  } */
206 
209  n = v.n;
210  p = v.p;
211  x.clear();
212  x.reserve(v.get_nnz());
213  for(unsigned int i=0 ; i<v.x.size() ; i++)
214  x[i] = interval(v.x[i]);
215  return *this;
216  }
217 
219  sivector& operator=(const real& v) {
220  return sp_vs_assign<sivector,real,interval>(*this,v);
221  }
222 
225  return sp_vs_assign<sivector,interval,interval>(*this,v);
226  }
227 
230  return spf_vv_assign<sivector,rvector,interval>(*this,v);
231  }
232 
235  return spf_vv_assign<sivector,ivector,interval>(*this,v);
236  }
237 
240  return spf_vv_assign<sivector,rvector_slice,interval>(*this,v);
241  }
242 
245  return spf_vv_assign<sivector,ivector_slice,interval>(*this,v);
246  }
247 
252 
254 
258  interval& operator[](const int i) {
259 #if(CXSC_INDEX_CHECK)
260  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator[](const int)"));
261 #endif
262  int k;
263 
264  for(k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
265  if(p[k] == i-lb)
266  return x[k];
267  }
268 
269  p.insert(p.begin() + k, i-lb);
270  x.insert(x.begin() + k, interval(0.0));
271 
272  return x[k];
273  }
274 
276 
280  interval operator[](const int i) const {
281 #if(CXSC_INDEX_CHECK)
282  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator[](const int)"));
283 #endif
284  return (*this)(i);
285  }
286 
288 
292  const interval operator()(const int i) const {
293 #if(CXSC_INDEX_CHECK)
294  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator()(const int)"));
295 #endif
296  interval r(0.0);
297 
298  for(int k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
299  if(p[k] == i-lb)
300  r = x[k];
301  }
302 
303  return r;
304  }
305 
307 
311  sivector v(n,get_nnz());
312  intvector pinv = perminv(per);
313 
314  std::map<int,interval> work;
315  for(int i=0 ; i<get_nnz() ; i++) {
316  work.insert(std::make_pair(pinv[Lb(pinv)+p[i]], x[i]));
317  }
318 
319  for(std::map<int,interval>::iterator it=work.begin() ; it!=work.end() ; it++) {
320  v.p.push_back(it->first);
321  v.x.push_back(it->second);
322  }
323 
324  return v;
325  }
326 
328 
335  intvector p = permvec(P);
336  return (*this)(p);
337  }
338 
340 
342  sivector_slice operator()(const int, const int);
343 
345  sivector& operator*=(const real& s) {
346  return sp_vs_multassign(*this,s);
347  }
348 
351  return sp_vs_multassign(*this,s);
352  }
353 
355  sivector& operator/=(const real& s) {
356  return sp_vs_divassign(*this,s);
357  }
358 
361  return sp_vs_divassign(*this,s);
362  }
363 
366  return spf_vv_addassign(*this,v);
367  }
368 
371  return spf_vv_addassign(*this,v);
372  }
373 
376  return spf_vv_addassign(*this,v);
377  }
378 
381  return spf_vv_addassign(*this,v);
382  }
383 
386  return spsp_vv_addassign(*this,v);
387  }
388 
391  return spsp_vv_addassign(*this,v);
392  }
393 
396  return spf_vv_subassign(*this,v);
397  }
398 
401  return spf_vv_subassign(*this,v);
402  }
403 
406  return spf_vv_subassign(*this,v);
407  }
408 
411  return spf_vv_subassign(*this,v);
412  }
413 
416  return spsp_vv_subassign(*this,v);
417  }
418 
421  return spsp_vv_subassign(*this,v);
422  }
423 
426  return spf_vv_hullassign(*this,v);
427  }
428 
431  return spf_vv_hullassign(*this,v);
432  }
433 
436  return spf_vv_hullassign(*this,v);
437  }
438 
441  return spf_vv_hullassign(*this,v);
442  }
443 
446  return spsp_vv_hullassign(*this,v);
447  }
448 
451  return spsp_vv_hullassign(*this,v);
452  }
453 
456  return spf_vv_intersectassign(*this,v);
457  }
458 
461  return spsp_vv_intersectassign(*this,v);
462  }
463 
472 
473  friend void SetLb(sivector&, const int);
474  friend void SetUb(sivector&, const int);
475  friend int Lb(const sivector&);
476  friend int Ub(const sivector&);
477  friend srvector Inf(const sivector&);
478  friend srvector Sup(const sivector&);
479  friend sivector Re(const scivector&);
480  friend sivector Im(const scivector&);
481  friend sivector abs(const sivector&);
482  friend sivector abs(const sivector_slice&);
483  friend srvector mid(const sivector&);
484  friend srvector diam(const sivector&);
485  friend sivector abs(const scivector&);
486  friend sivector abs(const scivector_slice&);
487  friend srvector absmin(const sivector&);
488  friend srvector absmax(const sivector&);
489  friend int VecLen(const sivector&);
490  friend sivector Blow(const sivector&, const real&);
491 
492  friend class srvector_slice;
493  friend class sivector_slice;
494  friend class scivector_slice;
495  friend class scivector;
496  friend class ivector;
497  friend class ivector_slice;
498  friend class civector;
499  friend class civector_slice;
500 
501 #include "vector_friend_declarations.inl"
502 };
503 
504 inline ivector::ivector(const sivector& v) {
505  l = v.lb;
506  u = v.ub;
507  size = v.n;
508  dat = new interval[v.n];
509  for(int i=0 ; i<v.n ; i++)
510  dat[i] = 0.0;
511  for(int i=0 ; i<v.get_nnz() ; i++)
512  dat[v.p[i]] = v.x[i];
513 }
514 
515 inline ivector::ivector(const srvector& v) {
516  l = v.lb;
517  u = v.ub;
518  size = v.n;
519  dat = new interval[v.n];
520  for(int i=0 ; i<v.n ; i++)
521  dat[i] = 0.0;
522  for(int i=0 ; i<v.get_nnz() ; i++)
523  dat[v.p[i]] = v.x[i];
524 }
525 
527  return fsp_vv_assign<ivector,sivector,interval>(*this,v);
528 }
529 
531  return fsl_vv_assign<ivector,sivector_slice,interval>(*this,v);
532 }
533 
535  return fsp_vv_assign<ivector,srvector,interval>(*this,v);
536 }
537 
539  return fsl_vv_assign<ivector,srvector_slice,interval>(*this,v);
540 }
541 
543 
546 inline void SetLb(sivector& v, const int i) {
547  v.lb = i;
548  v.ub = v.lb + v.n - 1;
549 }
550 
552 
555 inline void SetUb(sivector& v, const int j) {
556  v.ub = j;
557  v.lb = v.ub - v.n + 1;
558 }
559 
561 inline int Lb(const sivector& v) {
562  return v.lb;
563 }
564 
566 inline int Ub(const sivector& v) {
567  return v.ub;
568 }
569 
571 inline void Resize(sivector& v) {
572  sp_v_resize(v);
573 }
574 
576 
579 inline void Resize(sivector& v, const int n) {
580  sp_v_resize(v,n);
581 }
582 
584 
588 inline void Resize(sivector& v, const int l, const int u) {
589  sp_v_resize(v,l,u);
590 }
591 
593 inline srvector Inf(const sivector& v) {
594  srvector res(v.n, v.get_nnz());
595  res.lb = v.lb;
596  res.ub = v.ub;
597  res.p = v.p;
598  for(int i=0 ; i<v.get_nnz() ; i++)
599  res.x[i] = Inf(v.x[i]);
600  return res;
601 }
602 
604 inline srvector Sup(const sivector& v) {
605  srvector res(v.n, v.get_nnz());
606  res.lb = v.lb;
607  res.ub = v.ub;
608  res.p = v.p;
609  for(int i=0 ; i<v.get_nnz() ; i++)
610  res.x[i] = Sup(v.x[i]);
611  return res;
612 }
613 
615 inline sivector abs(const sivector& v) {
616  sivector res(v.n, v.get_nnz());
617  res.lb = v.lb;
618  res.ub = v.ub;
619  res.p = v.p;
620  for(int i=0 ; i<v.get_nnz() ; i++)
621  res.x.push_back(abs(v.x[i]));
622  return res;
623 }
624 
626 inline srvector absmin(const sivector& v) {
627  srvector res(v.n, v.get_nnz());
628  res.lb = v.lb;
629  res.ub = v.ub;
630  res.p = v.p;
631  for(int i=0 ; i<v.get_nnz() ; i++)
632  res.x.push_back(AbsMin(v.x[i]));
633  res.dropzeros();
634  return res;
635 }
636 
638 inline srvector absmax(const sivector& v) {
639  srvector res(v.n, v.get_nnz());
640  res.lb = v.lb;
641  res.ub = v.ub;
642  res.p = v.p;
643  for(int i=0 ; i<v.get_nnz() ; i++)
644  res.x.push_back(AbsMax(v.x[i]));
645  res.dropzeros();
646  return res;
647 }
648 
650 inline srvector mid(const sivector& v) {
651  srvector res(v.n, v.get_nnz());
652  res.lb = v.lb;
653  res.ub = v.ub;
654  res.p = v.p;
655  for(int i=0 ; i<v.get_nnz() ; i++) {
656  res.x.push_back(mid(v.x[i]));
657  }
658  return res;
659 }
660 
662 inline srvector diam(const sivector& v) {
663  srvector res(v.n, v.get_nnz());
664  res.lb = v.lb;
665  res.ub = v.ub;
666  res.p = v.p;
667  for(int i=0 ; i<v.get_nnz() ; i++)
668  res.x.push_back(diam(v.x[i]));
669  return res;
670 }
671 
673 inline int VecLen(const sivector& v) {
674  return v.n;
675 }
676 
678 inline sivector Blow(const sivector& v, const real& eps) {
679  sivector res(v);
680  for(unsigned int i=0 ; i<v.x.size() ; i++)
681  res.x[i] = Blow(v.x[i],eps);
682  return res;
683 }
684 
686 inline bool in (const sivector& v1, const sivector& v2) {
687  for(int i=0 ; i<VecLen(v1) ; i++)
688  if(!in(v1(i+Lb(v1)), v2(i+Lb(v2)))) return false;
689  return true;
690 }
691 
693 inline bool Zero(const sivector& v1) {
694  for(int i=0 ; i<VecLen(v1) ; i++)
695  if(v1(i+Lb(v1)) != 0.0) return false;
696  return true;
697 }
698 
700 inline sivector operator-(const sivector& v) {
701  return sp_v_negative(v);
702 }
703 
705 
711 inline interval operator*(const sivector& v1, const ivector& v2) {
712  return spf_vv_mult<sivector,ivector,interval,sparse_idot>(v1,v2);
713 }
714 
716 
722 inline interval operator*(const sivector& v1, const rvector& v2) {
723  return spf_vv_mult<sivector,rvector,interval,sparse_idot>(v1,v2);
724 }
725 
727 
733 inline interval operator*(const srvector& v1, const ivector& v2) {
734  return spf_vv_mult<srvector,ivector,interval,sparse_idot>(v1,v2);
735 }
736 
738 
744 inline interval operator*(const rvector& v1, const sivector& v2) {
745  return fsp_vv_mult<rvector,sivector,interval,sparse_idot>(v1,v2);
746 }
747 
749 
755 inline interval operator*(const ivector& v1, const srvector& v2) {
756  return fsp_vv_mult<ivector,srvector,interval,sparse_idot>(v1,v2);
757 }
758 
760 
766 inline interval operator*(const ivector& v1, const sivector& v2) {
767  return fsp_vv_mult<ivector,sivector,interval,sparse_idot>(v1,v2);
768 }
769 
771 
777 inline interval operator*(const sivector& v1, const rvector_slice& v2) {
778  return spf_vv_mult<sivector,rvector_slice,interval,sparse_idot>(v1,v2);
779 }
780 
782 
788 inline interval operator*(const sivector& v1, const ivector_slice& v2) {
789  return spf_vv_mult<sivector,ivector_slice,interval,sparse_idot>(v1,v2);
790 }
791 
793 
799 inline interval operator*(const srvector& v1, const ivector_slice& v2) {
800  return spf_vv_mult<srvector,ivector_slice,interval,sparse_idot>(v1,v2);
801 }
802 
804 
810 inline interval operator*(const ivector_slice& v1, const srvector& v2) {
811  return fsp_vv_mult<ivector_slice,srvector,interval,sparse_idot>(v1,v2);
812 }
813 
815 
821 inline interval operator*(const ivector_slice& v1, const sivector& v2) {
822  return fsp_vv_mult<ivector_slice,sivector,interval,sparse_idot>(v1,v2);
823 }
824 
826 
832 inline interval operator*(const rvector_slice& v1, const sivector& v2) {
833  return fsp_vv_mult<rvector_slice,sivector,interval,sparse_idot>(v1,v2);
834 }
835 
837 
843 inline interval operator*(const sivector& v1, const srvector& v2) {
844  return spsp_vv_mult<sivector,srvector,interval,sparse_idot>(v1,v2);
845 }
846 
848 
854 inline interval operator*(const srvector& v1, const sivector& v2) {
855  return spsp_vv_mult<srvector,sivector,interval,sparse_idot>(v1,v2);
856 }
857 
859 
865 inline interval operator*(const sivector& v1, const sivector& v2) {
866  return spsp_vv_mult<sivector,sivector,interval,sparse_idot>(v1,v2);
867 }
868 
870 inline sivector operator*(const sivector& v, const real& s) {
871  return sp_vs_mult<sivector,real,sivector>(v,s);
872 }
873 
875 inline sivector operator*(const sivector& v, const interval& s) {
876  return sp_vs_mult<sivector,interval,sivector>(v,s);
877 }
878 
880 inline sivector operator*(const srvector& v, const interval& s) {
881  return sp_vs_mult<srvector,interval,sivector>(v,s);
882 }
883 
885 inline sivector operator/(const sivector& v, const real& s) {
886  return sp_vs_div<sivector,real,sivector>(v,s);
887 }
888 
890 inline sivector operator/(const sivector& v, const interval& s) {
891  return sp_vs_div<sivector,interval,sivector>(v,s);
892 }
893 
895 inline sivector operator/(const srvector& v, const interval& s) {
896  return sp_vs_div<srvector,interval,sivector>(v,s);
897 }
898 
900 inline sivector operator*(const real& s, const sivector& v) {
901  return sp_sv_mult<real,sivector,sivector>(s,v);
902 }
903 
905 inline sivector operator*(const interval& s, const sivector& v) {
906  return sp_sv_mult<interval,sivector,sivector>(s,v);
907 }
908 
910 inline sivector operator*(const interval& s, const srvector& v) {
911  return sp_sv_mult<interval,srvector,sivector>(s,v);
912 }
913 
915 inline ivector operator+(const ivector& v1, const srvector& v2) {
916  return fsp_vv_add<ivector,srvector,ivector>(v1,v2);
917 }
918 
920 inline ivector operator+(const rvector& v1, const sivector& v2) {
921  return fsp_vv_add<rvector,sivector,ivector>(v1,v2);
922 }
923 
925 inline ivector operator+(const ivector& v1, const sivector& v2) {
926  return fsp_vv_add<ivector,sivector,ivector>(v1,v2);
927 }
928 
930 inline ivector operator+(const sivector& v1, const rvector& v2) {
931  return spf_vv_add<sivector,rvector,ivector>(v1,v2);
932 }
933 
935 inline ivector operator+(const srvector& v1, const ivector& v2) {
936  return spf_vv_add<srvector,ivector,ivector>(v1,v2);
937 }
938 
940 inline ivector operator+(const sivector& v1, const ivector& v2) {
941  return spf_vv_add<sivector,ivector,ivector>(v1,v2);
942 }
943 
945 inline ivector operator+(const ivector_slice& v1, const srvector& v2) {
946  return fsp_vv_add<ivector_slice,srvector,ivector>(v1,v2);
947 }
948 
950 inline ivector operator+(const rvector_slice& v1, const sivector& v2) {
951  return fsp_vv_add<rvector_slice,sivector,ivector>(v1,v2);
952 }
953 
955 inline ivector operator+(const ivector_slice& v1, const sivector& v2) {
956  return fsp_vv_add<ivector_slice,sivector,ivector>(v1,v2);
957 }
958 
960 inline ivector operator+(const sivector& v1, const rvector_slice& v2) {
961  return spf_vv_add<sivector,rvector_slice,ivector>(v1,v2);
962 }
963 
965 inline ivector operator+(const srvector& v1, const ivector_slice& v2) {
966  return spf_vv_add<srvector,ivector_slice,ivector>(v1,v2);
967 }
968 
970 inline ivector operator+(const sivector& v1, const ivector_slice& v2) {
971  return spf_vv_add<sivector,ivector_slice,ivector>(v1,v2);
972 }
973 
975 inline sivector operator+(const sivector& v1, const srvector& v2) {
976  return spsp_vv_add<sivector,srvector,sivector,interval>(v1,v2);
977 }
978 
980 inline sivector operator+(const srvector& v1, const sivector& v2) {
981  return spsp_vv_add<srvector,sivector,sivector,interval>(v1,v2);
982 }
983 
985 inline sivector operator+(const sivector& v1, const sivector& v2) {
986  return spsp_vv_add<sivector,sivector,sivector,interval>(v1,v2);
987 }
988 
990 inline ivector operator-(const ivector& v1, const srvector& v2) {
991  return fsp_vv_sub<ivector,srvector,ivector>(v1,v2);
992 }
993 
995 inline ivector operator-(const rvector& v1, const sivector& v2) {
996  return fsp_vv_sub<rvector,sivector,ivector>(v1,v2);
997 }
998 
1000 inline ivector operator-(const ivector& v1, const sivector& v2) {
1001  return fsp_vv_sub<ivector,sivector,ivector>(v1,v2);
1002 }
1003 
1005 inline ivector operator-(const sivector& v1, const rvector& v2) {
1006  return spf_vv_sub<sivector,rvector,ivector>(v1,v2);
1007 }
1008 
1010 inline ivector operator-(const srvector& v1, const ivector& v2) {
1011  return spf_vv_sub<srvector,ivector,ivector>(v1,v2);
1012 }
1013 
1015 inline ivector operator-(const sivector& v1, const ivector& v2) {
1016  return spf_vv_sub<sivector,ivector,ivector>(v1,v2);
1017 }
1018 
1020 inline ivector operator-(const ivector_slice& v1, const srvector& v2) {
1021  return fsp_vv_sub<ivector_slice,srvector,ivector>(v1,v2);
1022 }
1023 
1025 inline ivector operator-(const rvector_slice& v1, const sivector& v2) {
1026  return fsp_vv_sub<rvector_slice,sivector,ivector>(v1,v2);
1027 }
1028 
1030 inline ivector operator-(const ivector_slice& v1, const sivector& v2) {
1031  return fsp_vv_sub<ivector_slice,sivector,ivector>(v1,v2);
1032 }
1033 
1035 inline ivector operator-(const sivector& v1, const rvector_slice& v2) {
1036  return spf_vv_sub<sivector,rvector_slice,ivector>(v1,v2);
1037 }
1038 
1040 inline ivector operator-(const srvector& v1, const ivector_slice& v2) {
1041  return spf_vv_sub<srvector,ivector_slice,ivector>(v1,v2);
1042 }
1043 
1045 inline ivector operator-(const sivector& v1, const ivector_slice& v2) {
1046  return spf_vv_sub<sivector,ivector_slice,ivector>(v1,v2);
1047 }
1048 
1050 inline sivector operator-(const sivector& v1, const srvector& v2) {
1051  return spsp_vv_sub<sivector,srvector,sivector,interval>(v1,v2);
1052 }
1053 
1055 inline sivector operator-(const srvector& v1, const sivector& v2) {
1056  return spsp_vv_sub<srvector,sivector,sivector,interval>(v1,v2);
1057 }
1058 
1060 inline sivector operator-(const sivector& v1, const sivector& v2) {
1061  return spsp_vv_sub<sivector,sivector,sivector,interval>(v1,v2);
1062 }
1063 
1065 inline ivector operator|(const rvector& v1, const srvector& v2) {
1066  return fsp_vv_hull<rvector,srvector,ivector>(v1,v2);
1067 }
1068 
1070 inline ivector operator|(const srvector& v1, const rvector& v2) {
1071  return spf_vv_hull<srvector,rvector,ivector>(v1,v2);
1072 }
1073 
1075 inline ivector operator|(const rvector_slice& v1, const srvector& v2) {
1076  return fsp_vv_hull<rvector_slice,srvector,ivector>(v1,v2);
1077 }
1078 
1080 inline ivector operator|(const srvector& v1, const rvector_slice& v2) {
1081  return spf_vv_hull<srvector,rvector_slice,ivector>(v1,v2);
1082 }
1083 
1085 inline sivector operator|(const srvector& v1, const srvector& v2) {
1086  return spsp_vv_hull<srvector,srvector,sivector,interval>(v1,v2);
1087 }
1088 
1090 inline ivector operator|(const ivector& v1, const srvector& v2) {
1091  return fsp_vv_hull<ivector,srvector,ivector>(v1,v2);
1092 }
1093 
1095 inline ivector operator|(const rvector& v1, const sivector& v2) {
1096  return fsp_vv_hull<rvector,sivector,ivector>(v1,v2);
1097 }
1098 
1100 inline ivector operator|(const ivector& v1, const sivector& v2) {
1101  return fsp_vv_hull<ivector,sivector,ivector>(v1,v2);
1102 }
1103 
1105 inline ivector operator|(const sivector& v1, const rvector& v2) {
1106  return spf_vv_hull<sivector,rvector,ivector>(v1,v2);
1107 }
1108 
1110 inline ivector operator|(const srvector& v1, const ivector& v2) {
1111  return spf_vv_hull<srvector,ivector,ivector>(v1,v2);
1112 }
1113 
1115 inline ivector operator|(const sivector& v1, const ivector& v2) {
1116  return spf_vv_hull<sivector,ivector,ivector>(v1,v2);
1117 }
1118 
1120 inline ivector operator|(const ivector_slice& v1, const srvector& v2) {
1121  return fsp_vv_hull<ivector_slice,srvector,ivector>(v1,v2);
1122 }
1123 
1125 inline ivector operator|(const rvector_slice& v1, const sivector& v2) {
1126  return fsp_vv_hull<rvector_slice,sivector,ivector>(v1,v2);
1127 }
1128 
1130 inline ivector operator|(const ivector_slice& v1, const sivector& v2) {
1131  return fsp_vv_hull<ivector_slice,sivector,ivector>(v1,v2);
1132 }
1133 
1135 inline ivector operator|(const sivector& v1, const rvector_slice& v2) {
1136  return spf_vv_hull<sivector,rvector_slice,ivector>(v1,v2);
1137 }
1138 
1140 inline ivector operator|(const srvector& v1, const ivector_slice& v2) {
1141  return spf_vv_hull<srvector,ivector_slice,ivector>(v1,v2);
1142 }
1143 
1145 inline ivector operator|(const sivector& v1, const ivector_slice& v2) {
1146  return spf_vv_hull<sivector,ivector_slice,ivector>(v1,v2);
1147 }
1148 
1150 inline sivector operator|(const sivector& v1, const srvector& v2) {
1151  return spsp_vv_hull<sivector,srvector,sivector,interval>(v1,v2);
1152 }
1153 
1155 inline sivector operator|(const srvector& v1, const sivector& v2) {
1156  return spsp_vv_hull<srvector,sivector,sivector,interval>(v1,v2);
1157 }
1158 
1160 inline sivector operator|(const sivector& v1, const sivector& v2) {
1161  return spsp_vv_hull<sivector,sivector,sivector,interval>(v1,v2);
1162 }
1163 
1165 inline sivector operator&(const ivector& v1, const sivector& v2) {
1166  return fsp_vv_intersect<ivector,sivector,ivector>(v1,v2);
1167 }
1168 
1170 inline sivector operator&(const sivector& v1, const ivector& v2) {
1171  return spf_vv_intersect<sivector,ivector,ivector>(v1,v2);
1172 }
1173 
1175 inline sivector operator&(const ivector_slice& v1, const sivector& v2) {
1176  return fsp_vv_intersect<ivector_slice,sivector,ivector>(v1,v2);
1177 }
1178 
1180 inline sivector operator&(const sivector& v1, const ivector_slice& v2) {
1181  return spf_vv_intersect<sivector,ivector_slice,ivector>(v1,v2);
1182 }
1183 
1185 inline sivector operator&(const sivector& v1, const sivector& v2) {
1186  return spsp_vv_intersect<sivector,sivector,sivector,interval>(v1,v2);
1187 }
1188 
1190  return fsp_vv_addassign(*this,v2);
1191 }
1192 
1194  return fsp_vv_addassign(*this,v2);
1195 }
1196 
1198  return fsp_vv_addassign(*this,v2);
1199 }
1200 
1202  return fsp_vv_addassign(*this,v2);
1203 }
1204 
1206  return fsp_vv_subassign(*this,v2);
1207 }
1208 
1210  return fsp_vv_subassign(*this,v2);
1211 }
1212 
1214  return fsp_vv_subassign(*this,v2);
1215 }
1216 
1218  return fsp_vv_subassign(*this,v2);
1219 }
1220 
1222  return fsp_vv_hullassign(*this,v2);
1223 }
1224 
1226  return fsp_vv_hullassign(*this,v2);
1227 }
1228 
1230  return fsp_vv_hullassign(*this,v2);
1231 }
1232 
1234  return fsp_vv_hullassign(*this,v2);
1235 }
1236 
1238  return fsp_vv_intersectassign(*this,v2);
1239 }
1240 
1242  return fsp_vv_intersectassign(*this,v2);
1243 }
1244 
1246 
1249 inline bool operator==(const sivector& v1, const sivector& v2) {
1250  return spsp_vv_comp(v1,v2);
1251 }
1252 
1254 
1257 inline bool operator==(const sivector& v1, const srvector& v2) {
1258  return spsp_vv_comp(v1,v2);
1259 }
1260 
1262 
1265 inline bool operator==(const srvector& v1, const sivector& v2) {
1266  return spsp_vv_comp(v1,v2);
1267 }
1268 
1270 
1273 inline bool operator==(const sivector& v1, const rvector& v2) {
1274  return spf_vv_comp(v1,v2);
1275 }
1276 
1278 
1281 inline bool operator==(const srvector& v1, const ivector& v2) {
1282  return spf_vv_comp(v1,v2);
1283 }
1284 
1286 
1289 inline bool operator==(const sivector& v1, const ivector& v2) {
1290  return spf_vv_comp(v1,v2);
1291 }
1292 
1294 
1297 inline bool operator==(const ivector& v1, const srvector& v2) {
1298  return fsp_vv_comp(v1,v2);
1299 }
1300 
1302 
1305 inline bool operator==(const rvector& v1, const sivector& v2) {
1306  return fsp_vv_comp(v1,v2);
1307 }
1308 
1310 
1313 inline bool operator==(const ivector& v1, const sivector& v2) {
1314  return fsp_vv_comp(v1,v2);
1315 }
1316 
1318 
1321 inline bool operator==(const sivector& v1, const rvector_slice& v2) {
1322  return spf_vv_comp(v1,v2);
1323 }
1324 
1326 
1329 inline bool operator==(const srvector& v1, const ivector_slice& v2) {
1330  return spf_vv_comp(v1,v2);
1331 }
1332 
1334 
1337 inline bool operator==(const sivector& v1, const ivector_slice& v2) {
1338  return spf_vv_comp(v1,v2);
1339 }
1340 
1342 
1345 inline bool operator==(const ivector_slice& v1, const srvector& v2) {
1346  return fsp_vv_comp(v1,v2);
1347 }
1348 
1350 
1353 inline bool operator==(const rvector_slice& v1, const sivector& v2) {
1354  return fsp_vv_comp(v1,v2);
1355 }
1356 
1358 
1361 inline bool operator==(const ivector_slice& v1, const sivector& v2) {
1362  return fsp_vv_comp(v1,v2);
1363 }
1364 
1366 
1369 inline bool operator!=(const sivector& v1, const srvector& v2) {
1370  return !spsp_vv_comp(v1,v2);
1371 }
1372 
1374 
1377 inline bool operator!=(const srvector& v1, const sivector& v2) {
1378  return !spsp_vv_comp(v1,v2);
1379 }
1380 
1382 
1385 inline bool operator!=(const sivector& v1, const sivector& v2) {
1386  return !spsp_vv_comp(v1,v2);
1387 }
1388 
1390 
1393 inline bool operator!=(const sivector& v1, const rvector& v2) {
1394  return !spf_vv_comp(v1,v2);
1395 }
1396 
1398 
1401 inline bool operator!=(const srvector& v1, const ivector& v2) {
1402  return !spf_vv_comp(v1,v2);
1403 }
1404 
1406 
1409 inline bool operator!=(const sivector& v1, const ivector& v2) {
1410  return !spf_vv_comp(v1,v2);
1411 }
1412 
1414 
1417 inline bool operator!=(const ivector& v1, const srvector& v2) {
1418  return !fsp_vv_comp(v1,v2);
1419 }
1420 
1422 
1425 inline bool operator!=(const rvector& v1, const sivector& v2) {
1426  return !fsp_vv_comp(v1,v2);
1427 }
1428 
1430 
1433 inline bool operator!=(const ivector& v1, const sivector& v2) {
1434  return !fsp_vv_comp(v1,v2);
1435 }
1436 
1438 
1441 inline bool operator!=(const sivector& v1, const rvector_slice& v2) {
1442  return !spf_vv_comp(v1,v2);
1443 }
1444 
1446 
1449 inline bool operator!=(const srvector& v1, const ivector_slice& v2) {
1450  return !spf_vv_comp(v1,v2);
1451 }
1452 
1454 
1457 inline bool operator!=(const sivector& v1, const ivector_slice& v2) {
1458  return !spf_vv_comp(v1,v2);
1459 }
1460 
1462 
1465 inline bool operator!=(const ivector_slice& v1, const srvector& v2) {
1466  return !fsp_vv_comp(v1,v2);
1467 }
1468 
1470 
1473 inline bool operator!=(const rvector_slice& v1, const sivector& v2) {
1474  return !fsp_vv_comp(v1,v2);
1475 }
1476 
1478 
1481 inline bool operator!=(const ivector_slice& v1, const sivector& v2) {
1482  return !fsp_vv_comp(v1,v2);
1483 }
1484 
1486 
1489 inline bool operator<(const sivector& v1, const sivector& v2) {
1490  return spsp_vv_less<sivector,sivector,interval>(v1,v2);
1491 }
1492 
1494 
1497 inline bool operator<(const srvector& v1, const sivector& v2) {
1498  return spsp_vv_less<srvector,sivector,interval>(v1,v2);
1499 }
1500 
1502 
1505 inline bool operator<(const srvector& v1, const ivector& v2) {
1506  return spf_vv_less<srvector,ivector,interval>(v1,v2);
1507 }
1508 
1510 
1513 inline bool operator<(const sivector& v1, const ivector& v2) {
1514  return spf_vv_less<sivector,ivector,interval>(v1,v2);
1515 }
1516 
1518 
1521 inline bool operator<(const rvector& v1, const sivector& v2) {
1522  return fsp_vv_less<rvector,sivector,interval>(v1,v2);
1523 }
1524 
1526 
1529 inline bool operator<(const ivector& v1, const sivector& v2) {
1530  return fsp_vv_less<ivector,sivector,interval>(v1,v2);
1531 }
1532 
1534 
1537 inline bool operator<(const srvector& v1, const ivector_slice& v2) {
1538  return spf_vv_less<srvector,ivector_slice,interval>(v1,v2);
1539 }
1540 
1542 
1545 inline bool operator<(const sivector& v1, const ivector_slice& v2) {
1546  return spf_vv_less<sivector,ivector_slice,interval>(v1,v2);
1547 }
1548 
1550 
1553 inline bool operator<(const rvector_slice& v1, const sivector& v2) {
1554  return fsp_vv_less<rvector_slice,sivector,interval>(v1,v2);
1555 }
1556 
1558 
1561 inline bool operator<(const ivector_slice& v1, const sivector& v2) {
1562  return fsp_vv_less<ivector_slice,sivector,interval>(v1,v2);
1563 }
1564 
1566 
1569 inline bool operator<=(const sivector& v1, const sivector& v2) {
1570  return spsp_vv_leq<sivector,sivector,interval>(v1,v2);
1571 }
1572 
1574 
1577 inline bool operator<=(const srvector& v1, const sivector& v2) {
1578  return spsp_vv_leq<srvector,sivector,interval>(v1,v2);
1579 }
1580 
1582 
1585 inline bool operator<=(const srvector& v1, const ivector& v2) {
1586  return spf_vv_leq<srvector,ivector,interval>(v1,v2);
1587 }
1588 
1590 
1593 inline bool operator<=(const sivector& v1, const ivector& v2) {
1594  return spf_vv_leq<sivector,ivector,interval>(v1,v2);
1595 }
1596 
1598 
1601 inline bool operator<=(const rvector& v1, const sivector& v2) {
1602  return fsp_vv_leq<rvector,sivector,interval>(v1,v2);
1603 }
1604 
1606 
1609 inline bool operator<=(const ivector& v1, const sivector& v2) {
1610  return fsp_vv_leq<ivector,sivector,interval>(v1,v2);
1611 }
1612 
1614 
1617 inline bool operator<=(const srvector& v1, const ivector_slice& v2) {
1618  return spf_vv_leq<srvector,ivector_slice,interval>(v1,v2);
1619 }
1620 
1622 
1625 inline bool operator<=(const sivector& v1, const ivector_slice& v2) {
1626  return spf_vv_leq<sivector,ivector_slice,interval>(v1,v2);
1627 }
1628 
1630 
1633 inline bool operator<=(const rvector_slice& v1, const sivector& v2) {
1634  return fsp_vv_leq<rvector_slice,sivector,interval>(v1,v2);
1635 }
1636 
1638 
1641 inline bool operator<=(const ivector_slice& v1, const sivector& v2) {
1642  return fsp_vv_leq<ivector_slice,sivector,interval>(v1,v2);
1643 }
1644 
1646 
1649 inline bool operator>(const sivector& v1, const sivector& v2) {
1650  return spsp_vv_greater<sivector,sivector,interval>(v1,v2);
1651 }
1652 
1654 
1657 inline bool operator>(const sivector& v1, const srvector& v2) {
1658  return spsp_vv_greater<sivector,srvector,interval>(v1,v2);
1659 }
1660 
1662 
1665 inline bool operator>(const sivector& v1, const rvector& v2) {
1666  return spf_vv_greater<sivector,rvector,interval>(v1,v2);
1667 }
1668 
1670 
1673 inline bool operator>(const sivector& v1, const ivector& v2) {
1674  return spf_vv_greater<sivector,ivector,interval>(v1,v2);
1675 }
1676 
1678 
1681 inline bool operator>(const ivector& v1, const srvector& v2) {
1682  return fsp_vv_greater<ivector,srvector,interval>(v1,v2);
1683 }
1684 
1686 
1689 inline bool operator>(const ivector& v1, const sivector& v2) {
1690  return fsp_vv_greater<ivector,sivector,interval>(v1,v2);
1691 }
1692 
1694 
1697 inline bool operator>(const sivector& v1, const rvector_slice& v2) {
1698  return spf_vv_greater<sivector,rvector_slice,interval>(v1,v2);
1699 }
1700 
1702 
1705 inline bool operator>(const sivector& v1, const ivector_slice& v2) {
1706  return spf_vv_greater<sivector,ivector_slice,interval>(v1,v2);
1707 }
1708 
1710 
1713 inline bool operator>(const ivector_slice& v1, const srvector& v2) {
1714  return fsp_vv_greater<ivector_slice,srvector,interval>(v1,v2);
1715 }
1716 
1718 
1721 inline bool operator>(const ivector_slice& v1, const sivector& v2) {
1722  return fsp_vv_greater<ivector_slice,sivector,interval>(v1,v2);
1723 }
1724 
1726 
1729 inline bool operator>=(const sivector& v1, const sivector& v2) {
1730  return spsp_vv_geq<sivector,sivector,interval>(v1,v2);
1731 }
1732 
1734 
1737 inline bool operator>=(const sivector& v1, const srvector& v2) {
1738  return spsp_vv_geq<sivector,srvector,interval>(v1,v2);
1739 }
1740 
1742 
1745 inline bool operator>=(const sivector& v1, const rvector& v2) {
1746  return spf_vv_geq<sivector,rvector,interval>(v1,v2);
1747 }
1748 
1750 
1753 inline bool operator>=(const sivector& v1, const ivector& v2) {
1754  return spf_vv_geq<sivector,ivector,interval>(v1,v2);
1755 }
1756 
1758 
1761 inline bool operator>=(const ivector& v1, const srvector& v2) {
1762  return fsp_vv_geq<ivector,srvector,interval>(v1,v2);
1763 }
1764 
1766 
1769 inline bool operator>=(const ivector& v1, const sivector& v2) {
1770  return fsp_vv_geq<ivector,sivector,interval>(v1,v2);
1771 }
1772 
1774 
1777 inline bool operator>=(const sivector& v1, const rvector_slice& v2) {
1778  return spf_vv_geq<sivector,rvector_slice,interval>(v1,v2);
1779 }
1780 
1782 
1785 inline bool operator>=(const sivector& v1, const ivector_slice& v2) {
1786  return spf_vv_geq<sivector,ivector_slice,interval>(v1,v2);
1787 }
1788 
1790 
1793 inline bool operator>=(const ivector_slice& v1, const srvector& v2) {
1794  return fsp_vv_geq<ivector_slice,srvector,interval>(v1,v2);
1795 }
1796 
1798 
1801 inline bool operator>=(const ivector_slice& v1, const sivector& v2) {
1802  return fsp_vv_geq<ivector_slice,sivector,interval>(v1,v2);
1803 }
1804 
1806 
1811 inline std::ostream& operator<<(std::ostream& os, const sivector& v) {
1812  return sp_v_output<sivector,interval>(os,v);
1813 }
1814 
1816 
1821 inline std::istream& operator>>(std::istream& is, sivector& v) {
1822  return sp_v_input<sivector,interval>(is,v);
1823 }
1824 
1826 
1832  private:
1833  std::vector<int>& p;
1834  std::vector<interval>& x;
1835  sivector& orig;
1836  int start,end;
1837  int lb;
1838  int ub;
1839  int n;
1840  int nnz;
1841  int offset;
1842 
1844 
1848  sivector_slice(sivector& v, int l, int u) : p(v.p), x(v.x), orig(v), lb(l), ub(u), n(u-l+1) {
1849  int i;
1850 
1851  for(i=0 ; i<v.get_nnz() && p[i]<lb-v.lb ; i++);
1852 
1853  start = i;
1854 
1855  for(i=start ; i<v.get_nnz() && p[i]<=ub-v.lb ; i++);
1856 
1857  end = i-1;
1858 
1859  nnz = end-start+1;
1860  offset = lb-v.lb;
1861  }
1862 
1863  public:
1864 
1866  int get_nnz() const {
1867  return nnz;
1868  }
1869 
1871  real density() const {
1872  return (double)nnz/n;
1873  }
1874 
1876 
1880  interval& operator[](const int i) {
1881 #if(CXSC_INDEX_CHECK)
1882  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector_slice::operator[](const int)"));
1883 #endif
1884  int k;
1885 
1886  for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
1887  if(p[k]-offset == i-lb)
1888  return x[k];
1889  }
1890 
1891  p.insert(p.begin() + k, i-lb);
1892  x.insert(x.begin() + k, interval(0.0));
1893  end++;
1894 
1895  return x[k];
1896  }
1897 
1899 
1903  interval operator[](const int i) const {
1904 #if(CXSC_INDEX_CHECK)
1905  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector_slice::operator[](const int)"));
1906 #endif
1907  return (*this)(i);
1908  }
1909 
1911 
1915  const interval operator()(const int i) const {
1916 #if(CXSC_INDEX_CHECK)
1917  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector_slice::operator()(const int)"));
1918 #endif
1919  interval r(0.0);
1920 
1921  for(int k=start ; k<end && p[k]-start<=i-lb ; k++) {
1922  if(p[k]-start == i-lb)
1923  r = x[k];
1924  }
1925 
1926  return r;
1927  }
1928 
1931  return sl_vs_assign<sivector_slice,real,interval,std::vector<interval>::iterator>(*this,v);
1932  }
1933 
1936  return sl_vs_assign<sivector_slice,interval,interval,std::vector<interval>::iterator>(*this,v);
1937  }
1938 
1941  return slsl_vv_assign<sivector_slice,srvector_slice,interval,std::vector<interval>::iterator>(*this,v);
1942  }
1943 
1946  return slsl_vv_assign<sivector_slice,sivector_slice,interval,std::vector<interval>::iterator>(*this,v);
1947  }
1948 
1951  return slsp_vv_assign<sivector_slice,srvector,interval,std::vector<interval>::iterator>(*this,v);
1952  }
1953 
1956  return slsp_vv_assign<sivector_slice,sivector,interval,std::vector<interval>::iterator>(*this,v);
1957  }
1958 
1961  return slf_vv_assign<sivector_slice,rvector,interval,std::vector<interval>::iterator>(*this,v);
1962  }
1963 
1966  return slf_vv_assign<sivector_slice,ivector,interval,std::vector<interval>::iterator>(*this,v);
1967  }
1968 
1971  return slf_vv_assign<sivector_slice,rvector_slice,interval,std::vector<interval>::iterator>(*this,v);
1972  }
1973 
1976  return slf_vv_assign<sivector_slice,ivector_slice,interval,std::vector<interval>::iterator>(*this,v);
1977  }
1978 
1981  return sl_vs_multassign(*this,s);
1982  }
1983 
1986  return sl_vs_multassign(*this,s);
1987  }
1988 
1991  return sl_vs_divassign(*this,s);
1992  }
1993 
1996  return sl_vs_divassign(*this,s);
1997  }
1998 
2001  return slf_vv_addassign<sivector_slice,rvector,interval>(*this,v);
2002  }
2003 
2006  return slf_vv_addassign<sivector_slice,ivector,interval>(*this,v);
2007  }
2008 
2011  return slf_vv_addassign<sivector_slice,rvector_slice,interval>(*this,v);
2012  }
2013 
2016  return slf_vv_addassign<sivector_slice,ivector_slice,interval>(*this,v);
2017  }
2018 
2021  return slsp_vv_addassign(*this,v);
2022  }
2023 
2026  return slsp_vv_addassign(*this,v);
2027  }
2028 
2031  return slsl_vv_addassign(*this,v);
2032  }
2033 
2036  return slsl_vv_addassign(*this,v);
2037  }
2038 
2041  return slf_vv_subassign<sivector_slice,rvector,interval>(*this,v);
2042  }
2043 
2046  return slf_vv_subassign<sivector_slice,ivector,interval>(*this,v);
2047  }
2048 
2051  return slf_vv_subassign<sivector_slice,rvector_slice,interval>(*this,v);
2052  }
2053 
2056  return slf_vv_subassign<sivector_slice,ivector_slice,interval>(*this,v);
2057  }
2058 
2061  return slsp_vv_subassign(*this,v);
2062  }
2063 
2066  return slsp_vv_subassign(*this,v);
2067  }
2068 
2071  return slsl_vv_subassign(*this,v);
2072  }
2073 
2076  return slsl_vv_subassign(*this,v);
2077  }
2078 
2081  return slf_vv_hullassign<sivector_slice,rvector,interval>(*this,v);
2082  }
2083 
2086  return slf_vv_hullassign<sivector_slice,ivector,interval>(*this,v);
2087  }
2088 
2091  return slf_vv_hullassign<sivector_slice,rvector_slice,interval>(*this,v);
2092  }
2093 
2096  return slf_vv_hullassign<sivector_slice,ivector_slice,interval>(*this,v);
2097  }
2098 
2101  return slsp_vv_hullassign(*this,v);
2102  }
2103 
2106  return slsp_vv_hullassign(*this,v);
2107  }
2108 
2111  return slsl_vv_hullassign(*this,v);
2112  }
2113 
2116  return slsl_vv_hullassign(*this,v);
2117  }
2118 
2121  return slf_vv_intersectassign<sivector_slice,ivector,interval>(*this,v);
2122  }
2123 
2126  return slf_vv_intersectassign<sivector_slice,ivector_slice,interval>(*this,v);
2127  }
2128 
2131  return slsp_vv_intersectassign(*this,v);
2132  }
2133 
2136  return slsl_vv_intersectassign(*this,v);
2137  }
2138 
2139  friend int Lb(const sivector_slice&);
2140  friend int Ub(const sivector_slice&);
2141  friend srvector Inf(const sivector_slice&);
2142  friend srvector Sup(const sivector_slice&);
2143  friend sivector abs(const sivector_slice&);
2144  friend srvector mid(const sivector_slice&);
2145  friend srvector diam(const sivector_slice&);
2146  friend int VecLen(const sivector_slice&);
2147 
2148 // friend srvector operator*(const srmatrix&, const srvector_slice&); //ok
2149 // friend srvector operator*(const srmatrix_slice&, const srvector_slice&); //ok
2150 
2151  friend class srvector;
2152  friend class sivector;
2153  friend class scivector;
2154  friend class ivector;
2155  friend class ivector_slice;
2156  friend class civector;
2157  friend class civector_slice;
2158 
2159 #include "vector_friend_declarations.inl"
2160 };
2161 
2163  l = v.lb;
2164  u = v.ub;
2165  size = v.n;
2166  dat = new interval[v.n];
2167  for(int i=0 ; i<v.n ; i++)
2168  dat[i] = 0.0;
2169  for(int i=v.start ; i<=v.end ; i++)
2170  dat[v.p[i]] = v.x[i];
2171 }
2172 
2174  l = v.lb;
2175  u = v.ub;
2176  size = v.n;
2177  dat = new interval[v.n];
2178  for(int i=0 ; i<v.n ; i++)
2179  dat[i] = 0.0;
2180  for(int i=v.start ; i<=v.end ; i++)
2181  dat[v.p[i]] = v.x[i];
2182 }
2183 
2185  *this = rvector(v);
2186  return *this;
2187 }
2188 
2190  *this = rvector(v);
2191  return *this;
2192 }
2193 
2195  *this = ivector(v);
2196  return *this;
2197 }
2198 
2200  *this = ivector(v);
2201  return *this;
2202 }
2203 
2204 inline sivector::sivector(const srvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
2205  p.reserve(s.nnz);
2206  x.reserve(s.nnz);
2207 
2208  for(int i=s.start ; i<=s.end ; i++) {
2209  p.push_back(s.p[i]-s.offset);
2210  x.push_back(interval(s.x[i]));
2211  }
2212 
2213 }
2214 
2215 inline sivector::sivector(const sivector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
2216  p.reserve(s.nnz);
2217  x.reserve(s.nnz);
2218 
2219  for(int i=s.start ; i<=s.end ; i++) {
2220  p.push_back(s.p[i]-s.offset);
2221  x.push_back(s.x[i]);
2222  }
2223 
2224 }
2225 
2227  return spsl_vv_assign<sivector,srvector_slice,interval>(*this,v);
2228 }
2229 
2231  return spsl_vv_assign<sivector,sivector_slice,interval>(*this,v);
2232 }
2233 
2234 inline sivector_slice sivector::operator()(const int i, const int j) {
2235 #if(CXSC_INDEX_CHECK)
2236  if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator()(const int,const int)"));
2237 #endif
2238  return sivector_slice(*this,i,j);
2239 }
2240 
2242 inline sivector operator-(const sivector_slice& v) {
2243  return sl_v_negative<sivector_slice,sivector>(v);
2244 }
2245 
2247 inline int Lb(const sivector_slice& v) {
2248  return v.lb;
2249 }
2250 
2252 inline int Ub(const sivector_slice& v) {
2253  return v.ub;
2254 }
2255 
2257 inline srvector Inf(const sivector_slice& v) {
2258  return Inf(sivector(v));
2259 }
2260 
2262 inline srvector Sup(const sivector_slice& v) {
2263  return Sup(sivector(v));
2264 }
2265 
2267 inline sivector abs(const sivector_slice& v) {
2268  sivector res(v.n, v.nnz);
2269  res.lb = v.lb;
2270  res.ub = v.ub;
2271  res.p = v.p;
2272  for(int i=v.start ; i<=v.end ; i++)
2273  res.x.push_back(abs(v.x[i]));
2274  return res;
2275 }
2276 
2278 inline srvector mid(const sivector_slice& v) {
2279  srvector res(v.n, v.nnz);
2280  res.lb = v.lb;
2281  res.ub = v.ub;
2282  res.p = v.p;
2283  for(int i=v.start ; i<=v.end ; i++)
2284  res.x.push_back(mid(v.x[i]));
2285  return res;
2286 }
2287 
2289 inline srvector diam(const sivector_slice& v) {
2290  srvector res(v.n, v.nnz);
2291  res.lb = v.lb;
2292  res.ub = v.ub;
2293  res.p = v.p;
2294  for(int i=v.start ; i<v.end ; i++)
2295  res.x.push_back(diam(v.x[i]));
2296  return res;
2297 }
2298 
2300 inline int VecLen(const sivector_slice& v) {
2301  return v.n;
2302 }
2303 
2305 
2311 inline interval operator*(const sivector_slice& v1, const rvector& v2) {
2312  return slf_vv_mult<sivector_slice,rvector,interval,sparse_idot>(v1,v2);
2313 }
2314 
2316 
2322 inline interval operator*(const srvector_slice& v1, const ivector& v2) {
2323  return slf_vv_mult<srvector_slice,ivector,interval,sparse_idot>(v1,v2);
2324 }
2325 
2327 
2333 inline interval operator*(const sivector_slice& v1, const ivector& v2) {
2334  return slf_vv_mult<sivector_slice,ivector,interval,sparse_idot>(v1,v2);
2335 }
2336 
2338 
2344 inline interval operator*(const ivector& v1, const srvector_slice& v2) {
2345  return fsl_vv_mult<ivector,srvector_slice,interval,sparse_idot>(v1,v2);
2346 }
2347 
2349 
2355 inline interval operator*(const rvector& v1, const sivector_slice& v2) {
2356  return fsl_vv_mult<rvector,sivector_slice,interval,sparse_idot>(v1,v2);
2357 }
2358 
2360 
2366 inline interval operator*(const ivector& v1, const sivector_slice& v2) {
2367  return fsl_vv_mult<ivector,sivector_slice,interval,sparse_idot>(v1,v2);
2368 }
2369 
2371 
2377 inline interval operator*(const sivector_slice& v1, const rvector_slice& v2) {
2378  return slf_vv_mult<sivector_slice,rvector_slice,interval,sparse_idot>(v1,v2);
2379 }
2380 
2382 
2388 inline interval operator*(const srvector_slice& v1, const ivector_slice& v2) {
2389  return slf_vv_mult<srvector_slice,ivector_slice,interval,sparse_idot>(v1,v2);
2390 }
2391 
2393 
2399 inline interval operator*(const sivector_slice& v1, const ivector_slice& v2) {
2400  return slf_vv_mult<sivector_slice,ivector_slice,interval,sparse_idot>(v1,v2);
2401 }
2402 
2404 
2410 inline interval operator*(const ivector_slice& v1, const srvector_slice& v2) {
2411  return fsl_vv_mult<ivector_slice,srvector_slice,interval,sparse_idot>(v1,v2);
2412 }
2413 
2415 
2421 inline interval operator*(const rvector_slice& v1, const sivector_slice& v2) {
2422  return fsl_vv_mult<rvector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
2423 }
2424 
2426 
2432 inline interval operator*(const ivector_slice& v1, const sivector_slice& v2) {
2433  return fsl_vv_mult<ivector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
2434 }
2435 
2437 
2443 inline interval operator*(const sivector& v1, const srvector_slice& v2) {
2444  return spsl_vv_mult<sivector,srvector_slice,interval,sparse_idot>(v1,v2);
2445 }
2446 
2448 
2454 inline interval operator*(const srvector& v1, const sivector_slice& v2) {
2455  return spsl_vv_mult<srvector,sivector_slice,interval,sparse_idot>(v1,v2);
2456 }
2457 
2459 
2465 inline interval operator*(const sivector& v1, const sivector_slice& v2) {
2466  return spsl_vv_mult<sivector,sivector_slice,interval,sparse_idot>(v1,v2);
2467 }
2468 
2470 
2476 inline interval operator*(const sivector_slice& v1, const srvector& v2) {
2477  return slsp_vv_mult<sivector_slice,srvector,interval,sparse_idot>(v1,v2);
2478 }
2479 
2481 
2487 inline interval operator*(const srvector_slice& v1, const sivector& v2) {
2488  return slsp_vv_mult<srvector_slice,sivector,interval,sparse_idot>(v1,v2);
2489 }
2490 
2492 
2498 inline interval operator*(const sivector_slice& v1, const sivector& v2) {
2499  return slsp_vv_mult<sivector_slice,sivector,interval,sparse_idot>(v1,v2);
2500 }
2501 
2503 
2509 inline interval operator*(const sivector_slice& v1, const srvector_slice& v2) {
2510  return slsl_vv_mult<sivector_slice,srvector_slice,interval,sparse_idot>(v1,v2);
2511 }
2512 
2514 
2520 inline interval operator*(const srvector_slice& v1, const sivector_slice& v2) {
2521  return slsl_vv_mult<srvector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
2522 }
2523 
2525 
2531 inline interval operator*(const sivector_slice& v1, const sivector_slice& v2) {
2532  return slsl_vv_mult<sivector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
2533 }
2534 
2536 inline sivector operator*(const sivector_slice& v, const real& s) {
2537  return sp_vs_mult<sivector_slice,real,sivector>(v,s);
2538 }
2539 
2541 inline sivector operator*(const sivector_slice& v, const interval& s) {
2542  return sp_vs_mult<sivector_slice,interval,sivector>(v,s);
2543 }
2544 
2546 inline sivector operator*(const srvector_slice& v, const interval& s) {
2547  return sp_vs_mult<srvector_slice,interval,sivector>(v,s);
2548 }
2549 
2551 inline sivector operator/(const sivector_slice& v, const real& s) {
2552  return sp_vs_div<sivector_slice,real,sivector>(v,s);
2553 }
2554 
2556 inline sivector operator/(const sivector_slice& v, const interval& s) {
2557  return sp_vs_div<sivector_slice,interval,sivector>(v,s);
2558 }
2559 
2561 inline sivector operator/(const srvector_slice& v, const interval& s) {
2562  return sp_vs_div<srvector_slice,interval,sivector>(v,s);
2563 }
2564 
2566 inline sivector operator*(const real& s, const sivector_slice& v) {
2567  return sp_sv_mult<real,sivector_slice,sivector>(s,v);
2568 }
2569 
2571 inline sivector operator*(const interval& s, const sivector_slice& v) {
2572  return sp_sv_mult<interval,sivector_slice,sivector>(s,v);
2573 }
2574 
2576 inline sivector operator*(const interval& s, const srvector_slice& v) {
2577  return sp_sv_mult<interval,srvector_slice,sivector>(s,v);
2578 }
2579 
2581 inline ivector operator+(const ivector& v1, const srvector_slice& v2) {
2582  return fsl_vv_add<ivector,srvector_slice,ivector>(v1,v2);
2583 }
2584 
2586 inline ivector operator+(const rvector& v1, const sivector_slice& v2) {
2587  return fsl_vv_add<rvector,sivector_slice,ivector>(v1,v2);
2588 }
2589 
2591 inline ivector operator+(const ivector& v1, const sivector_slice& v2) {
2592  return fsl_vv_add<ivector,sivector_slice,ivector>(v1,v2);
2593 }
2594 
2596 inline ivector operator+(const sivector_slice& v1, const rvector& v2) {
2597  return slf_vv_add<sivector_slice,rvector,ivector>(v1,v2);
2598 }
2599 
2601 inline ivector operator+(const srvector_slice& v1, const ivector& v2) {
2602  return slf_vv_add<srvector_slice,ivector,ivector>(v1,v2);
2603 }
2604 
2606 inline ivector operator+(const sivector_slice& v1, const ivector& v2) {
2607  return slf_vv_add<sivector_slice,ivector,ivector>(v1,v2);
2608 }
2609 
2611 inline ivector operator+(const ivector_slice& v1, const srvector_slice& v2) {
2612  return fsl_vv_add<ivector_slice,srvector_slice,ivector>(v1,v2);
2613 }
2614 
2616 inline ivector operator+(const rvector_slice& v1, const sivector_slice& v2) {
2617  return fsl_vv_add<rvector_slice,sivector_slice,ivector>(v1,v2);
2618 }
2619 
2621 inline ivector operator+(const ivector_slice& v1, const sivector_slice& v2) {
2622  return fsl_vv_add<ivector_slice,sivector_slice,ivector>(v1,v2);
2623 }
2624 
2626 inline ivector operator+(const sivector_slice& v1, const rvector_slice& v2) {
2627  return slf_vv_add<sivector_slice,rvector_slice,ivector>(v1,v2);
2628 }
2629 
2631 inline ivector operator+(const srvector_slice& v1, const ivector_slice& v2) {
2632  return slf_vv_add<srvector_slice,ivector_slice,ivector>(v1,v2);
2633 }
2634 
2636 inline ivector operator+(const sivector_slice& v1, const ivector_slice& v2) {
2637  return slf_vv_add<sivector_slice,ivector_slice,ivector>(v1,v2);
2638 }
2639 
2641 inline sivector operator+(const sivector_slice& v1, const srvector_slice& v2) {
2642  return slsl_vv_add<sivector_slice,srvector_slice,sivector,interval>(v1,v2);
2643 }
2644 
2646 inline sivector operator+(const srvector_slice& v1, const sivector_slice& v2) {
2647  return slsl_vv_add<srvector_slice,sivector_slice,sivector,interval>(v1,v2);
2648 }
2649 
2651 inline sivector operator+(const sivector_slice& v1, const sivector_slice& v2) {
2652  return slsl_vv_add<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
2653 }
2654 
2656 inline sivector operator+(const sivector& v1, const srvector_slice& v2) {
2657  return spsl_vv_add<sivector,srvector_slice,sivector,interval>(v1,v2);
2658 }
2659 
2661 inline sivector operator+(const srvector& v1, const sivector_slice& v2) {
2662  return spsl_vv_add<srvector,sivector_slice,sivector,interval>(v1,v2);
2663 }
2664 
2666 inline sivector operator+(const sivector& v1, const sivector_slice& v2) {
2667  return spsl_vv_add<sivector,sivector_slice,sivector,interval>(v1,v2);
2668 }
2669 
2671 inline sivector operator+(const sivector_slice& v1, const srvector& v2) {
2672  return slsp_vv_add<sivector_slice,srvector,sivector,interval>(v1,v2);
2673 }
2674 
2676 inline sivector operator+(const srvector_slice& v1, const sivector& v2) {
2677  return slsp_vv_add<srvector_slice,sivector,sivector,interval>(v1,v2);
2678 }
2679 
2681 inline sivector operator+(const sivector_slice& v1, const sivector& v2) {
2682  return slsp_vv_add<sivector_slice,sivector,sivector,interval>(v1,v2);
2683 }
2684 
2686 inline ivector operator-(const ivector& v1, const srvector_slice& v2) {
2687  return fsl_vv_sub<ivector,srvector_slice,ivector>(v1,v2);
2688 }
2689 
2691 inline ivector operator-(const rvector& v1, const sivector_slice& v2) {
2692  return fsl_vv_sub<rvector,sivector_slice,ivector>(v1,v2);
2693 }
2694 
2696 inline ivector operator-(const ivector& v1, const sivector_slice& v2) {
2697  return fsl_vv_sub<ivector,sivector_slice,ivector>(v1,v2);
2698 }
2699 
2701 inline ivector operator-(const sivector_slice& v1, const rvector& v2) {
2702  return slf_vv_sub<sivector_slice,rvector,ivector>(v1,v2);
2703 }
2704 
2706 inline ivector operator-(const srvector_slice& v1, const ivector& v2) {
2707  return slf_vv_sub<srvector_slice,ivector,ivector>(v1,v2);
2708 }
2709 
2711 inline ivector operator-(const sivector_slice& v1, const ivector& v2) {
2712  return slf_vv_sub<sivector_slice,ivector,ivector>(v1,v2);
2713 }
2714 
2716 inline ivector operator-(const ivector_slice& v1, const srvector_slice& v2) {
2717  return fsl_vv_sub<ivector_slice,srvector_slice,ivector>(v1,v2);
2718 }
2719 
2721 inline ivector operator-(const rvector_slice& v1, const sivector_slice& v2) {
2722  return fsl_vv_sub<rvector_slice,sivector_slice,ivector>(v1,v2);
2723 }
2724 
2726 inline ivector operator-(const ivector_slice& v1, const sivector_slice& v2) {
2727  return fsl_vv_sub<ivector_slice,sivector_slice,ivector>(v1,v2);
2728 }
2729 
2731 inline ivector operator-(const sivector_slice& v1, const rvector_slice& v2) {
2732  return slf_vv_sub<sivector_slice,rvector_slice,ivector>(v1,v2);
2733 }
2734 
2736 inline ivector operator-(const srvector_slice& v1, const ivector_slice& v2) {
2737  return slf_vv_sub<srvector_slice,ivector_slice,ivector>(v1,v2);
2738 }
2739 
2741 inline ivector operator-(const sivector_slice& v1, const ivector_slice& v2) {
2742  return slf_vv_sub<sivector_slice,ivector_slice,ivector>(v1,v2);
2743 }
2744 
2746 inline sivector operator-(const sivector_slice& v1, const srvector_slice& v2) {
2747  return slsl_vv_sub<sivector_slice,srvector_slice,sivector,interval>(v1,v2);
2748 }
2749 
2751 inline sivector operator-(const srvector_slice& v1, const sivector_slice& v2) {
2752  return slsl_vv_sub<srvector_slice,sivector_slice,sivector,interval>(v1,v2);
2753 }
2754 
2756 inline sivector operator-(const sivector_slice& v1, const sivector_slice& v2) {
2757  return slsl_vv_sub<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
2758 }
2759 
2761 inline sivector operator-(const sivector& v1, const srvector_slice& v2) {
2762  return spsl_vv_sub<sivector,srvector_slice,sivector,interval>(v1,v2);
2763 }
2764 
2766 inline sivector operator-(const srvector& v1, const sivector_slice& v2) {
2767  return spsl_vv_sub<srvector,sivector_slice,sivector,interval>(v1,v2);
2768 }
2769 
2771 inline sivector operator-(const sivector& v1, const sivector_slice& v2) {
2772  return spsl_vv_sub<sivector,sivector_slice,sivector,interval>(v1,v2);
2773 }
2774 
2776 inline sivector operator-(const sivector_slice& v1, const srvector& v2) {
2777  return slsp_vv_sub<sivector_slice,srvector,sivector,interval>(v1,v2);
2778 }
2779 
2781 inline sivector operator-(const srvector_slice& v1, const sivector& v2) {
2782  return slsp_vv_sub<srvector_slice,sivector,sivector,interval>(v1,v2);
2783 }
2784 
2786 inline sivector operator-(const sivector_slice& v1, const sivector& v2) {
2787  return slsp_vv_sub<sivector_slice,sivector,sivector,interval>(v1,v2);
2788 }
2789 
2791 inline ivector operator|(const rvector& v1, const srvector_slice& v2) {
2792  return fsl_vv_hull<rvector,srvector_slice,ivector>(v1,v2);
2793 }
2794 
2796 inline ivector operator|(const srvector_slice& v1, const rvector& v2) {
2797  return slf_vv_hull<srvector_slice,rvector,ivector>(v1,v2);
2798 }
2799 
2801 inline ivector operator|(const rvector_slice& v1, const srvector_slice& v2) {
2802  return fsl_vv_hull<rvector_slice,srvector_slice,ivector>(v1,v2);
2803 }
2804 
2806 inline ivector operator|(const srvector_slice& v1, const rvector_slice& v2) {
2807  return slf_vv_hull<srvector_slice,rvector_slice,ivector>(v1,v2);
2808 }
2809 
2811 inline sivector operator|(const srvector_slice& v1, const srvector_slice& v2) {
2812  return slsl_vv_hull<srvector_slice,srvector_slice,sivector,interval>(v1,v2);
2813 }
2814 
2816 inline sivector operator|(const srvector& v1, const srvector_slice& v2) {
2817  return spsl_vv_hull<srvector,srvector_slice,sivector,interval>(v1,v2);
2818 }
2819 
2821 inline sivector operator|(const srvector_slice& v1, const srvector& v2) {
2822  return slsp_vv_hull<srvector_slice,srvector,sivector,interval>(v1,v2);
2823 }
2824 
2826 inline ivector operator|(const ivector& v1, const srvector_slice& v2) {
2827  return fsl_vv_hull<ivector,srvector_slice,ivector>(v1,v2);
2828 }
2829 
2831 inline ivector operator|(const rvector& v1, const sivector_slice& v2) {
2832  return fsl_vv_hull<rvector,sivector_slice,ivector>(v1,v2);
2833 }
2834 
2836 inline ivector operator|(const ivector& v1, const sivector_slice& v2) {
2837  return fsl_vv_hull<ivector,sivector_slice,ivector>(v1,v2);
2838 }
2839 
2841 inline ivector operator|(const sivector_slice& v1, const rvector& v2) {
2842  return slf_vv_hull<sivector_slice,rvector,ivector>(v1,v2);
2843 }
2844 
2846 inline ivector operator|(const srvector_slice& v1, const ivector& v2) {
2847  return slf_vv_hull<srvector_slice,ivector,ivector>(v1,v2);
2848 }
2849 
2851 inline ivector operator|(const sivector_slice& v1, const ivector& v2) {
2852  return slf_vv_hull<sivector_slice,ivector,ivector>(v1,v2);
2853 }
2854 
2856 inline ivector operator|(const ivector_slice& v1, const srvector_slice& v2) {
2857  return fsl_vv_hull<ivector_slice,srvector_slice,ivector>(v1,v2);
2858 }
2859 
2861 inline ivector operator|(const rvector_slice& v1, const sivector_slice& v2) {
2862  return fsl_vv_hull<rvector_slice,sivector_slice,ivector>(v1,v2);
2863 }
2864 
2866 inline ivector operator|(const ivector_slice& v1, const sivector_slice& v2) {
2867  return fsl_vv_hull<ivector_slice,sivector_slice,ivector>(v1,v2);
2868 }
2869 
2871 inline ivector operator|(const sivector_slice& v1, const rvector_slice& v2) {
2872  return slf_vv_hull<sivector_slice,rvector_slice,ivector>(v1,v2);
2873 }
2874 
2876 inline ivector operator|(const srvector_slice& v1, const ivector_slice& v2) {
2877  return slf_vv_hull<srvector_slice,ivector_slice,ivector>(v1,v2);
2878 }
2879 
2881 inline ivector operator|(const sivector_slice& v1, const ivector_slice& v2) {
2882  return slf_vv_hull<sivector_slice,ivector_slice,ivector>(v1,v2);
2883 }
2884 
2886 inline sivector operator|(const sivector_slice& v1, const srvector_slice& v2) {
2887  return slsl_vv_hull<sivector_slice,srvector_slice,sivector,interval>(v1,v2);
2888 }
2889 
2891 inline sivector operator|(const srvector_slice& v1, const sivector_slice& v2) {
2892  return slsl_vv_hull<srvector_slice,sivector_slice,sivector,interval>(v1,v2);
2893 }
2894 
2896 inline sivector operator|(const sivector_slice& v1, const sivector_slice& v2) {
2897  return slsl_vv_hull<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
2898 }
2899 
2901 inline sivector operator|(const sivector& v1, const srvector_slice& v2) {
2902  return spsl_vv_hull<sivector,srvector_slice,sivector,interval>(v1,v2);
2903 }
2904 
2906 inline sivector operator|(const srvector& v1, const sivector_slice& v2) {
2907  return spsl_vv_hull<srvector,sivector_slice,sivector,interval>(v1,v2);
2908 }
2909 
2911 inline sivector operator|(const sivector& v1, const sivector_slice& v2) {
2912  return spsl_vv_hull<sivector,sivector_slice,sivector,interval>(v1,v2);
2913 }
2914 
2916 inline sivector operator|(const sivector_slice& v1, const srvector& v2) {
2917  return slsp_vv_hull<sivector_slice,srvector,sivector,interval>(v1,v2);
2918 }
2919 
2921 inline sivector operator|(const srvector_slice& v1, const sivector& v2) {
2922  return slsp_vv_hull<srvector_slice,sivector,sivector,interval>(v1,v2);
2923 }
2924 
2926 inline sivector operator|(const sivector_slice& v1, const sivector& v2) {
2927  return slsp_vv_hull<sivector_slice,sivector,sivector,interval>(v1,v2);
2928 }
2929 
2931 inline ivector operator&(const ivector& v1, const sivector_slice& v2) {
2932  return fsl_vv_intersect<ivector,sivector_slice,ivector>(v1,v2);
2933 }
2934 
2936 inline ivector operator&(const sivector_slice& v1, const ivector& v2) {
2937  return slf_vv_intersect<sivector_slice,ivector,ivector>(v1,v2);
2938 }
2939 
2941 inline ivector operator&(const ivector_slice& v1, const sivector_slice& v2) {
2942  return fsl_vv_intersect<ivector_slice,sivector_slice,ivector>(v1,v2);
2943 }
2944 
2946 inline ivector operator&(const sivector_slice& v1, const ivector_slice& v2) {
2947  return slf_vv_intersect<sivector_slice,ivector_slice,ivector>(v1,v2);
2948 }
2949 
2951 inline sivector operator&(const sivector_slice& v1, const sivector_slice& v2) {
2952  return slsl_vv_intersect<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
2953 }
2954 
2956 inline sivector operator&(const sivector& v1, const sivector_slice& v2) {
2957  return spsl_vv_intersect<sivector,sivector_slice,sivector,interval>(v1,v2);
2958 }
2959 
2961 inline sivector operator&(const sivector_slice& v1, const sivector& v2) {
2962  return slsp_vv_intersect<sivector_slice,sivector,sivector,interval>(v1,v2);
2963 }
2964 
2966  return fsl_vv_addassign(*this,v2);
2967 }
2968 
2970  return fsl_vv_addassign(*this,v2);
2971 }
2972 
2974  return fsl_vv_addassign(*this,v2);
2975 }
2976 
2978  return fsl_vv_addassign(*this,v2);
2979 }
2980 
2982  return spsl_vv_addassign(*this,v2);
2983 }
2984 
2986  return spsl_vv_addassign(*this,v2);
2987 }
2988 
2990  return fsl_vv_subassign(*this,v2);
2991 }
2992 
2994  return fsl_vv_subassign(*this,v2);
2995 }
2996 
2998  return fsl_vv_subassign(*this,v2);
2999 }
3000 
3002  return fsl_vv_subassign(*this,v2);
3003 }
3004 
3006  return spsl_vv_subassign(*this,v2);
3007 }
3008 
3010  return spsl_vv_subassign(*this,v2);
3011 }
3012 
3014  return fsl_vv_hullassign(*this,v2);
3015 }
3016 
3018  return fsl_vv_hullassign(*this,v2);
3019 }
3020 
3022  return fsl_vv_hullassign(*this,v2);
3023 }
3024 
3026  return fsl_vv_hullassign(*this,v2);
3027 }
3028 
3030  return fsl_vv_intersectassign(*this,v2);
3031 }
3032 
3034  return fsl_vv_intersectassign(*this,v2);
3035 }
3036 
3038 
3041 inline bool operator==(const sivector_slice& v1, const srvector_slice& v2) {
3042  return slsl_vv_comp(v1,v2);
3043 }
3044 
3046 
3049 inline bool operator==(const srvector_slice& v1, const sivector_slice& v2) {
3050  return slsl_vv_comp(v1,v2);
3051 }
3052 
3054 
3057 inline bool operator==(const sivector_slice& v1, const sivector_slice& v2) {
3058  return slsl_vv_comp(v1,v2);
3059 }
3060 
3062 
3065 inline bool operator==(const sivector_slice& v1, const srvector& v2) {
3066  return slsp_vv_comp(v1,v2);
3067 }
3068 
3070 
3073 inline bool operator==(const srvector_slice& v1, const sivector& v2) {
3074  return slsp_vv_comp(v1,v2);
3075 }
3076 
3078 
3081 inline bool operator==(const sivector_slice& v1, const sivector& v2) {
3082  return slsp_vv_comp(v1,v2);
3083 }
3084 
3086 
3089 inline bool operator==(const sivector& v1, const srvector_slice& v2) {
3090  return spsl_vv_comp(v1,v2);
3091 }
3092 
3094 
3097 inline bool operator==(const srvector& v1, const sivector_slice& v2) {
3098  return spsl_vv_comp(v1,v2);
3099 }
3100 
3102 
3105 inline bool operator==(const sivector& v1, const sivector_slice& v2) {
3106  return spsl_vv_comp(v1,v2);
3107 }
3108 
3110 
3113 inline bool operator==(const sivector_slice& v1, const rvector& v2) {
3114  return slf_vv_comp(v1,v2);
3115 }
3116 
3118 
3121 inline bool operator==(const srvector_slice& v1, const ivector& v2) {
3122  return slf_vv_comp(v1,v2);
3123 }
3124 
3126 
3129 inline bool operator==(const sivector_slice& v1, const ivector& v2) {
3130  return slf_vv_comp(v1,v2);
3131 }
3132 
3134 
3137 inline bool operator==(const ivector& v1, const srvector_slice& v2) {
3138  return fsl_vv_comp(v1,v2);
3139 }
3140 
3142 
3145 inline bool operator==(const rvector& v1, const sivector_slice& v2) {
3146  return fsl_vv_comp(v1,v2);
3147 }
3148 
3150 
3153 inline bool operator==(const ivector& v1, const sivector_slice& v2) {
3154  return fsl_vv_comp(v1,v2);
3155 }
3156 
3158 
3161 inline bool operator==(const sivector_slice& v1, const rvector_slice& v2) {
3162  return slf_vv_comp(v1,v2);
3163 }
3164 
3166 
3169 inline bool operator==(const srvector_slice& v1, const ivector_slice& v2) {
3170  return slf_vv_comp(v1,v2);
3171 }
3172 
3174 
3177 inline bool operator==(const sivector_slice& v1, const ivector_slice& v2) {
3178  return slf_vv_comp(v1,v2);
3179 }
3180 
3182 
3185 inline bool operator==(const ivector_slice& v1, const srvector_slice& v2) {
3186  return fsl_vv_comp(v1,v2);
3187 }
3188 
3190 
3193 inline bool operator==(const rvector_slice& v1, const sivector_slice& v2) {
3194  return fsl_vv_comp(v1,v2);
3195 }
3196 
3198 
3201 inline bool operator==(const ivector_slice& v1, const sivector_slice& v2) {
3202  return fsl_vv_comp(v1,v2);
3203 }
3204 
3206 
3209 inline bool operator!=(const sivector_slice& v1, const srvector_slice& v2) {
3210  return !slsl_vv_comp(v1,v2);
3211 }
3212 
3214 
3217 inline bool operator!=(const srvector_slice& v1, const sivector_slice& v2) {
3218  return !slsl_vv_comp(v1,v2);
3219 }
3220 
3222 
3225 inline bool operator!=(const sivector_slice& v1, const sivector_slice& v2) {
3226  return !slsl_vv_comp(v1,v2);
3227 }
3228 
3230 
3233 inline bool operator!=(const sivector_slice& v1, const rvector& v2) {
3234  return !slf_vv_comp(v1,v2);
3235 }
3236 
3238 
3241 inline bool operator!=(const srvector_slice& v1, const ivector& v2) {
3242  return !slf_vv_comp(v1,v2);
3243 }
3244 
3246 
3249 inline bool operator!=(const sivector_slice& v1, const ivector& v2) {
3250  return !slf_vv_comp(v1,v2);
3251 }
3252 
3254 
3257 inline bool operator!=(const ivector& v1, const srvector_slice& v2) {
3258  return !fsl_vv_comp(v1,v2);
3259 }
3260 
3262 
3265 inline bool operator!=(const rvector& v1, const sivector_slice& v2) {
3266  return !fsl_vv_comp(v1,v2);
3267 }
3268 
3270 
3273 inline bool operator!=(const ivector& v1, const sivector_slice& v2) {
3274  return !fsl_vv_comp(v1,v2);
3275 }
3276 
3278 
3281 inline bool operator!=(const sivector_slice& v1, const srvector& v2) {
3282  return !slsp_vv_comp(v1,v2);
3283 }
3284 
3286 
3289 inline bool operator!=(const srvector_slice& v1, const sivector& v2) {
3290  return !slsp_vv_comp(v1,v2);
3291 }
3292 
3294 
3297 inline bool operator!=(const sivector_slice& v1, const sivector& v2) {
3298  return !slsp_vv_comp(v1,v2);
3299 }
3300 
3302 
3305 inline bool operator!=(const sivector& v1, const srvector_slice& v2) {
3306  return !spsl_vv_comp(v1,v2);
3307 }
3308 
3310 
3313 inline bool operator!=(const srvector& v1, const sivector_slice& v2) {
3314  return !spsl_vv_comp(v1,v2);
3315 }
3316 
3318 
3321 inline bool operator!=(const sivector& v1, const sivector_slice& v2) {
3322  return !spsl_vv_comp(v1,v2);
3323 }
3324 
3326 
3329 inline bool operator!=(const sivector_slice& v1, const rvector_slice& v2) {
3330  return !slf_vv_comp(v1,v2);
3331 }
3332 
3334 
3337 inline bool operator!=(const srvector_slice& v1, const ivector_slice& v2) {
3338  return !slf_vv_comp(v1,v2);
3339 }
3340 
3342 
3345 inline bool operator!=(const sivector_slice& v1, const ivector_slice& v2) {
3346  return !slf_vv_comp(v1,v2);
3347 }
3348 
3350 
3353 inline bool operator!=(const ivector_slice& v1, const srvector_slice& v2) {
3354  return !fsl_vv_comp(v1,v2);
3355 }
3356 
3358 
3361 inline bool operator!=(const rvector_slice& v1, const sivector_slice& v2) {
3362  return !fsl_vv_comp(v1,v2);
3363 }
3364 
3366 
3369 inline bool operator!=(const ivector_slice& v1, const sivector_slice& v2) {
3370  return !fsl_vv_comp(v1,v2);
3371 }
3372 
3374 
3377 inline bool operator<(const srvector_slice& v1, const sivector_slice& v2) {
3378  return slsl_vv_less<srvector_slice,sivector_slice,interval>(v1,v2);
3379 }
3380 
3382 
3385 inline bool operator<(const sivector_slice& v1, const sivector_slice& v2) {
3386  return slsl_vv_less<sivector_slice,sivector_slice,interval>(v1,v2);
3387 }
3388 
3390 
3393 inline bool operator<(const srvector_slice& v1, const sivector& v2) {
3394  return slsp_vv_less<srvector_slice,sivector,interval>(v1,v2);
3395 }
3396 
3398 
3401 inline bool operator<(const sivector_slice& v1, const sivector& v2) {
3402  return slsp_vv_less<sivector_slice,sivector,interval>(v1,v2);
3403 }
3404 
3406 
3409 inline bool operator<(const srvector& v1, const sivector_slice& v2) {
3410  return spsl_vv_less<srvector,sivector_slice,interval>(v1,v2);
3411 }
3412 
3414 
3417 inline bool operator<(const sivector& v1, const sivector_slice& v2) {
3418  return spsl_vv_less<sivector,sivector_slice,interval>(v1,v2);
3419 }
3420 
3422 
3425 inline bool operator<(const srvector_slice& v1, const ivector& v2) {
3426  return slf_vv_less<srvector_slice,ivector,interval>(v1,v2);
3427 }
3428 
3430 
3433 inline bool operator<(const sivector_slice& v1, const ivector& v2) {
3434  return slf_vv_less<sivector_slice,ivector,interval>(v1,v2);
3435 }
3436 
3438 
3441 inline bool operator<(const rvector& v1, const sivector_slice& v2) {
3442  return fsl_vv_less<rvector,sivector_slice,interval>(v1,v2);
3443 }
3444 
3446 
3449 inline bool operator<(const ivector& v1, const sivector_slice& v2) {
3450  return fsl_vv_less<ivector,sivector_slice,interval>(v1,v2);
3451 }
3452 
3454 
3457 inline bool operator<(const srvector_slice& v1, const ivector_slice& v2) {
3458  return slf_vv_less<srvector_slice,ivector_slice,interval>(v1,v2);
3459 }
3460 
3462 
3465 inline bool operator<(const sivector_slice& v1, const ivector_slice& v2) {
3466  return slf_vv_less<sivector_slice,ivector_slice,interval>(v1,v2);
3467 }
3468 
3470 
3473 inline bool operator<(const rvector_slice& v1, const sivector_slice& v2) {
3474  return fsl_vv_less<rvector_slice,sivector_slice,interval>(v1,v2);
3475 }
3476 
3478 
3481 inline bool operator<(const ivector_slice& v1, const sivector_slice& v2) {
3482  return fsl_vv_less<ivector_slice,sivector_slice,interval>(v1,v2);
3483 }
3484 
3486 
3489 inline bool operator<=(const sivector_slice& v1, const sivector_slice& v2) {
3490  return slsl_vv_leq<sivector_slice,sivector_slice,interval>(v1,v2);
3491 }
3492 
3494 
3497 inline bool operator<=(const srvector_slice& v1, const sivector& v2) {
3498  return slsp_vv_leq<srvector_slice,sivector,interval>(v1,v2);
3499 }
3500 
3502 
3505 inline bool operator<=(const sivector_slice& v1, const sivector& v2) {
3506  return slsp_vv_leq<sivector_slice,sivector,interval>(v1,v2);
3507 }
3508 
3510 
3513 inline bool operator<=(const srvector& v1, const sivector_slice& v2) {
3514  return spsl_vv_leq<srvector,sivector_slice,interval>(v1,v2);
3515 }
3516 
3518 
3521 inline bool operator<=(const sivector& v1, const sivector_slice& v2) {
3522  return spsl_vv_leq<sivector,sivector_slice,interval>(v1,v2);
3523 }
3524 
3526 
3529 inline bool operator<=(const srvector_slice& v1, const ivector& v2) {
3530  return slf_vv_leq<srvector_slice,ivector,interval>(v1,v2);
3531 }
3532 
3534 
3537 inline bool operator<=(const sivector_slice& v1, const ivector& v2) {
3538  return slf_vv_leq<sivector_slice,ivector,interval>(v1,v2);
3539 }
3540 
3542 
3545 inline bool operator<=(const rvector& v1, const sivector_slice& v2) {
3546  return fsl_vv_leq<rvector,sivector_slice,interval>(v1,v2);
3547 }
3548 
3550 
3553 inline bool operator<=(const ivector& v1, const sivector_slice& v2) {
3554  return fsl_vv_leq<ivector,sivector_slice,interval>(v1,v2);
3555 }
3556 
3558 
3561 inline bool operator<=(const srvector_slice& v1, const ivector_slice& v2) {
3562  return slf_vv_leq<srvector_slice,ivector_slice,interval>(v1,v2);
3563 }
3564 
3566 
3569 inline bool operator<=(const sivector_slice& v1, const ivector_slice& v2) {
3570  return slf_vv_leq<sivector_slice,ivector_slice,interval>(v1,v2);
3571 }
3572 
3574 
3577 inline bool operator<=(const rvector_slice& v1, const sivector_slice& v2) {
3578  return fsl_vv_leq<rvector_slice,sivector_slice,interval>(v1,v2);
3579 }
3580 
3582 
3585 inline bool operator<=(const ivector_slice& v1, const sivector_slice& v2) {
3586  return fsl_vv_leq<ivector_slice,sivector_slice,interval>(v1,v2);
3587 }
3588 
3590 
3593 inline bool operator>(const sivector_slice& v1, const srvector_slice& v2) {
3594  return slsl_vv_greater<sivector_slice,srvector_slice,interval>(v1,v2);
3595 }
3596 
3598 
3601 inline bool operator>(const sivector_slice& v1, const sivector_slice& v2) {
3602  return slsl_vv_greater<sivector_slice,sivector_slice,interval>(v1,v2);
3603 }
3604 
3606 
3609 inline bool operator>(const sivector_slice& v1, const srvector& v2) {
3610  return slsp_vv_greater<sivector_slice,srvector,interval>(v1,v2);
3611 }
3612 
3614 
3617 inline bool operator>(const sivector_slice& v1, const sivector& v2) {
3618  return slsp_vv_greater<sivector_slice,sivector,interval>(v1,v2);
3619 }
3620 
3622 
3625 inline bool operator>(const sivector& v1, const srvector_slice& v2) {
3626  return spsl_vv_greater<sivector,srvector_slice,interval>(v1,v2);
3627 }
3628 
3630 
3633 inline bool operator>(const sivector& v1, const sivector_slice& v2) {
3634  return spsl_vv_greater<sivector,sivector_slice,interval>(v1,v2);
3635 }
3636 
3638 
3641 inline bool operator>(const sivector_slice& v1, const rvector& v2) {
3642  return slf_vv_greater<sivector_slice,rvector,interval>(v1,v2);
3643 }
3644 
3646 
3649 inline bool operator>(const sivector_slice& v1, const ivector& v2) {
3650  return slf_vv_greater<sivector_slice,ivector,interval>(v1,v2);
3651 }
3652 
3654 
3657 inline bool operator>(const ivector& v1, const srvector_slice& v2) {
3658  return fsl_vv_greater<ivector,srvector_slice,interval>(v1,v2);
3659 }
3660 
3662 
3665 inline bool operator>(const ivector& v1, const sivector_slice& v2) {
3666  return fsl_vv_greater<ivector,sivector_slice,interval>(v1,v2);
3667 }
3668 
3670 
3673 inline bool operator>(const sivector_slice& v1, const rvector_slice& v2) {
3674  return slf_vv_greater<sivector_slice,rvector_slice,interval>(v1,v2);
3675 }
3676 
3678 
3681 inline bool operator>(const sivector_slice& v1, const ivector_slice& v2) {
3682  return slf_vv_greater<sivector_slice,ivector_slice,interval>(v1,v2);
3683 }
3684 
3686 
3689 inline bool operator>(const ivector_slice& v1, const srvector_slice& v2) {
3690  return fsl_vv_greater<ivector_slice,srvector_slice,interval>(v1,v2);
3691 }
3692 
3694 
3697 inline bool operator>(const ivector_slice& v1, const sivector_slice& v2) {
3698  return fsl_vv_greater<ivector_slice,sivector_slice,interval>(v1,v2);
3699 }
3700 
3702 
3705 inline bool operator>=(const sivector_slice& v1, const srvector_slice& v2) {
3706  return slsl_vv_geq<sivector_slice,srvector_slice,interval>(v1,v2);
3707 }
3708 
3710 
3713 inline bool operator>=(const sivector_slice& v1, const sivector_slice& v2) {
3714  return slsl_vv_geq<sivector_slice,sivector_slice,interval>(v1,v2);
3715 }
3716 
3718 
3721 inline bool operator>=(const sivector_slice& v1, const srvector& v2) {
3722  return slsp_vv_geq<sivector_slice,srvector,interval>(v1,v2);
3723 }
3724 
3726 
3729 inline bool operator>=(const sivector_slice& v1, const sivector& v2) {
3730  return slsp_vv_geq<sivector_slice,sivector,interval>(v1,v2);
3731 }
3732 
3734 
3737 inline bool operator>=(const sivector& v1, const srvector_slice& v2) {
3738  return spsl_vv_geq<sivector,srvector_slice,interval>(v1,v2);
3739 }
3740 
3742 
3745 inline bool operator>=(const sivector& v1, const sivector_slice& v2) {
3746  return spsl_vv_geq<sivector,sivector_slice,interval>(v1,v2);
3747 }
3748 
3750 
3753 inline bool operator>=(const sivector_slice& v1, const rvector& v2) {
3754  return slf_vv_geq<sivector_slice,rvector,interval>(v1,v2);
3755 }
3756 
3758 
3761 inline bool operator>=(const sivector_slice& v1, const ivector& v2) {
3762  return slf_vv_geq<sivector_slice,ivector,interval>(v1,v2);
3763 }
3764 
3766 
3769 inline bool operator>=(const ivector& v1, const srvector_slice& v2) {
3770  return fsl_vv_geq<ivector,srvector_slice,interval>(v1,v2);
3771 }
3772 
3774 
3777 inline bool operator>=(const ivector& v1, const sivector_slice& v2) {
3778  return fsl_vv_geq<ivector,sivector_slice,interval>(v1,v2);
3779 }
3780 
3782 
3785 inline bool operator>=(const sivector_slice& v1, const rvector_slice& v2) {
3786  return slf_vv_geq<sivector_slice,rvector_slice,interval>(v1,v2);
3787 }
3788 
3790 
3793 inline bool operator>=(const sivector_slice& v1, const ivector_slice& v2) {
3794  return slf_vv_geq<sivector_slice,ivector_slice,interval>(v1,v2);
3795 }
3796 
3798 
3801 inline bool operator>=(const ivector_slice& v1, const srvector_slice& v2) {
3802  return fsl_vv_geq<ivector_slice,srvector_slice,interval>(v1,v2);
3803 }
3804 
3806 
3809 inline bool operator>=(const ivector_slice& v1, const sivector_slice& v2) {
3810  return fsl_vv_geq<ivector_slice,sivector_slice,interval>(v1,v2);
3811 }
3812 
3814 
3819 inline std::ostream& operator<<(std::ostream& os, const sivector_slice& v) {
3820  return sl_v_output<sivector_slice,interval>(os,v);
3821 }
3822 
3824 
3829 inline std::istream& operator>>(std::istream& is, sivector_slice& v) {
3830  return sl_v_input<sivector_slice,interval>(is,v);
3831 }
3832 
3834 
3837 inline void accumulate(idotprecision& dot, const sivector& x, const sivector& y) {
3838  spsp_vv_accu<idotprecision,sivector,sivector,sparse_idot>(dot,x,y);
3839 }
3840 
3842 
3845 inline void accumulate(idotprecision& dot, const sivector& x, const srvector& y) {
3846  spsp_vv_accu<idotprecision,sivector,srvector,sparse_idot>(dot,x,y);
3847 }
3848 
3850 
3853 inline void accumulate(idotprecision& dot, const srvector& x, const sivector& y) {
3854  spsp_vv_accu<idotprecision,srvector,sivector,sparse_idot>(dot,x,y);
3855 }
3856 
3858 
3861 inline void accumulate(idotprecision& dot, const sivector& x, const ivector& y) {
3862  spf_vv_accu<idotprecision,sivector,ivector,sparse_idot>(dot,x,y);
3863 }
3864 
3866 
3869 inline void accumulate(idotprecision& dot, const sivector& x, const rvector& y) {
3870  spf_vv_accu<idotprecision,sivector,rvector,sparse_idot>(dot,x,y);
3871 }
3872 
3874 
3877 inline void accumulate(idotprecision& dot, const srvector& x, const ivector& y) {
3878  spf_vv_accu<idotprecision,srvector,ivector,sparse_idot>(dot,x,y);
3879 }
3880 
3882 
3885 inline void accumulate(idotprecision& dot, const sivector& x, const ivector_slice& y) {
3886  spf_vv_accu<idotprecision,sivector,ivector_slice,sparse_idot>(dot,x,y);
3887 }
3888 
3890 
3893 inline void accumulate(idotprecision& dot, const sivector& x, const rvector_slice& y) {
3894  spf_vv_accu<idotprecision,sivector,rvector_slice,sparse_idot>(dot,x,y);
3895 }
3896 
3898 
3901 inline void accumulate(idotprecision& dot, const srvector& x, const ivector_slice& y) {
3902  spf_vv_accu<idotprecision,srvector,ivector_slice,sparse_idot>(dot,x,y);
3903 }
3904 
3906 
3909 inline void accumulate(idotprecision& dot, const ivector& x, const sivector& y) {
3910  fsp_vv_accu<idotprecision,ivector,sivector,sparse_idot>(dot,x,y);
3911 }
3912 
3914 
3917 inline void accumulate(idotprecision& dot, const ivector& x, const srvector& y) {
3918  fsp_vv_accu<idotprecision,ivector,srvector,sparse_idot>(dot,x,y);
3919 }
3920 
3922 
3925 inline void accumulate(idotprecision& dot, const rvector& x, const sivector& y) {
3926  fsp_vv_accu<idotprecision,rvector,sivector,sparse_idot>(dot,x,y);
3927 }
3928 
3930 
3933 inline void accumulate(idotprecision& dot, const ivector_slice& x, const sivector& y) {
3934  fsp_vv_accu<idotprecision,ivector_slice,sivector,sparse_idot>(dot,x,y);
3935 }
3936 
3938 
3941 inline void accumulate(idotprecision& dot, const ivector_slice& x, const srvector& y) {
3942  fsp_vv_accu<idotprecision,ivector_slice,srvector,sparse_idot>(dot,x,y);
3943 }
3944 
3946 
3949 inline void accumulate(idotprecision& dot, const rvector_slice& x, const sivector& y) {
3950  fsp_vv_accu<idotprecision,rvector_slice,sivector,sparse_idot>(dot,x,y);
3951 }
3952 
3954 
3957 inline void accumulate(idotprecision& dot, const sivector_slice& x, const ivector& y) {
3958  slf_vv_accu<idotprecision,sivector_slice,ivector,sparse_idot>(dot,x,y);
3959 }
3960 
3962 
3965 inline void accumulate(idotprecision& dot, const sivector_slice& x, const rvector& y) {
3966  slf_vv_accu<idotprecision,sivector_slice,rvector,sparse_idot>(dot,x,y);
3967 }
3968 
3970 
3973 inline void accumulate(idotprecision& dot, const srvector_slice& x, const ivector& y) {
3974  slf_vv_accu<idotprecision,srvector_slice,ivector,sparse_idot>(dot,x,y);
3975 }
3976 
3978 
3981 inline void accumulate(idotprecision& dot, const sivector_slice& x, const ivector_slice& y) {
3982  slf_vv_accu<idotprecision,sivector_slice,ivector_slice,sparse_idot>(dot,x,y);
3983 }
3984 
3986 
3989 inline void accumulate(idotprecision& dot, const sivector_slice& x, const rvector_slice& y) {
3990  slf_vv_accu<idotprecision,sivector_slice,rvector_slice,sparse_idot>(dot,x,y);
3991 }
3992 
3994 
3997 inline void accumulate(idotprecision& dot, const srvector_slice& x, const ivector_slice& y) {
3998  slf_vv_accu<idotprecision,srvector_slice,ivector_slice,sparse_idot>(dot,x,y);
3999 }
4000 
4002 
4005 inline void accumulate(idotprecision& dot, const ivector& x, const sivector_slice& y) {
4006  fsl_vv_accu<idotprecision,ivector,sivector_slice,sparse_idot>(dot,x,y);
4007 }
4008 
4010 
4013 inline void accumulate(idotprecision& dot, const ivector& x, const srvector_slice& y) {
4014  fsl_vv_accu<idotprecision,ivector,srvector_slice,sparse_idot>(dot,x,y);
4015 }
4016 
4018 
4021 inline void accumulate(idotprecision& dot, const rvector& x, const sivector_slice& y) {
4022  fsl_vv_accu<idotprecision,rvector,sivector_slice,sparse_idot>(dot,x,y);
4023 }
4024 
4026 
4029 inline void accumulate(idotprecision& dot, const ivector_slice& x, const sivector_slice& y) {
4030  fsl_vv_accu<idotprecision,ivector_slice,sivector_slice,sparse_idot>(dot,x,y);
4031 }
4032 
4034 
4037 inline void accumulate(idotprecision& dot, const ivector_slice& x, const srvector_slice& y) {
4038  fsl_vv_accu<idotprecision,ivector_slice,srvector_slice,sparse_idot>(dot,x,y);
4039 }
4040 
4042 
4045 inline void accumulate(idotprecision& dot, const rvector_slice& x, const sivector_slice& y) {
4046  fsl_vv_accu<idotprecision,rvector_slice,sivector_slice,sparse_idot>(dot,x,y);
4047 }
4048 
4050 
4053 inline void accumulate(idotprecision& dot, const sivector_slice& x, const sivector_slice& y) {
4054  slsl_vv_accu<idotprecision,sivector_slice,sivector_slice,sparse_idot>(dot,x,y);
4055 }
4056 
4058 
4061 inline void accumulate(idotprecision& dot, const sivector_slice& x, const srvector_slice& y) {
4062  slsl_vv_accu<idotprecision,sivector_slice,srvector_slice,sparse_idot>(dot,x,y);
4063 }
4064 
4066 
4069 inline void accumulate(idotprecision& dot, const srvector_slice& x, const sivector_slice& y) {
4070  slsl_vv_accu<idotprecision,srvector_slice,sivector_slice,sparse_idot>(dot,x,y);
4071 }
4072 
4074 
4077 inline void accumulate(idotprecision& dot, const sivector& x, const sivector_slice& y) {
4078  spsl_vv_accu<idotprecision,sivector,sivector_slice,sparse_idot>(dot,x,y);
4079 }
4080 
4082 
4085 inline void accumulate(idotprecision& dot, const sivector& x, const srvector_slice& y) {
4086  spsl_vv_accu<idotprecision,sivector,srvector_slice,sparse_idot>(dot,x,y);
4087 }
4088 
4090 
4093 inline void accumulate(idotprecision& dot, const srvector& x, const sivector_slice& y) {
4094  spsl_vv_accu<idotprecision,srvector,sivector_slice,sparse_idot>(dot,x,y);
4095 }
4096 
4098 
4101 inline void accumulate(idotprecision& dot, const sivector_slice& x, const sivector& y) {
4102  slsp_vv_accu<idotprecision,sivector_slice,sivector,sparse_idot>(dot,x,y);
4103 }
4104 
4106 
4109 inline void accumulate(idotprecision& dot, const sivector_slice& x, const srvector& y) {
4110  slsp_vv_accu<idotprecision,sivector_slice,srvector,sparse_idot>(dot,x,y);
4111 }
4112 
4114 
4117 inline void accumulate(idotprecision& dot, const srvector_slice& x, const sivector& y) {
4118  slsp_vv_accu<idotprecision,srvector_slice,sivector,sparse_idot>(dot,x,y);
4119 }
4120 
4122 
4125 inline void accumulate(cidotprecision& dot, const sivector& x, const sivector& y) {
4126  idotprecision tmp(0.0);
4127  tmp.set_k(dot.get_k());
4128  accumulate(tmp,x,y);
4129  SetRe(dot, Re(dot) + tmp);
4130 }
4131 
4133 
4136 inline void accumulate(cidotprecision& dot, const sivector& x, const srvector& y) {
4137  idotprecision tmp(0.0);
4138  tmp.set_k(dot.get_k());
4139  accumulate(tmp,x,y);
4140  SetRe(dot, Re(dot) + tmp);
4141 }
4142 
4144 
4147 inline void accumulate(cidotprecision& dot, const srvector& x, const sivector& y) {
4148  idotprecision tmp(0.0);
4149  tmp.set_k(dot.get_k());
4150  accumulate(tmp,x,y);
4151  SetRe(dot, Re(dot) + tmp);
4152 }
4153 
4155 
4158 inline void accumulate(cidotprecision& dot, const sivector& x, const ivector& y) {
4159  idotprecision tmp(0.0);
4160  tmp.set_k(dot.get_k());
4161  accumulate(tmp,x,y);
4162  SetRe(dot, Re(dot) + tmp);
4163 }
4164 
4166 
4169 inline void accumulate(cidotprecision& dot, const sivector& x, const rvector& y) {
4170  idotprecision tmp(0.0);
4171  tmp.set_k(dot.get_k());
4172  accumulate(tmp,x,y);
4173  SetRe(dot, Re(dot) + tmp);
4174 }
4175 
4177 
4180 inline void accumulate(cidotprecision& dot, const srvector& x, const ivector& y) {
4181  idotprecision tmp(0.0);
4182  tmp.set_k(dot.get_k());
4183  accumulate(tmp,x,y);
4184  SetRe(dot, Re(dot) + tmp);
4185 }
4186 
4188 
4191 inline void accumulate(cidotprecision& dot, const sivector& x, const ivector_slice& y) {
4192  idotprecision tmp(0.0);
4193  tmp.set_k(dot.get_k());
4194  accumulate(tmp,x,y);
4195  SetRe(dot, Re(dot) + tmp);
4196 }
4197 
4199 
4202 inline void accumulate(cidotprecision& dot, const sivector& x, const rvector_slice& y) {
4203  idotprecision tmp(0.0);
4204  tmp.set_k(dot.get_k());
4205  accumulate(tmp,x,y);
4206  SetRe(dot, Re(dot) + tmp);
4207 }
4208 
4210 
4213 inline void accumulate(cidotprecision& dot, const srvector& x, const ivector_slice& y) {
4214  idotprecision tmp(0.0);
4215  tmp.set_k(dot.get_k());
4216  accumulate(tmp,x,y);
4217  SetRe(dot, Re(dot) + tmp);
4218 }
4219 
4221 
4224 inline void accumulate(cidotprecision& dot, const ivector& x, const sivector& y) {
4225  idotprecision tmp(0.0);
4226  tmp.set_k(dot.get_k());
4227  accumulate(tmp,x,y);
4228  SetRe(dot, Re(dot) + tmp);
4229 }
4230 
4232 
4235 inline void accumulate(cidotprecision& dot, const ivector& x, const srvector& y) {
4236  idotprecision tmp(0.0);
4237  tmp.set_k(dot.get_k());
4238  accumulate(tmp,x,y);
4239  SetRe(dot, Re(dot) + tmp);
4240 }
4241 
4243 
4246 inline void accumulate(cidotprecision& dot, const rvector& x, const sivector& y) {
4247  idotprecision tmp(0.0);
4248  tmp.set_k(dot.get_k());
4249  accumulate(tmp,x,y);
4250  SetRe(dot, Re(dot) + tmp);
4251 }
4252 
4254 
4257 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const sivector& y) {
4258  idotprecision tmp(0.0);
4259  tmp.set_k(dot.get_k());
4260  accumulate(tmp,x,y);
4261  SetRe(dot, Re(dot) + tmp);
4262 }
4263 
4265 
4268 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const srvector& y) {
4269  idotprecision tmp(0.0);
4270  tmp.set_k(dot.get_k());
4271  accumulate(tmp,x,y);
4272  SetRe(dot, Re(dot) + tmp);
4273 }
4274 
4276 
4279 inline void accumulate(cidotprecision& dot, const rvector_slice& x, const sivector& y) {
4280  idotprecision tmp(0.0);
4281  tmp.set_k(dot.get_k());
4282  accumulate(tmp,x,y);
4283  SetRe(dot, Re(dot) + tmp);
4284 }
4285 
4287 
4290 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const ivector& y) {
4291  idotprecision tmp(0.0);
4292  tmp.set_k(dot.get_k());
4293  accumulate(tmp,x,y);
4294  SetRe(dot, Re(dot) + tmp);
4295 }
4296 
4298 
4301 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const rvector& y) {
4302  idotprecision tmp(0.0);
4303  tmp.set_k(dot.get_k());
4304  accumulate(tmp,x,y);
4305  SetRe(dot, Re(dot) + tmp);
4306 }
4307 
4309 
4312 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const ivector& y) {
4313  idotprecision tmp(0.0);
4314  tmp.set_k(dot.get_k());
4315  accumulate(tmp,x,y);
4316  SetRe(dot, Re(dot) + tmp);
4317 }
4318 
4320 
4323 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const ivector_slice& y) {
4324  idotprecision tmp(0.0);
4325  tmp.set_k(dot.get_k());
4326  accumulate(tmp,x,y);
4327  SetRe(dot, Re(dot) + tmp);
4328 }
4329 
4331 
4334 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const rvector_slice& y) {
4335  idotprecision tmp(0.0);
4336  tmp.set_k(dot.get_k());
4337  accumulate(tmp,x,y);
4338  SetRe(dot, Re(dot) + tmp);
4339 }
4340 
4342 
4345 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const ivector_slice& y) {
4346  idotprecision tmp(0.0);
4347  tmp.set_k(dot.get_k());
4348  accumulate(tmp,x,y);
4349  SetRe(dot, Re(dot) + tmp);
4350 }
4351 
4353 
4356 inline void accumulate(cidotprecision& dot, const ivector& x, const sivector_slice& y) {
4357  idotprecision tmp(0.0);
4358  tmp.set_k(dot.get_k());
4359  accumulate(tmp,x,y);
4360  SetRe(dot, Re(dot) + tmp);
4361 }
4362 
4364 
4367 inline void accumulate(cidotprecision& dot, const ivector& x, const srvector_slice& y) {
4368  idotprecision tmp(0.0);
4369  tmp.set_k(dot.get_k());
4370  accumulate(tmp,x,y);
4371  SetRe(dot, Re(dot) + tmp);
4372 }
4373 
4375 
4378 inline void accumulate(cidotprecision& dot, const rvector& x, const sivector_slice& y) {
4379  idotprecision tmp(0.0);
4380  tmp.set_k(dot.get_k());
4381  accumulate(tmp,x,y);
4382  SetRe(dot, Re(dot) + tmp);
4383 }
4384 
4386 
4389 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const sivector_slice& y) {
4390  idotprecision tmp(0.0);
4391  tmp.set_k(dot.get_k());
4392  accumulate(tmp,x,y);
4393  SetRe(dot, Re(dot) + tmp);
4394 }
4395 
4397 
4400 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const srvector_slice& y) {
4401  idotprecision tmp(0.0);
4402  tmp.set_k(dot.get_k());
4403  accumulate(tmp,x,y);
4404  SetRe(dot, Re(dot) + tmp);
4405 }
4406 
4408 
4411 inline void accumulate(cidotprecision& dot, const rvector_slice& x, const sivector_slice& y) {
4412  idotprecision tmp(0.0);
4413  tmp.set_k(dot.get_k());
4414  accumulate(tmp,x,y);
4415  SetRe(dot, Re(dot) + tmp);
4416 }
4417 
4419 
4422 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const sivector_slice& y) {
4423  idotprecision tmp(0.0);
4424  tmp.set_k(dot.get_k());
4425  accumulate(tmp,x,y);
4426  SetRe(dot, Re(dot) + tmp);
4427 }
4428 
4430 
4433 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const srvector_slice& y) {
4434  idotprecision tmp(0.0);
4435  tmp.set_k(dot.get_k());
4436  accumulate(tmp,x,y);
4437  SetRe(dot, Re(dot) + tmp);
4438 }
4439 
4441 
4444 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const sivector_slice& y) {
4445  idotprecision tmp(0.0);
4446  tmp.set_k(dot.get_k());
4447  accumulate(tmp,x,y);
4448  SetRe(dot, Re(dot) + tmp);
4449 }
4450 
4452 
4455 inline void accumulate(cidotprecision& dot, const sivector& x, const sivector_slice& y) {
4456  idotprecision tmp(0.0);
4457  tmp.set_k(dot.get_k());
4458  accumulate(tmp,x,y);
4459  SetRe(dot, Re(dot) + tmp);
4460 }
4461 
4463 
4466 inline void accumulate(cidotprecision& dot, const sivector& x, const srvector_slice& y) {
4467  idotprecision tmp(0.0);
4468  tmp.set_k(dot.get_k());
4469  accumulate(tmp,x,y);
4470  SetRe(dot, Re(dot) + tmp);
4471 }
4472 
4474 
4477 inline void accumulate(cidotprecision& dot, const srvector& x, const sivector_slice& y) {
4478  idotprecision tmp(0.0);
4479  tmp.set_k(dot.get_k());
4480  accumulate(tmp,x,y);
4481  SetRe(dot, Re(dot) + tmp);
4482 }
4483 
4485 
4488 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const sivector& y) {
4489  idotprecision tmp(0.0);
4490  tmp.set_k(dot.get_k());
4491  accumulate(tmp,x,y);
4492  SetRe(dot, Re(dot) + tmp);
4493 }
4494 
4496 
4499 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const srvector& y) {
4500  idotprecision tmp(0.0);
4501  tmp.set_k(dot.get_k());
4502  accumulate(tmp,x,y);
4503  SetRe(dot, Re(dot) + tmp);
4504 }
4505 
4507 
4510 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const sivector& y) {
4511  idotprecision tmp(0.0);
4512  tmp.set_k(dot.get_k());
4513  accumulate(tmp,x,y);
4514  SetRe(dot, Re(dot) + tmp);
4515 }
4516 
4517 } //namespace cxsc
4518 
4519 #include "sparsevector.inl"
4520 
4521 #endif
cxsc::sivector::SetLb
friend void SetLb(sivector &, const int)
Sets the lower index bound of the vector v to i.
Definition: sivector.hpp:546
cxsc::sivector::absmin
friend srvector absmin(const sivector &)
Computes the component-wise minimum absolute values for a vector v.
Definition: sivector.hpp:626
cxsc::sivector::operator[]
interval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: sivector.hpp:280
cxsc::AbsMax
real AbsMax(const interval &x)
Computes the greatest absolute value .
Definition: interval.cpp:303
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2070
cxsc::sivector::density
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
Definition: sivector.hpp:186
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2005
cxsc::sivector::Inf
friend srvector Inf(const sivector &)
Returns the infimum of the interval vector as a new sparse point vector.
Definition: sivector.hpp:593
cxsc::sivector_slice::operator/=
sivector_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: sivector.hpp:1990
cxsc::sivector_slice
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
cxsc::sivector::sivector
sivector(const int s)
Constructor for creating an empty vector of size s.
Definition: sivector.hpp:73
cxsc::sivector::row_indices
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: sivector.hpp:167
cxsc::sivector::Blow
friend sivector Blow(const sivector &, const real &)
Performs an epsilon inflation of the vector v.
Definition: sivector.hpp:678
cxsc::sivector::sivector
sivector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: sivector.hpp:95
cxsc::civector_slice
The Data Type civector_slice.
Definition: civector.hpp:1015
cxsc::sivector::dropzeros
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: sivector.hpp:191
cxsc::sivector::operator&=
sivector & operator&=(const ivector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: sivector.hpp:455
cxsc::sivector::operator-=
sivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:420
cxsc::srvector
A sparse real vector.
Definition: srvector.hpp:58
cxsc::sivector_slice::operator=
sivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
Definition: sivector.hpp:1930
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const rvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2080
cxsc::sivector::get_nnz
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
cxsc::sivector::operator|=
sivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:425
cxsc::sivector::values
std::vector< interval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: sivector.hpp:157
cxsc::sivector::operator&=
sivector & operator&=(const sivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: sivector.hpp:460
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2090
cxsc::srmatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2105
cxsc::cidotprecision::get_k
int get_k() const
Get currently set precision for computation of dot products.
Definition: cidot.hpp:89
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2000
cxsc::sivector::operator=
sivector & 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: sivector.hpp:244
cxsc::absmax
rvector absmax(const imatrix_subv &mv)
Returns the absolute maximum value of the matrix.
Definition: imatrix.inl:502
cxsc::sivector_slice::Lb
friend int Lb(const sivector_slice &)
Returns the lower index bound of the vector slice v.
Definition: sivector.hpp:2247
cxsc::sivector_slice::Sup
friend srvector Sup(const sivector_slice &)
Returns the supremum of the vector slice v.
Definition: sivector.hpp:2262
cxsc::sivector_slice::operator&=
sivector_slice & operator&=(const ivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2120
cxsc::sivector::VecLen
friend int VecLen(const sivector &)
Returns the length of the vector (the dimension)
Definition: sivector.hpp:673
cxsc::sivector::operator+=
sivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:375
cxsc::mid
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::sivector::operator*=
sivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
Definition: sivector.hpp:350
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::sivector::operator+=
sivector & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:380
cxsc::sivector::Re
friend sivector Re(const scivector &)
Returns the real part of the vector v.
Definition: scivector.hpp:908
cxsc::sivector::operator|=
sivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:430
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:52
cxsc::sivector::operator/=
sivector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition: sivector.hpp:355
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2010
cxsc::Zero
int Zero(ivector &x)
Checks if vector is zero vector.
Definition: ivector.cpp:80
cxsc::sivector::Im
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
Definition: scivector.hpp:919
cxsc::diam
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::sivector::sivector
sivector(const int n, const int nnz, const intvector &index, const ivector &values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition: sivector.hpp:105
cxsc::srvector_slice
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
cxsc::sivector::sivector
sivector(const ivector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: sivector.hpp:85
cxsc::sivector::operator+=
sivector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:385
cxsc::sivector::abs
friend sivector abs(const sivector &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: sivector.hpp:615
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2050
cxsc::sivector_slice::operator&=
sivector_slice & operator&=(const ivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2125
cxsc::sivector::operator=
sivector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: sivector.hpp:219
cxsc::sivector_slice::operator=
sivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1965
cxsc::ivector_slice::operator=
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
Definition: sivector.hpp:2194
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2020
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2040
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::ivector::operator-=
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator
Definition: sivector.hpp:1205
cxsc::Blow
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
cxsc::sivector_slice::get_nnz
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
Definition: sivector.hpp:1866
cxsc::sivector::operator+=
sivector & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:370
cxsc::sivector::values
const std::vector< interval > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: sivector.hpp:176
cxsc::sivector::operator-=
sivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:410
cxsc::sivector_slice::mid
friend srvector mid(const sivector_slice &)
Computes the midpoint vector of v.
Definition: sivector.hpp:2278
cxsc::ivector::operator&=
ivector & operator&=(const sivector &)
Implementation of assignment and intersection operator
Definition: sivector.hpp:1237
cxsc::sivector::absmax
friend srvector absmax(const sivector &)
Computes the component-wise maximum absolute values for a vector v.
Definition: sivector.hpp:638
cxsc::sivector_slice::Inf
friend srvector Inf(const sivector_slice &)
Returns the infimum vector slice v.
Definition: sivector.hpp:2257
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2055
cxsc::in
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
cxsc::sivector::operator=
sivector & 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: sivector.hpp:239
cxsc::sivector::mid
friend srvector mid(const sivector &)
Compute the midpoint vector of v.
Definition: sivector.hpp:650
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:963
cxsc::ivector::operator=
ivector & operator=(const ivector &rv)
Implementation of standard assigning operator.
Definition: ivector.inl:263
cxsc::sivector::operator/=
sivector & operator/=(const interval &s)
Operator for division of each element of the vector with an interval, result is assigned to the vecto...
Definition: sivector.hpp:360
cxsc::sivector_slice::density
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
Definition: sivector.hpp:1871
cxsc::sivector_slice::operator*=
sivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
Definition: sivector.hpp:1985
cxsc::ivector::ivector
ivector()
Constructor of class ivector.
Definition: ivector.inl:31
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::sivector_slice::operator*=
sivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: sivector.hpp:1980
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::ivector_slice::operator-=
ivector_slice & operator-=(const ivector &rv)
Implementation of subtraction and allocation operation.
Definition: ivector.inl:669
cxsc::sivector::sivector
sivector(const srmatrix_subv &A)
Creates a sparse interval vector out of a row or column of a sparse real matrix.
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2100
cxsc::sivector::diam
friend srvector diam(const sivector &)
Computes the diameter of v.
Definition: sivector.hpp:662
cxsc::sivector::operator=
sivector & operator=(const ivector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: sivector.hpp:234
cxsc::sivector_slice::operator&=
sivector_slice & operator&=(const sivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2130
cxsc::srvector::get_nnz
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
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const ivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2085
cxsc::sivector::operator|=
sivector & operator|=(const srvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:445
cxsc::sivector_slice::operator=
sivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
Definition: sivector.hpp:1935
cxsc::scivector
A sparse complex interval vector.
Definition: scivector.hpp:62
cxsc::sivector::operator-=
sivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:395
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::sivector_slice::diam
friend srvector diam(const sivector_slice &)
Computes the diameter of v.
Definition: sivector.hpp:2289
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2060
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::idotprecision::set_k
void set_k(unsigned int i)
Set precision for computation of dot products.
Definition: idot.hpp:88
cxsc::sivector_slice::operator()
const interval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: sivector.hpp:1915
cxsc::sivector::sivector
sivector(const int n, const int nnz, const int *index, const interval *values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition: sivector.hpp:116
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2075
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2025
cxsc::sivector_slice::operator&=
sivector_slice & operator&=(const sivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2135
cxsc::absmin
rvector absmin(const imatrix_subv &mv)
Returns the absolute minimum value of the matrix.
Definition: imatrix.inl:496
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2115
cxsc::sivector_slice::operator=
sivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1945
cxsc::sivector::operator*=
sivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition: sivector.hpp:345
cxsc::sivector::sivector
sivector(const srvector &v)
Creates a sparse interval vector out of a sparse real vector.
Definition: sivector.hpp:127
cxsc::sivector_slice::Ub
friend int Ub(const sivector_slice &)
Returns the upper index bound of the vector slice v.
Definition: sivector.hpp:2252
cxsc::sivector::operator()
const interval operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: sivector.hpp:292
cxsc::sivector_slice::operator=
sivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1950
cxsc::sivector_slice::operator=
sivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1940
cxsc::sivector_slice::operator=
sivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1970
cxsc::sivector_slice::operator=
sivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1975
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2095
cxsc::ivector_slice::operator|=
ivector_slice & operator|=(const ivector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: ivector.inl:726
cxsc::cidotprecision
The Data Type cidotprecision.
Definition: cidot.hpp:58
cxsc::sivector::operator|=
sivector & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:440
cxsc::ivector::operator+=
ivector & operator+=(const srvector &)
Implementation of assignment and addition operator
Definition: sivector.hpp:1189
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::Lb
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::sivector::operator+=
sivector & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:390
cxsc::sivector::operator[]
interval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
Definition: sivector.hpp:258
cxsc::sivector::operator+=
sivector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:365
cxsc::sivector::operator=
sivector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: sivector.hpp:229
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::ivector::operator|=
ivector & operator|=(const srvector &)
Implementation of assignment and hull operator
Definition: sivector.hpp:1221
cxsc::sivector_slice::operator|=
sivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2110
cxsc::sivector_slice::operator[]
interval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
Definition: sivector.hpp:1880
cxsc::scivector_slice
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
cxsc::sivector::Ub
friend int Ub(const sivector &)
Returns the upper index bound of the vector v.
Definition: sivector.hpp:566
cxsc::sivector::operator|=
sivector & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:435
cxsc::sivector_slice::operator=
sivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1960
cxsc::sivector::operator()
sivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition: sivector.hpp:310
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const sivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2035
cxsc::sivector::operator=
sivector & operator=(const interval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: sivector.hpp:224
cxsc::sivector::Sup
friend srvector Sup(const sivector &)
Returns the supremum of the interval vector as a new sparse point vector.
Definition: sivector.hpp:604
cxsc::srvector::dropzeros
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: srvector.hpp:170
cxsc::Ub
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2030
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2045
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::sivector::operator|=
sivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:450
cxsc::sivector::operator-=
sivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:400
cxsc::sivector::operator()
sivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition: sivector.hpp:334
cxsc::sivector_slice::VecLen
friend int VecLen(const sivector_slice &)
Returns the length of the vector slice.
Definition: sivector.hpp:2300
cxsc::sivector::operator-=
sivector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:405
cxsc::sivector::sivector
sivector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
Definition: sivector.hpp:79
cxsc::sivector_slice::abs
friend sivector abs(const sivector_slice &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: sivector.hpp:2267
cxsc::sivector_slice::operator[]
interval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: sivector.hpp:1903
cxsc::sivector::SetUb
friend void SetUb(sivector &, const int)
Sets the upper index bound of the vector v to i.
Definition: sivector.hpp:555
cxsc::sivector_slice::operator=
sivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1955
cxsc::AbsMin
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition: interval.cpp:293
cxsc::sivector::Lb
friend int Lb(const sivector &)
Returns the lower index bound of the vector v.
Definition: sivector.hpp:561
cxsc::sivector::operator=
sivector & operator=(const srvector &v)
Assign a sparse real vector to a sparse interval vector.
Definition: sivector.hpp:208
cxsc::sivector::row_indices
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: sivector.hpp:148
cxsc::civector
The Data Type civector.
Definition: civector.hpp:57
cxsc::sivector
A sparse interval vector.
Definition: sivector.hpp:59
cxsc::sivector::operator-=
sivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:415
cxsc::intmatrix
The Data Type intmatrix.
Definition: intmatrix.hpp:314
cxsc::ivector_slice::operator+=
ivector_slice & operator+=(const ivector &rv)
Implementation of addition and allocation operation.
Definition: ivector.inl:610
cxsc::sivector_slice::operator-=
sivector_slice & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2065
cxsc::sivector_slice::operator/=
sivector_slice & operator/=(const interval &s)
Operator for division of each element of the vector slice with an interval, result is assigned to the...
Definition: sivector.hpp:1995
cxsc::sivector::sivector
sivector()
Default constructor, creates an empty vector of size 0.
Definition: sivector.hpp:69
cxsc::VecLen
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
cxsc::simatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:114
cxsc::ivector_slice::operator&=
ivector_slice & operator&=(const ivector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: ivector.inl:783
cxsc::sivector_slice::operator+=
sivector_slice & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: sivector.hpp:2015