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
38namespace cxsc {
39
40class srvector_slice;
41class srmatrix;
42class srmatrix_slice;
43class srmatrix_subv;
44class sivector_slice;
45class simatrix;
46class simatrix_slice;
47class simatrix_subv;
48class scivector;
49class scivector_slice;
50class scimatrix;
51class scimatrix_slice;
52class scimatrix_subv;
53
55
59class 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
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
346 return sp_vs_multassign(*this,s);
347 }
348
351 return sp_vs_multassign(*this,s);
352 }
353
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
504inline 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
515inline 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
546inline void SetLb(sivector& v, const int i) {
547 v.lb = i;
548 v.ub = v.lb + v.n - 1;
549}
550
552
555inline void SetUb(sivector& v, const int j) {
556 v.ub = j;
557 v.lb = v.ub - v.n + 1;
558}
559
561inline int Lb(const sivector& v) {
562 return v.lb;
563}
564
566inline int Ub(const sivector& v) {
567 return v.ub;
568}
569
571inline void Resize(sivector& v) {
572 sp_v_resize(v);
573}
574
576
579inline void Resize(sivector& v, const int n) {
580 sp_v_resize(v,n);
581}
582
584
588inline void Resize(sivector& v, const int l, const int u) {
589 sp_v_resize(v,l,u);
590}
591
593inline 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
604inline 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
615inline 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
626inline 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
638inline 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
650inline 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
662inline 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
673inline int VecLen(const sivector& v) {
674 return v.n;
675}
676
678inline 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
686inline 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
693inline 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
700inline sivector operator-(const sivector& v) {
701 return sp_v_negative(v);
702}
703
705
711inline interval operator*(const sivector& v1, const ivector& v2) {
712 return spf_vv_mult<sivector,ivector,interval,sparse_idot>(v1,v2);
713}
714
716
722inline interval operator*(const sivector& v1, const rvector& v2) {
723 return spf_vv_mult<sivector,rvector,interval,sparse_idot>(v1,v2);
724}
725
727
733inline interval operator*(const srvector& v1, const ivector& v2) {
734 return spf_vv_mult<srvector,ivector,interval,sparse_idot>(v1,v2);
735}
736
738
744inline interval operator*(const rvector& v1, const sivector& v2) {
745 return fsp_vv_mult<rvector,sivector,interval,sparse_idot>(v1,v2);
746}
747
749
755inline interval operator*(const ivector& v1, const srvector& v2) {
756 return fsp_vv_mult<ivector,srvector,interval,sparse_idot>(v1,v2);
757}
758
760
766inline interval operator*(const ivector& v1, const sivector& v2) {
767 return fsp_vv_mult<ivector,sivector,interval,sparse_idot>(v1,v2);
768}
769
771
777inline 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
788inline 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
799inline 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
810inline 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
821inline 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
832inline 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
843inline interval operator*(const sivector& v1, const srvector& v2) {
844 return spsp_vv_mult<sivector,srvector,interval,sparse_idot>(v1,v2);
845}
846
848
854inline interval operator*(const srvector& v1, const sivector& v2) {
855 return spsp_vv_mult<srvector,sivector,interval,sparse_idot>(v1,v2);
856}
857
859
865inline interval operator*(const sivector& v1, const sivector& v2) {
866 return spsp_vv_mult<sivector,sivector,interval,sparse_idot>(v1,v2);
867}
868
870inline sivector operator*(const sivector& v, const real& s) {
871 return sp_vs_mult<sivector,real,sivector>(v,s);
872}
873
875inline sivector operator*(const sivector& v, const interval& s) {
876 return sp_vs_mult<sivector,interval,sivector>(v,s);
877}
878
880inline sivector operator*(const srvector& v, const interval& s) {
881 return sp_vs_mult<srvector,interval,sivector>(v,s);
882}
883
885inline sivector operator/(const sivector& v, const real& s) {
886 return sp_vs_div<sivector,real,sivector>(v,s);
887}
888
890inline sivector operator/(const sivector& v, const interval& s) {
891 return sp_vs_div<sivector,interval,sivector>(v,s);
892}
893
895inline sivector operator/(const srvector& v, const interval& s) {
896 return sp_vs_div<srvector,interval,sivector>(v,s);
897}
898
900inline sivector operator*(const real& s, const sivector& v) {
901 return sp_sv_mult<real,sivector,sivector>(s,v);
902}
903
905inline sivector operator*(const interval& s, const sivector& v) {
906 return sp_sv_mult<interval,sivector,sivector>(s,v);
907}
908
910inline sivector operator*(const interval& s, const srvector& v) {
911 return sp_sv_mult<interval,srvector,sivector>(s,v);
912}
913
915inline ivector operator+(const ivector& v1, const srvector& v2) {
916 return fsp_vv_add<ivector,srvector,ivector>(v1,v2);
917}
918
920inline ivector operator+(const rvector& v1, const sivector& v2) {
921 return fsp_vv_add<rvector,sivector,ivector>(v1,v2);
922}
923
925inline ivector operator+(const ivector& v1, const sivector& v2) {
926 return fsp_vv_add<ivector,sivector,ivector>(v1,v2);
927}
928
930inline ivector operator+(const sivector& v1, const rvector& v2) {
931 return spf_vv_add<sivector,rvector,ivector>(v1,v2);
932}
933
935inline ivector operator+(const srvector& v1, const ivector& v2) {
936 return spf_vv_add<srvector,ivector,ivector>(v1,v2);
937}
938
940inline ivector operator+(const sivector& v1, const ivector& v2) {
941 return spf_vv_add<sivector,ivector,ivector>(v1,v2);
942}
943
945inline ivector operator+(const ivector_slice& v1, const srvector& v2) {
946 return fsp_vv_add<ivector_slice,srvector,ivector>(v1,v2);
947}
948
950inline ivector operator+(const rvector_slice& v1, const sivector& v2) {
951 return fsp_vv_add<rvector_slice,sivector,ivector>(v1,v2);
952}
953
955inline ivector operator+(const ivector_slice& v1, const sivector& v2) {
956 return fsp_vv_add<ivector_slice,sivector,ivector>(v1,v2);
957}
958
960inline ivector operator+(const sivector& v1, const rvector_slice& v2) {
961 return spf_vv_add<sivector,rvector_slice,ivector>(v1,v2);
962}
963
965inline ivector operator+(const srvector& v1, const ivector_slice& v2) {
966 return spf_vv_add<srvector,ivector_slice,ivector>(v1,v2);
967}
968
970inline ivector operator+(const sivector& v1, const ivector_slice& v2) {
971 return spf_vv_add<sivector,ivector_slice,ivector>(v1,v2);
972}
973
975inline sivector operator+(const sivector& v1, const srvector& v2) {
976 return spsp_vv_add<sivector,srvector,sivector,interval>(v1,v2);
977}
978
980inline sivector operator+(const srvector& v1, const sivector& v2) {
981 return spsp_vv_add<srvector,sivector,sivector,interval>(v1,v2);
982}
983
985inline sivector operator+(const sivector& v1, const sivector& v2) {
986 return spsp_vv_add<sivector,sivector,sivector,interval>(v1,v2);
987}
988
990inline ivector operator-(const ivector& v1, const srvector& v2) {
991 return fsp_vv_sub<ivector,srvector,ivector>(v1,v2);
992}
993
995inline ivector operator-(const rvector& v1, const sivector& v2) {
996 return fsp_vv_sub<rvector,sivector,ivector>(v1,v2);
997}
998
1000inline ivector operator-(const ivector& v1, const sivector& v2) {
1001 return fsp_vv_sub<ivector,sivector,ivector>(v1,v2);
1002}
1003
1005inline ivector operator-(const sivector& v1, const rvector& v2) {
1006 return spf_vv_sub<sivector,rvector,ivector>(v1,v2);
1007}
1008
1010inline ivector operator-(const srvector& v1, const ivector& v2) {
1011 return spf_vv_sub<srvector,ivector,ivector>(v1,v2);
1012}
1013
1015inline ivector operator-(const sivector& v1, const ivector& v2) {
1016 return spf_vv_sub<sivector,ivector,ivector>(v1,v2);
1017}
1018
1020inline ivector operator-(const ivector_slice& v1, const srvector& v2) {
1021 return fsp_vv_sub<ivector_slice,srvector,ivector>(v1,v2);
1022}
1023
1025inline ivector operator-(const rvector_slice& v1, const sivector& v2) {
1026 return fsp_vv_sub<rvector_slice,sivector,ivector>(v1,v2);
1027}
1028
1030inline ivector operator-(const ivector_slice& v1, const sivector& v2) {
1031 return fsp_vv_sub<ivector_slice,sivector,ivector>(v1,v2);
1032}
1033
1035inline ivector operator-(const sivector& v1, const rvector_slice& v2) {
1036 return spf_vv_sub<sivector,rvector_slice,ivector>(v1,v2);
1037}
1038
1040inline ivector operator-(const srvector& v1, const ivector_slice& v2) {
1041 return spf_vv_sub<srvector,ivector_slice,ivector>(v1,v2);
1042}
1043
1045inline ivector operator-(const sivector& v1, const ivector_slice& v2) {
1046 return spf_vv_sub<sivector,ivector_slice,ivector>(v1,v2);
1047}
1048
1050inline sivector operator-(const sivector& v1, const srvector& v2) {
1051 return spsp_vv_sub<sivector,srvector,sivector,interval>(v1,v2);
1052}
1053
1055inline sivector operator-(const srvector& v1, const sivector& v2) {
1056 return spsp_vv_sub<srvector,sivector,sivector,interval>(v1,v2);
1057}
1058
1060inline sivector operator-(const sivector& v1, const sivector& v2) {
1061 return spsp_vv_sub<sivector,sivector,sivector,interval>(v1,v2);
1062}
1063
1065inline ivector operator|(const rvector& v1, const srvector& v2) {
1066 return fsp_vv_hull<rvector,srvector,ivector>(v1,v2);
1067}
1068
1070inline ivector operator|(const srvector& v1, const rvector& v2) {
1071 return spf_vv_hull<srvector,rvector,ivector>(v1,v2);
1072}
1073
1075inline ivector operator|(const rvector_slice& v1, const srvector& v2) {
1076 return fsp_vv_hull<rvector_slice,srvector,ivector>(v1,v2);
1077}
1078
1080inline ivector operator|(const srvector& v1, const rvector_slice& v2) {
1081 return spf_vv_hull<srvector,rvector_slice,ivector>(v1,v2);
1082}
1083
1085inline sivector operator|(const srvector& v1, const srvector& v2) {
1086 return spsp_vv_hull<srvector,srvector,sivector,interval>(v1,v2);
1087}
1088
1090inline ivector operator|(const ivector& v1, const srvector& v2) {
1091 return fsp_vv_hull<ivector,srvector,ivector>(v1,v2);
1092}
1093
1095inline ivector operator|(const rvector& v1, const sivector& v2) {
1096 return fsp_vv_hull<rvector,sivector,ivector>(v1,v2);
1097}
1098
1100inline ivector operator|(const ivector& v1, const sivector& v2) {
1101 return fsp_vv_hull<ivector,sivector,ivector>(v1,v2);
1102}
1103
1105inline ivector operator|(const sivector& v1, const rvector& v2) {
1106 return spf_vv_hull<sivector,rvector,ivector>(v1,v2);
1107}
1108
1110inline ivector operator|(const srvector& v1, const ivector& v2) {
1111 return spf_vv_hull<srvector,ivector,ivector>(v1,v2);
1112}
1113
1115inline ivector operator|(const sivector& v1, const ivector& v2) {
1116 return spf_vv_hull<sivector,ivector,ivector>(v1,v2);
1117}
1118
1120inline ivector operator|(const ivector_slice& v1, const srvector& v2) {
1121 return fsp_vv_hull<ivector_slice,srvector,ivector>(v1,v2);
1122}
1123
1125inline ivector operator|(const rvector_slice& v1, const sivector& v2) {
1126 return fsp_vv_hull<rvector_slice,sivector,ivector>(v1,v2);
1127}
1128
1130inline ivector operator|(const ivector_slice& v1, const sivector& v2) {
1131 return fsp_vv_hull<ivector_slice,sivector,ivector>(v1,v2);
1132}
1133
1135inline ivector operator|(const sivector& v1, const rvector_slice& v2) {
1136 return spf_vv_hull<sivector,rvector_slice,ivector>(v1,v2);
1137}
1138
1140inline ivector operator|(const srvector& v1, const ivector_slice& v2) {
1141 return spf_vv_hull<srvector,ivector_slice,ivector>(v1,v2);
1142}
1143
1145inline ivector operator|(const sivector& v1, const ivector_slice& v2) {
1146 return spf_vv_hull<sivector,ivector_slice,ivector>(v1,v2);
1147}
1148
1150inline sivector operator|(const sivector& v1, const srvector& v2) {
1151 return spsp_vv_hull<sivector,srvector,sivector,interval>(v1,v2);
1152}
1153
1155inline sivector operator|(const srvector& v1, const sivector& v2) {
1156 return spsp_vv_hull<srvector,sivector,sivector,interval>(v1,v2);
1157}
1158
1160inline sivector operator|(const sivector& v1, const sivector& v2) {
1161 return spsp_vv_hull<sivector,sivector,sivector,interval>(v1,v2);
1162}
1163
1165inline sivector operator&(const ivector& v1, const sivector& v2) {
1166 return fsp_vv_intersect<ivector,sivector,ivector>(v1,v2);
1167}
1168
1170inline sivector operator&(const sivector& v1, const ivector& v2) {
1171 return spf_vv_intersect<sivector,ivector,ivector>(v1,v2);
1172}
1173
1175inline sivector operator&(const ivector_slice& v1, const sivector& v2) {
1176 return fsp_vv_intersect<ivector_slice,sivector,ivector>(v1,v2);
1177}
1178
1180inline sivector operator&(const sivector& v1, const ivector_slice& v2) {
1181 return spf_vv_intersect<sivector,ivector_slice,ivector>(v1,v2);
1182}
1183
1185inline 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
1249inline bool operator==(const sivector& v1, const sivector& v2) {
1250 return spsp_vv_comp(v1,v2);
1251}
1252
1254
1257inline bool operator==(const sivector& v1, const srvector& v2) {
1258 return spsp_vv_comp(v1,v2);
1259}
1260
1262
1265inline bool operator==(const srvector& v1, const sivector& v2) {
1266 return spsp_vv_comp(v1,v2);
1267}
1268
1270
1273inline bool operator==(const sivector& v1, const rvector& v2) {
1274 return spf_vv_comp(v1,v2);
1275}
1276
1278
1281inline bool operator==(const srvector& v1, const ivector& v2) {
1282 return spf_vv_comp(v1,v2);
1283}
1284
1286
1289inline bool operator==(const sivector& v1, const ivector& v2) {
1290 return spf_vv_comp(v1,v2);
1291}
1292
1294
1297inline bool operator==(const ivector& v1, const srvector& v2) {
1298 return fsp_vv_comp(v1,v2);
1299}
1300
1302
1305inline bool operator==(const rvector& v1, const sivector& v2) {
1306 return fsp_vv_comp(v1,v2);
1307}
1308
1310
1313inline bool operator==(const ivector& v1, const sivector& v2) {
1314 return fsp_vv_comp(v1,v2);
1315}
1316
1318
1321inline bool operator==(const sivector& v1, const rvector_slice& v2) {
1322 return spf_vv_comp(v1,v2);
1323}
1324
1326
1329inline bool operator==(const srvector& v1, const ivector_slice& v2) {
1330 return spf_vv_comp(v1,v2);
1331}
1332
1334
1337inline bool operator==(const sivector& v1, const ivector_slice& v2) {
1338 return spf_vv_comp(v1,v2);
1339}
1340
1342
1345inline bool operator==(const ivector_slice& v1, const srvector& v2) {
1346 return fsp_vv_comp(v1,v2);
1347}
1348
1350
1353inline bool operator==(const rvector_slice& v1, const sivector& v2) {
1354 return fsp_vv_comp(v1,v2);
1355}
1356
1358
1361inline bool operator==(const ivector_slice& v1, const sivector& v2) {
1362 return fsp_vv_comp(v1,v2);
1363}
1364
1366
1369inline bool operator!=(const sivector& v1, const srvector& v2) {
1370 return !spsp_vv_comp(v1,v2);
1371}
1372
1374
1377inline bool operator!=(const srvector& v1, const sivector& v2) {
1378 return !spsp_vv_comp(v1,v2);
1379}
1380
1382
1385inline bool operator!=(const sivector& v1, const sivector& v2) {
1386 return !spsp_vv_comp(v1,v2);
1387}
1388
1390
1393inline bool operator!=(const sivector& v1, const rvector& v2) {
1394 return !spf_vv_comp(v1,v2);
1395}
1396
1398
1401inline bool operator!=(const srvector& v1, const ivector& v2) {
1402 return !spf_vv_comp(v1,v2);
1403}
1404
1406
1409inline bool operator!=(const sivector& v1, const ivector& v2) {
1410 return !spf_vv_comp(v1,v2);
1411}
1412
1414
1417inline bool operator!=(const ivector& v1, const srvector& v2) {
1418 return !fsp_vv_comp(v1,v2);
1419}
1420
1422
1425inline bool operator!=(const rvector& v1, const sivector& v2) {
1426 return !fsp_vv_comp(v1,v2);
1427}
1428
1430
1433inline bool operator!=(const ivector& v1, const sivector& v2) {
1434 return !fsp_vv_comp(v1,v2);
1435}
1436
1438
1441inline bool operator!=(const sivector& v1, const rvector_slice& v2) {
1442 return !spf_vv_comp(v1,v2);
1443}
1444
1446
1449inline bool operator!=(const srvector& v1, const ivector_slice& v2) {
1450 return !spf_vv_comp(v1,v2);
1451}
1452
1454
1457inline bool operator!=(const sivector& v1, const ivector_slice& v2) {
1458 return !spf_vv_comp(v1,v2);
1459}
1460
1462
1465inline bool operator!=(const ivector_slice& v1, const srvector& v2) {
1466 return !fsp_vv_comp(v1,v2);
1467}
1468
1470
1473inline bool operator!=(const rvector_slice& v1, const sivector& v2) {
1474 return !fsp_vv_comp(v1,v2);
1475}
1476
1478
1481inline bool operator!=(const ivector_slice& v1, const sivector& v2) {
1482 return !fsp_vv_comp(v1,v2);
1483}
1484
1486
1489inline bool operator<(const sivector& v1, const sivector& v2) {
1490 return spsp_vv_less<sivector,sivector,interval>(v1,v2);
1491}
1492
1494
1497inline bool operator<(const srvector& v1, const sivector& v2) {
1498 return spsp_vv_less<srvector,sivector,interval>(v1,v2);
1499}
1500
1502
1505inline bool operator<(const srvector& v1, const ivector& v2) {
1506 return spf_vv_less<srvector,ivector,interval>(v1,v2);
1507}
1508
1510
1513inline bool operator<(const sivector& v1, const ivector& v2) {
1514 return spf_vv_less<sivector,ivector,interval>(v1,v2);
1515}
1516
1518
1521inline bool operator<(const rvector& v1, const sivector& v2) {
1522 return fsp_vv_less<rvector,sivector,interval>(v1,v2);
1523}
1524
1526
1529inline bool operator<(const ivector& v1, const sivector& v2) {
1530 return fsp_vv_less<ivector,sivector,interval>(v1,v2);
1531}
1532
1534
1537inline bool operator<(const srvector& v1, const ivector_slice& v2) {
1538 return spf_vv_less<srvector,ivector_slice,interval>(v1,v2);
1539}
1540
1542
1545inline bool operator<(const sivector& v1, const ivector_slice& v2) {
1546 return spf_vv_less<sivector,ivector_slice,interval>(v1,v2);
1547}
1548
1550
1553inline bool operator<(const rvector_slice& v1, const sivector& v2) {
1554 return fsp_vv_less<rvector_slice,sivector,interval>(v1,v2);
1555}
1556
1558
1561inline bool operator<(const ivector_slice& v1, const sivector& v2) {
1562 return fsp_vv_less<ivector_slice,sivector,interval>(v1,v2);
1563}
1564
1566
1569inline bool operator<=(const sivector& v1, const sivector& v2) {
1570 return spsp_vv_leq<sivector,sivector,interval>(v1,v2);
1571}
1572
1574
1577inline bool operator<=(const srvector& v1, const sivector& v2) {
1578 return spsp_vv_leq<srvector,sivector,interval>(v1,v2);
1579}
1580
1582
1585inline bool operator<=(const srvector& v1, const ivector& v2) {
1586 return spf_vv_leq<srvector,ivector,interval>(v1,v2);
1587}
1588
1590
1593inline bool operator<=(const sivector& v1, const ivector& v2) {
1594 return spf_vv_leq<sivector,ivector,interval>(v1,v2);
1595}
1596
1598
1601inline bool operator<=(const rvector& v1, const sivector& v2) {
1602 return fsp_vv_leq<rvector,sivector,interval>(v1,v2);
1603}
1604
1606
1609inline bool operator<=(const ivector& v1, const sivector& v2) {
1610 return fsp_vv_leq<ivector,sivector,interval>(v1,v2);
1611}
1612
1614
1617inline bool operator<=(const srvector& v1, const ivector_slice& v2) {
1618 return spf_vv_leq<srvector,ivector_slice,interval>(v1,v2);
1619}
1620
1622
1625inline bool operator<=(const sivector& v1, const ivector_slice& v2) {
1626 return spf_vv_leq<sivector,ivector_slice,interval>(v1,v2);
1627}
1628
1630
1633inline bool operator<=(const rvector_slice& v1, const sivector& v2) {
1634 return fsp_vv_leq<rvector_slice,sivector,interval>(v1,v2);
1635}
1636
1638
1641inline bool operator<=(const ivector_slice& v1, const sivector& v2) {
1642 return fsp_vv_leq<ivector_slice,sivector,interval>(v1,v2);
1643}
1644
1646
1649inline bool operator>(const sivector& v1, const sivector& v2) {
1650 return spsp_vv_greater<sivector,sivector,interval>(v1,v2);
1651}
1652
1654
1657inline bool operator>(const sivector& v1, const srvector& v2) {
1658 return spsp_vv_greater<sivector,srvector,interval>(v1,v2);
1659}
1660
1662
1665inline bool operator>(const sivector& v1, const rvector& v2) {
1666 return spf_vv_greater<sivector,rvector,interval>(v1,v2);
1667}
1668
1670
1673inline bool operator>(const sivector& v1, const ivector& v2) {
1674 return spf_vv_greater<sivector,ivector,interval>(v1,v2);
1675}
1676
1678
1681inline bool operator>(const ivector& v1, const srvector& v2) {
1682 return fsp_vv_greater<ivector,srvector,interval>(v1,v2);
1683}
1684
1686
1689inline bool operator>(const ivector& v1, const sivector& v2) {
1690 return fsp_vv_greater<ivector,sivector,interval>(v1,v2);
1691}
1692
1694
1697inline bool operator>(const sivector& v1, const rvector_slice& v2) {
1698 return spf_vv_greater<sivector,rvector_slice,interval>(v1,v2);
1699}
1700
1702
1705inline bool operator>(const sivector& v1, const ivector_slice& v2) {
1706 return spf_vv_greater<sivector,ivector_slice,interval>(v1,v2);
1707}
1708
1710
1713inline bool operator>(const ivector_slice& v1, const srvector& v2) {
1714 return fsp_vv_greater<ivector_slice,srvector,interval>(v1,v2);
1715}
1716
1718
1721inline bool operator>(const ivector_slice& v1, const sivector& v2) {
1722 return fsp_vv_greater<ivector_slice,sivector,interval>(v1,v2);
1723}
1724
1726
1729inline bool operator>=(const sivector& v1, const sivector& v2) {
1730 return spsp_vv_geq<sivector,sivector,interval>(v1,v2);
1731}
1732
1734
1737inline bool operator>=(const sivector& v1, const srvector& v2) {
1738 return spsp_vv_geq<sivector,srvector,interval>(v1,v2);
1739}
1740
1742
1745inline bool operator>=(const sivector& v1, const rvector& v2) {
1746 return spf_vv_geq<sivector,rvector,interval>(v1,v2);
1747}
1748
1750
1753inline bool operator>=(const sivector& v1, const ivector& v2) {
1754 return spf_vv_geq<sivector,ivector,interval>(v1,v2);
1755}
1756
1758
1761inline bool operator>=(const ivector& v1, const srvector& v2) {
1762 return fsp_vv_geq<ivector,srvector,interval>(v1,v2);
1763}
1764
1766
1769inline bool operator>=(const ivector& v1, const sivector& v2) {
1770 return fsp_vv_geq<ivector,sivector,interval>(v1,v2);
1771}
1772
1774
1777inline bool operator>=(const sivector& v1, const rvector_slice& v2) {
1778 return spf_vv_geq<sivector,rvector_slice,interval>(v1,v2);
1779}
1780
1782
1785inline bool operator>=(const sivector& v1, const ivector_slice& v2) {
1786 return spf_vv_geq<sivector,ivector_slice,interval>(v1,v2);
1787}
1788
1790
1793inline bool operator>=(const ivector_slice& v1, const srvector& v2) {
1794 return fsp_vv_geq<ivector_slice,srvector,interval>(v1,v2);
1795}
1796
1798
1801inline bool operator>=(const ivector_slice& v1, const sivector& v2) {
1802 return fsp_vv_geq<ivector_slice,sivector,interval>(v1,v2);
1803}
1804
1806
1811inline std::ostream& operator<<(std::ostream& os, const sivector& v) {
1812 return sp_v_output<sivector,interval>(os,v);
1813}
1814
1816
1821inline 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
2204inline 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
2215inline 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
2234inline 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
2242inline sivector operator-(const sivector_slice& v) {
2243 return sl_v_negative<sivector_slice,sivector>(v);
2244}
2245
2247inline int Lb(const sivector_slice& v) {
2248 return v.lb;
2249}
2250
2252inline int Ub(const sivector_slice& v) {
2253 return v.ub;
2254}
2255
2257inline srvector Inf(const sivector_slice& v) {
2258 return Inf(sivector(v));
2259}
2260
2262inline srvector Sup(const sivector_slice& v) {
2263 return Sup(sivector(v));
2264}
2265
2267inline 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
2278inline 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
2289inline 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
2300inline int VecLen(const sivector_slice& v) {
2301 return v.n;
2302}
2303
2305
2311inline 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
2322inline 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
2333inline 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
2344inline 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
2355inline 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
2366inline 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
2377inline 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
2388inline 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
2399inline 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
2410inline 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
2421inline 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
2432inline 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
2443inline 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
2454inline 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
2465inline 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
2476inline 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
2487inline 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
2498inline 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
2509inline 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
2520inline 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
2531inline 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
2536inline sivector operator*(const sivector_slice& v, const real& s) {
2537 return sp_vs_mult<sivector_slice,real,sivector>(v,s);
2538}
2539
2541inline sivector operator*(const sivector_slice& v, const interval& s) {
2542 return sp_vs_mult<sivector_slice,interval,sivector>(v,s);
2543}
2544
2546inline sivector operator*(const srvector_slice& v, const interval& s) {
2547 return sp_vs_mult<srvector_slice,interval,sivector>(v,s);
2548}
2549
2551inline sivector operator/(const sivector_slice& v, const real& s) {
2552 return sp_vs_div<sivector_slice,real,sivector>(v,s);
2553}
2554
2556inline sivector operator/(const sivector_slice& v, const interval& s) {
2557 return sp_vs_div<sivector_slice,interval,sivector>(v,s);
2558}
2559
2561inline sivector operator/(const srvector_slice& v, const interval& s) {
2562 return sp_vs_div<srvector_slice,interval,sivector>(v,s);
2563}
2564
2566inline sivector operator*(const real& s, const sivector_slice& v) {
2567 return sp_sv_mult<real,sivector_slice,sivector>(s,v);
2568}
2569
2571inline sivector operator*(const interval& s, const sivector_slice& v) {
2572 return sp_sv_mult<interval,sivector_slice,sivector>(s,v);
2573}
2574
2576inline sivector operator*(const interval& s, const srvector_slice& v) {
2577 return sp_sv_mult<interval,srvector_slice,sivector>(s,v);
2578}
2579
2581inline ivector operator+(const ivector& v1, const srvector_slice& v2) {
2582 return fsl_vv_add<ivector,srvector_slice,ivector>(v1,v2);
2583}
2584
2586inline ivector operator+(const rvector& v1, const sivector_slice& v2) {
2587 return fsl_vv_add<rvector,sivector_slice,ivector>(v1,v2);
2588}
2589
2591inline ivector operator+(const ivector& v1, const sivector_slice& v2) {
2592 return fsl_vv_add<ivector,sivector_slice,ivector>(v1,v2);
2593}
2594
2596inline ivector operator+(const sivector_slice& v1, const rvector& v2) {
2597 return slf_vv_add<sivector_slice,rvector,ivector>(v1,v2);
2598}
2599
2601inline ivector operator+(const srvector_slice& v1, const ivector& v2) {
2602 return slf_vv_add<srvector_slice,ivector,ivector>(v1,v2);
2603}
2604
2606inline ivector operator+(const sivector_slice& v1, const ivector& v2) {
2607 return slf_vv_add<sivector_slice,ivector,ivector>(v1,v2);
2608}
2609
2611inline ivector operator+(const ivector_slice& v1, const srvector_slice& v2) {
2612 return fsl_vv_add<ivector_slice,srvector_slice,ivector>(v1,v2);
2613}
2614
2616inline ivector operator+(const rvector_slice& v1, const sivector_slice& v2) {
2617 return fsl_vv_add<rvector_slice,sivector_slice,ivector>(v1,v2);
2618}
2619
2621inline ivector operator+(const ivector_slice& v1, const sivector_slice& v2) {
2622 return fsl_vv_add<ivector_slice,sivector_slice,ivector>(v1,v2);
2623}
2624
2626inline ivector operator+(const sivector_slice& v1, const rvector_slice& v2) {
2627 return slf_vv_add<sivector_slice,rvector_slice,ivector>(v1,v2);
2628}
2629
2631inline ivector operator+(const srvector_slice& v1, const ivector_slice& v2) {
2632 return slf_vv_add<srvector_slice,ivector_slice,ivector>(v1,v2);
2633}
2634
2636inline ivector operator+(const sivector_slice& v1, const ivector_slice& v2) {
2637 return slf_vv_add<sivector_slice,ivector_slice,ivector>(v1,v2);
2638}
2639
2641inline 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
2646inline 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
2651inline 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
2656inline sivector operator+(const sivector& v1, const srvector_slice& v2) {
2657 return spsl_vv_add<sivector,srvector_slice,sivector,interval>(v1,v2);
2658}
2659
2661inline sivector operator+(const srvector& v1, const sivector_slice& v2) {
2662 return spsl_vv_add<srvector,sivector_slice,sivector,interval>(v1,v2);
2663}
2664
2666inline sivector operator+(const sivector& v1, const sivector_slice& v2) {
2667 return spsl_vv_add<sivector,sivector_slice,sivector,interval>(v1,v2);
2668}
2669
2671inline sivector operator+(const sivector_slice& v1, const srvector& v2) {
2672 return slsp_vv_add<sivector_slice,srvector,sivector,interval>(v1,v2);
2673}
2674
2676inline sivector operator+(const srvector_slice& v1, const sivector& v2) {
2677 return slsp_vv_add<srvector_slice,sivector,sivector,interval>(v1,v2);
2678}
2679
2681inline sivector operator+(const sivector_slice& v1, const sivector& v2) {
2682 return slsp_vv_add<sivector_slice,sivector,sivector,interval>(v1,v2);
2683}
2684
2686inline ivector operator-(const ivector& v1, const srvector_slice& v2) {
2687 return fsl_vv_sub<ivector,srvector_slice,ivector>(v1,v2);
2688}
2689
2691inline ivector operator-(const rvector& v1, const sivector_slice& v2) {
2692 return fsl_vv_sub<rvector,sivector_slice,ivector>(v1,v2);
2693}
2694
2696inline ivector operator-(const ivector& v1, const sivector_slice& v2) {
2697 return fsl_vv_sub<ivector,sivector_slice,ivector>(v1,v2);
2698}
2699
2701inline ivector operator-(const sivector_slice& v1, const rvector& v2) {
2702 return slf_vv_sub<sivector_slice,rvector,ivector>(v1,v2);
2703}
2704
2706inline ivector operator-(const srvector_slice& v1, const ivector& v2) {
2707 return slf_vv_sub<srvector_slice,ivector,ivector>(v1,v2);
2708}
2709
2711inline ivector operator-(const sivector_slice& v1, const ivector& v2) {
2712 return slf_vv_sub<sivector_slice,ivector,ivector>(v1,v2);
2713}
2714
2716inline ivector operator-(const ivector_slice& v1, const srvector_slice& v2) {
2717 return fsl_vv_sub<ivector_slice,srvector_slice,ivector>(v1,v2);
2718}
2719
2721inline ivector operator-(const rvector_slice& v1, const sivector_slice& v2) {
2722 return fsl_vv_sub<rvector_slice,sivector_slice,ivector>(v1,v2);
2723}
2724
2726inline ivector operator-(const ivector_slice& v1, const sivector_slice& v2) {
2727 return fsl_vv_sub<ivector_slice,sivector_slice,ivector>(v1,v2);
2728}
2729
2731inline ivector operator-(const sivector_slice& v1, const rvector_slice& v2) {
2732 return slf_vv_sub<sivector_slice,rvector_slice,ivector>(v1,v2);
2733}
2734
2736inline ivector operator-(const srvector_slice& v1, const ivector_slice& v2) {
2737 return slf_vv_sub<srvector_slice,ivector_slice,ivector>(v1,v2);
2738}
2739
2741inline ivector operator-(const sivector_slice& v1, const ivector_slice& v2) {
2742 return slf_vv_sub<sivector_slice,ivector_slice,ivector>(v1,v2);
2743}
2744
2746inline 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
2751inline 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
2756inline 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
2761inline sivector operator-(const sivector& v1, const srvector_slice& v2) {
2762 return spsl_vv_sub<sivector,srvector_slice,sivector,interval>(v1,v2);
2763}
2764
2766inline sivector operator-(const srvector& v1, const sivector_slice& v2) {
2767 return spsl_vv_sub<srvector,sivector_slice,sivector,interval>(v1,v2);
2768}
2769
2771inline sivector operator-(const sivector& v1, const sivector_slice& v2) {
2772 return spsl_vv_sub<sivector,sivector_slice,sivector,interval>(v1,v2);
2773}
2774
2776inline sivector operator-(const sivector_slice& v1, const srvector& v2) {
2777 return slsp_vv_sub<sivector_slice,srvector,sivector,interval>(v1,v2);
2778}
2779
2781inline sivector operator-(const srvector_slice& v1, const sivector& v2) {
2782 return slsp_vv_sub<srvector_slice,sivector,sivector,interval>(v1,v2);
2783}
2784
2786inline sivector operator-(const sivector_slice& v1, const sivector& v2) {
2787 return slsp_vv_sub<sivector_slice,sivector,sivector,interval>(v1,v2);
2788}
2789
2791inline ivector operator|(const rvector& v1, const srvector_slice& v2) {
2792 return fsl_vv_hull<rvector,srvector_slice,ivector>(v1,v2);
2793}
2794
2796inline ivector operator|(const srvector_slice& v1, const rvector& v2) {
2797 return slf_vv_hull<srvector_slice,rvector,ivector>(v1,v2);
2798}
2799
2801inline ivector operator|(const rvector_slice& v1, const srvector_slice& v2) {
2802 return fsl_vv_hull<rvector_slice,srvector_slice,ivector>(v1,v2);
2803}
2804
2806inline ivector operator|(const srvector_slice& v1, const rvector_slice& v2) {
2807 return slf_vv_hull<srvector_slice,rvector_slice,ivector>(v1,v2);
2808}
2809
2811inline 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
2816inline sivector operator|(const srvector& v1, const srvector_slice& v2) {
2817 return spsl_vv_hull<srvector,srvector_slice,sivector,interval>(v1,v2);
2818}
2819
2821inline sivector operator|(const srvector_slice& v1, const srvector& v2) {
2822 return slsp_vv_hull<srvector_slice,srvector,sivector,interval>(v1,v2);
2823}
2824
2826inline ivector operator|(const ivector& v1, const srvector_slice& v2) {
2827 return fsl_vv_hull<ivector,srvector_slice,ivector>(v1,v2);
2828}
2829
2831inline ivector operator|(const rvector& v1, const sivector_slice& v2) {
2832 return fsl_vv_hull<rvector,sivector_slice,ivector>(v1,v2);
2833}
2834
2836inline ivector operator|(const ivector& v1, const sivector_slice& v2) {
2837 return fsl_vv_hull<ivector,sivector_slice,ivector>(v1,v2);
2838}
2839
2841inline ivector operator|(const sivector_slice& v1, const rvector& v2) {
2842 return slf_vv_hull<sivector_slice,rvector,ivector>(v1,v2);
2843}
2844
2846inline ivector operator|(const srvector_slice& v1, const ivector& v2) {
2847 return slf_vv_hull<srvector_slice,ivector,ivector>(v1,v2);
2848}
2849
2851inline ivector operator|(const sivector_slice& v1, const ivector& v2) {
2852 return slf_vv_hull<sivector_slice,ivector,ivector>(v1,v2);
2853}
2854
2856inline ivector operator|(const ivector_slice& v1, const srvector_slice& v2) {
2857 return fsl_vv_hull<ivector_slice,srvector_slice,ivector>(v1,v2);
2858}
2859
2861inline ivector operator|(const rvector_slice& v1, const sivector_slice& v2) {
2862 return fsl_vv_hull<rvector_slice,sivector_slice,ivector>(v1,v2);
2863}
2864
2866inline ivector operator|(const ivector_slice& v1, const sivector_slice& v2) {
2867 return fsl_vv_hull<ivector_slice,sivector_slice,ivector>(v1,v2);
2868}
2869
2871inline ivector operator|(const sivector_slice& v1, const rvector_slice& v2) {
2872 return slf_vv_hull<sivector_slice,rvector_slice,ivector>(v1,v2);
2873}
2874
2876inline ivector operator|(const srvector_slice& v1, const ivector_slice& v2) {
2877 return slf_vv_hull<srvector_slice,ivector_slice,ivector>(v1,v2);
2878}
2879
2881inline ivector operator|(const sivector_slice& v1, const ivector_slice& v2) {
2882 return slf_vv_hull<sivector_slice,ivector_slice,ivector>(v1,v2);
2883}
2884
2886inline 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
2891inline 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
2896inline 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
2901inline sivector operator|(const sivector& v1, const srvector_slice& v2) {
2902 return spsl_vv_hull<sivector,srvector_slice,sivector,interval>(v1,v2);
2903}
2904
2906inline sivector operator|(const srvector& v1, const sivector_slice& v2) {
2907 return spsl_vv_hull<srvector,sivector_slice,sivector,interval>(v1,v2);
2908}
2909
2911inline sivector operator|(const sivector& v1, const sivector_slice& v2) {
2912 return spsl_vv_hull<sivector,sivector_slice,sivector,interval>(v1,v2);
2913}
2914
2916inline sivector operator|(const sivector_slice& v1, const srvector& v2) {
2917 return slsp_vv_hull<sivector_slice,srvector,sivector,interval>(v1,v2);
2918}
2919
2921inline sivector operator|(const srvector_slice& v1, const sivector& v2) {
2922 return slsp_vv_hull<srvector_slice,sivector,sivector,interval>(v1,v2);
2923}
2924
2926inline sivector operator|(const sivector_slice& v1, const sivector& v2) {
2927 return slsp_vv_hull<sivector_slice,sivector,sivector,interval>(v1,v2);
2928}
2929
2931inline ivector operator&(const ivector& v1, const sivector_slice& v2) {
2932 return fsl_vv_intersect<ivector,sivector_slice,ivector>(v1,v2);
2933}
2934
2936inline ivector operator&(const sivector_slice& v1, const ivector& v2) {
2937 return slf_vv_intersect<sivector_slice,ivector,ivector>(v1,v2);
2938}
2939
2941inline ivector operator&(const ivector_slice& v1, const sivector_slice& v2) {
2942 return fsl_vv_intersect<ivector_slice,sivector_slice,ivector>(v1,v2);
2943}
2944
2946inline ivector operator&(const sivector_slice& v1, const ivector_slice& v2) {
2947 return slf_vv_intersect<sivector_slice,ivector_slice,ivector>(v1,v2);
2948}
2949
2951inline 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
2956inline sivector operator&(const sivector& v1, const sivector_slice& v2) {
2957 return spsl_vv_intersect<sivector,sivector_slice,sivector,interval>(v1,v2);
2958}
2959
2961inline 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
3041inline bool operator==(const sivector_slice& v1, const srvector_slice& v2) {
3042 return slsl_vv_comp(v1,v2);
3043}
3044
3046
3049inline bool operator==(const srvector_slice& v1, const sivector_slice& v2) {
3050 return slsl_vv_comp(v1,v2);
3051}
3052
3054
3057inline bool operator==(const sivector_slice& v1, const sivector_slice& v2) {
3058 return slsl_vv_comp(v1,v2);
3059}
3060
3062
3065inline bool operator==(const sivector_slice& v1, const srvector& v2) {
3066 return slsp_vv_comp(v1,v2);
3067}
3068
3070
3073inline bool operator==(const srvector_slice& v1, const sivector& v2) {
3074 return slsp_vv_comp(v1,v2);
3075}
3076
3078
3081inline bool operator==(const sivector_slice& v1, const sivector& v2) {
3082 return slsp_vv_comp(v1,v2);
3083}
3084
3086
3089inline bool operator==(const sivector& v1, const srvector_slice& v2) {
3090 return spsl_vv_comp(v1,v2);
3091}
3092
3094
3097inline bool operator==(const srvector& v1, const sivector_slice& v2) {
3098 return spsl_vv_comp(v1,v2);
3099}
3100
3102
3105inline bool operator==(const sivector& v1, const sivector_slice& v2) {
3106 return spsl_vv_comp(v1,v2);
3107}
3108
3110
3113inline bool operator==(const sivector_slice& v1, const rvector& v2) {
3114 return slf_vv_comp(v1,v2);
3115}
3116
3118
3121inline bool operator==(const srvector_slice& v1, const ivector& v2) {
3122 return slf_vv_comp(v1,v2);
3123}
3124
3126
3129inline bool operator==(const sivector_slice& v1, const ivector& v2) {
3130 return slf_vv_comp(v1,v2);
3131}
3132
3134
3137inline bool operator==(const ivector& v1, const srvector_slice& v2) {
3138 return fsl_vv_comp(v1,v2);
3139}
3140
3142
3145inline bool operator==(const rvector& v1, const sivector_slice& v2) {
3146 return fsl_vv_comp(v1,v2);
3147}
3148
3150
3153inline bool operator==(const ivector& v1, const sivector_slice& v2) {
3154 return fsl_vv_comp(v1,v2);
3155}
3156
3158
3161inline bool operator==(const sivector_slice& v1, const rvector_slice& v2) {
3162 return slf_vv_comp(v1,v2);
3163}
3164
3166
3169inline bool operator==(const srvector_slice& v1, const ivector_slice& v2) {
3170 return slf_vv_comp(v1,v2);
3171}
3172
3174
3177inline bool operator==(const sivector_slice& v1, const ivector_slice& v2) {
3178 return slf_vv_comp(v1,v2);
3179}
3180
3182
3185inline bool operator==(const ivector_slice& v1, const srvector_slice& v2) {
3186 return fsl_vv_comp(v1,v2);
3187}
3188
3190
3193inline bool operator==(const rvector_slice& v1, const sivector_slice& v2) {
3194 return fsl_vv_comp(v1,v2);
3195}
3196
3198
3201inline bool operator==(const ivector_slice& v1, const sivector_slice& v2) {
3202 return fsl_vv_comp(v1,v2);
3203}
3204
3206
3209inline bool operator!=(const sivector_slice& v1, const srvector_slice& v2) {
3210 return !slsl_vv_comp(v1,v2);
3211}
3212
3214
3217inline bool operator!=(const srvector_slice& v1, const sivector_slice& v2) {
3218 return !slsl_vv_comp(v1,v2);
3219}
3220
3222
3225inline bool operator!=(const sivector_slice& v1, const sivector_slice& v2) {
3226 return !slsl_vv_comp(v1,v2);
3227}
3228
3230
3233inline bool operator!=(const sivector_slice& v1, const rvector& v2) {
3234 return !slf_vv_comp(v1,v2);
3235}
3236
3238
3241inline bool operator!=(const srvector_slice& v1, const ivector& v2) {
3242 return !slf_vv_comp(v1,v2);
3243}
3244
3246
3249inline bool operator!=(const sivector_slice& v1, const ivector& v2) {
3250 return !slf_vv_comp(v1,v2);
3251}
3252
3254
3257inline bool operator!=(const ivector& v1, const srvector_slice& v2) {
3258 return !fsl_vv_comp(v1,v2);
3259}
3260
3262
3265inline bool operator!=(const rvector& v1, const sivector_slice& v2) {
3266 return !fsl_vv_comp(v1,v2);
3267}
3268
3270
3273inline bool operator!=(const ivector& v1, const sivector_slice& v2) {
3274 return !fsl_vv_comp(v1,v2);
3275}
3276
3278
3281inline bool operator!=(const sivector_slice& v1, const srvector& v2) {
3282 return !slsp_vv_comp(v1,v2);
3283}
3284
3286
3289inline bool operator!=(const srvector_slice& v1, const sivector& v2) {
3290 return !slsp_vv_comp(v1,v2);
3291}
3292
3294
3297inline bool operator!=(const sivector_slice& v1, const sivector& v2) {
3298 return !slsp_vv_comp(v1,v2);
3299}
3300
3302
3305inline bool operator!=(const sivector& v1, const srvector_slice& v2) {
3306 return !spsl_vv_comp(v1,v2);
3307}
3308
3310
3313inline bool operator!=(const srvector& v1, const sivector_slice& v2) {
3314 return !spsl_vv_comp(v1,v2);
3315}
3316
3318
3321inline bool operator!=(const sivector& v1, const sivector_slice& v2) {
3322 return !spsl_vv_comp(v1,v2);
3323}
3324
3326
3329inline bool operator!=(const sivector_slice& v1, const rvector_slice& v2) {
3330 return !slf_vv_comp(v1,v2);
3331}
3332
3334
3337inline bool operator!=(const srvector_slice& v1, const ivector_slice& v2) {
3338 return !slf_vv_comp(v1,v2);
3339}
3340
3342
3345inline bool operator!=(const sivector_slice& v1, const ivector_slice& v2) {
3346 return !slf_vv_comp(v1,v2);
3347}
3348
3350
3353inline bool operator!=(const ivector_slice& v1, const srvector_slice& v2) {
3354 return !fsl_vv_comp(v1,v2);
3355}
3356
3358
3361inline bool operator!=(const rvector_slice& v1, const sivector_slice& v2) {
3362 return !fsl_vv_comp(v1,v2);
3363}
3364
3366
3369inline bool operator!=(const ivector_slice& v1, const sivector_slice& v2) {
3370 return !fsl_vv_comp(v1,v2);
3371}
3372
3374
3377inline 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
3385inline 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
3393inline bool operator<(const srvector_slice& v1, const sivector& v2) {
3394 return slsp_vv_less<srvector_slice,sivector,interval>(v1,v2);
3395}
3396
3398
3401inline bool operator<(const sivector_slice& v1, const sivector& v2) {
3402 return slsp_vv_less<sivector_slice,sivector,interval>(v1,v2);
3403}
3404
3406
3409inline bool operator<(const srvector& v1, const sivector_slice& v2) {
3410 return spsl_vv_less<srvector,sivector_slice,interval>(v1,v2);
3411}
3412
3414
3417inline bool operator<(const sivector& v1, const sivector_slice& v2) {
3418 return spsl_vv_less<sivector,sivector_slice,interval>(v1,v2);
3419}
3420
3422
3425inline bool operator<(const srvector_slice& v1, const ivector& v2) {
3426 return slf_vv_less<srvector_slice,ivector,interval>(v1,v2);
3427}
3428
3430
3433inline bool operator<(const sivector_slice& v1, const ivector& v2) {
3434 return slf_vv_less<sivector_slice,ivector,interval>(v1,v2);
3435}
3436
3438
3441inline bool operator<(const rvector& v1, const sivector_slice& v2) {
3442 return fsl_vv_less<rvector,sivector_slice,interval>(v1,v2);
3443}
3444
3446
3449inline bool operator<(const ivector& v1, const sivector_slice& v2) {
3450 return fsl_vv_less<ivector,sivector_slice,interval>(v1,v2);
3451}
3452
3454
3457inline 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
3465inline 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
3473inline 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
3481inline 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
3489inline 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
3497inline bool operator<=(const srvector_slice& v1, const sivector& v2) {
3498 return slsp_vv_leq<srvector_slice,sivector,interval>(v1,v2);
3499}
3500
3502
3505inline bool operator<=(const sivector_slice& v1, const sivector& v2) {
3506 return slsp_vv_leq<sivector_slice,sivector,interval>(v1,v2);
3507}
3508
3510
3513inline bool operator<=(const srvector& v1, const sivector_slice& v2) {
3514 return spsl_vv_leq<srvector,sivector_slice,interval>(v1,v2);
3515}
3516
3518
3521inline bool operator<=(const sivector& v1, const sivector_slice& v2) {
3522 return spsl_vv_leq<sivector,sivector_slice,interval>(v1,v2);
3523}
3524
3526
3529inline bool operator<=(const srvector_slice& v1, const ivector& v2) {
3530 return slf_vv_leq<srvector_slice,ivector,interval>(v1,v2);
3531}
3532
3534
3537inline bool operator<=(const sivector_slice& v1, const ivector& v2) {
3538 return slf_vv_leq<sivector_slice,ivector,interval>(v1,v2);
3539}
3540
3542
3545inline bool operator<=(const rvector& v1, const sivector_slice& v2) {
3546 return fsl_vv_leq<rvector,sivector_slice,interval>(v1,v2);
3547}
3548
3550
3553inline bool operator<=(const ivector& v1, const sivector_slice& v2) {
3554 return fsl_vv_leq<ivector,sivector_slice,interval>(v1,v2);
3555}
3556
3558
3561inline 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
3569inline 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
3577inline 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
3585inline 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
3593inline 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
3601inline 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
3609inline bool operator>(const sivector_slice& v1, const srvector& v2) {
3610 return slsp_vv_greater<sivector_slice,srvector,interval>(v1,v2);
3611}
3612
3614
3617inline bool operator>(const sivector_slice& v1, const sivector& v2) {
3618 return slsp_vv_greater<sivector_slice,sivector,interval>(v1,v2);
3619}
3620
3622
3625inline bool operator>(const sivector& v1, const srvector_slice& v2) {
3626 return spsl_vv_greater<sivector,srvector_slice,interval>(v1,v2);
3627}
3628
3630
3633inline bool operator>(const sivector& v1, const sivector_slice& v2) {
3634 return spsl_vv_greater<sivector,sivector_slice,interval>(v1,v2);
3635}
3636
3638
3641inline bool operator>(const sivector_slice& v1, const rvector& v2) {
3642 return slf_vv_greater<sivector_slice,rvector,interval>(v1,v2);
3643}
3644
3646
3649inline bool operator>(const sivector_slice& v1, const ivector& v2) {
3650 return slf_vv_greater<sivector_slice,ivector,interval>(v1,v2);
3651}
3652
3654
3657inline bool operator>(const ivector& v1, const srvector_slice& v2) {
3658 return fsl_vv_greater<ivector,srvector_slice,interval>(v1,v2);
3659}
3660
3662
3665inline bool operator>(const ivector& v1, const sivector_slice& v2) {
3666 return fsl_vv_greater<ivector,sivector_slice,interval>(v1,v2);
3667}
3668
3670
3673inline 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
3681inline 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
3689inline 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
3697inline 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
3705inline 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
3713inline 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
3721inline bool operator>=(const sivector_slice& v1, const srvector& v2) {
3722 return slsp_vv_geq<sivector_slice,srvector,interval>(v1,v2);
3723}
3724
3726
3729inline bool operator>=(const sivector_slice& v1, const sivector& v2) {
3730 return slsp_vv_geq<sivector_slice,sivector,interval>(v1,v2);
3731}
3732
3734
3737inline bool operator>=(const sivector& v1, const srvector_slice& v2) {
3738 return spsl_vv_geq<sivector,srvector_slice,interval>(v1,v2);
3739}
3740
3742
3745inline bool operator>=(const sivector& v1, const sivector_slice& v2) {
3746 return spsl_vv_geq<sivector,sivector_slice,interval>(v1,v2);
3747}
3748
3750
3753inline bool operator>=(const sivector_slice& v1, const rvector& v2) {
3754 return slf_vv_geq<sivector_slice,rvector,interval>(v1,v2);
3755}
3756
3758
3761inline bool operator>=(const sivector_slice& v1, const ivector& v2) {
3762 return slf_vv_geq<sivector_slice,ivector,interval>(v1,v2);
3763}
3764
3766
3769inline bool operator>=(const ivector& v1, const srvector_slice& v2) {
3770 return fsl_vv_geq<ivector,srvector_slice,interval>(v1,v2);
3771}
3772
3774
3777inline bool operator>=(const ivector& v1, const sivector_slice& v2) {
3778 return fsl_vv_geq<ivector,sivector_slice,interval>(v1,v2);
3779}
3780
3782
3785inline 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
3793inline 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
3801inline 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
3809inline 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
3819inline std::ostream& operator<<(std::ostream& os, const sivector_slice& v) {
3820 return sl_v_output<sivector_slice,interval>(os,v);
3821}
3822
3824
3829inline std::istream& operator>>(std::istream& is, sivector_slice& v) {
3830 return sl_v_input<sivector_slice,interval>(is,v);
3831}
3832
3834
3837inline 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
3845inline 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
3853inline 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
3861inline 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
3869inline 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
3877inline 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
3885inline 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
3893inline 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
3901inline 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
3909inline 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
3917inline 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
3925inline 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
3933inline 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
3941inline 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
3949inline 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
3957inline 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
3965inline 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
3973inline 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
3981inline 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
3989inline 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
3997inline 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
4005inline 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
4013inline 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
4021inline 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
4029inline 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
4037inline 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
4045inline 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
4053inline 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
4061inline 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
4069inline 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
4077inline 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
4085inline 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
4093inline 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
4101inline 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
4109inline 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
4117inline 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
4125inline 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
4136inline 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
4147inline 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
4158inline 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
4169inline 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
4180inline 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
4191inline 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
4202inline 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
4213inline 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
4224inline 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
4235inline 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
4246inline 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
4257inline 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
4268inline 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
4279inline 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
4290inline 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
4301inline 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
4312inline 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
4323inline 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
4334inline 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
4345inline 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
4356inline 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
4367inline 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
4378inline 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
4389inline 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
4400inline 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
4411inline 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
4422inline 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
4433inline 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
4444inline 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
4455inline 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
4466inline 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
4477inline 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
4488inline 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
4499inline 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
4510inline 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
The Data Type cidotprecision.
Definition: cidot.hpp:58
int get_k() const
Get currently set precision for computation of dot products.
Definition: cidot.hpp:89
The Data Type civector_slice.
Definition: civector.hpp:1015
The Data Type civector.
Definition: civector.hpp:57
The Data Type idotprecision.
Definition: idot.hpp:48
void set_k(unsigned int i)
Set precision for computation of dot products.
Definition: idot.hpp:88
The Scalar Type interval.
Definition: interval.hpp:55
The Data Type intmatrix.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector_slice.
Definition: ivector.hpp:963
ivector_slice & operator|=(const ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: ivector.inl:726
ivector_slice & operator+=(const ivector &rv) noexcept
Implementation of addition and allocation operation.
Definition: ivector.inl:610
ivector_slice & operator-=(const ivector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: ivector.inl:669
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
Definition: sivector.hpp:2194
ivector_slice & operator&=(const ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: ivector.inl:783
The Data Type ivector.
Definition: ivector.hpp:55
ivector & operator|=(const srvector &)
Implementation of assignment and hull operator
Definition: sivector.hpp:1221
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator
Definition: sivector.hpp:1205
ivector & operator&=(const sivector &)
Implementation of assignment and intersection operator
Definition: sivector.hpp:1237
ivector & operator=(const ivector &rv) noexcept
Implementation of standard assigning operator.
Definition: ivector.inl:263
ivector & operator+=(const srvector &)
Implementation of assignment and addition operator
Definition: sivector.hpp:1189
ivector() noexcept
Constructor of class ivector.
Definition: ivector.inl:31
The Scalar Type real.
Definition: real.hpp:114
The Data Type rvector_slice.
Definition: rvector.hpp:1064
The Data Type rvector.
Definition: rvector.hpp:58
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
A sparse complex interval vector.
Definition: scivector.hpp:62
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
friend srvector Sup(const sivector_slice &)
Returns the supremum of the vector slice v.
Definition: sivector.hpp:2262
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
friend int Lb(const sivector_slice &)
Returns the lower index bound of the vector slice v.
Definition: sivector.hpp:2247
sivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: sivector.hpp:1980
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
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
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
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
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
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
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
sivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1955
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
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
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
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
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
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
sivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1960
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
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
sivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1950
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
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
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
friend srvector mid(const sivector_slice &)
Computes the midpoint vector of v.
Definition: sivector.hpp:2278
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
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
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
friend srvector diam(const sivector_slice &)
Computes the diameter of v.
Definition: sivector.hpp:2289
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
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
sivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1970
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
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
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
sivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1965
sivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1945
sivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
Definition: sivector.hpp:1985
sivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1940
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
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
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
sivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
Definition: sivector.hpp:1930
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
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
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
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
sivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: sivector.hpp:1975
sivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
Definition: sivector.hpp:1935
friend int VecLen(const sivector_slice &)
Returns the length of the vector slice.
Definition: sivector.hpp:2300
friend srvector Inf(const sivector_slice &)
Returns the infimum vector slice v.
Definition: sivector.hpp:2257
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
friend int Ub(const sivector_slice &)
Returns the upper index bound of the vector slice v.
Definition: sivector.hpp:2252
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
A sparse interval vector.
Definition: sivector.hpp:59
sivector & operator|=(const srvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:445
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
sivector()
Default constructor, creates an empty vector of size 0.
Definition: sivector.hpp:69
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
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
friend int VecLen(const sivector &)
Returns the length of the vector (the dimension)
Definition: sivector.hpp:673
friend int Ub(const sivector &)
Returns the upper index bound of the vector v.
Definition: sivector.hpp:566
sivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:395
friend srvector mid(const sivector &)
Compute the midpoint vector of v.
Definition: sivector.hpp:650
sivector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:375
sivector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition: sivector.hpp:345
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: sivector.hpp:191
friend sivector Re(const scivector &)
Returns the real part of the vector v.
Definition: scivector.hpp:908
friend void SetUb(sivector &, const int)
Sets the upper index bound of the vector v to i.
Definition: sivector.hpp:555
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
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
sivector & operator|=(const sivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:450
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
sivector & operator&=(const ivector_slice &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: sivector.hpp:455
sivector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:365
friend srvector diam(const sivector &)
Computes the diameter of v.
Definition: sivector.hpp:662
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
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
friend void SetLb(sivector &, const int)
Sets the lower index bound of the vector v to i.
Definition: sivector.hpp:546
sivector & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:370
sivector & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector.
Definition: sivector.hpp:350
sivector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: sivector.hpp:219
sivector(const srmatrix_subv &A)
Creates a sparse interval vector out of a row or column of a sparse real matrix.
sivector & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:380
friend int Lb(const sivector &)
Returns the lower index bound of the vector v.
Definition: sivector.hpp:561
sivector & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:410
sivector & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:390
sivector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:415
sivector & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:400
friend srvector Sup(const sivector &)
Returns the supremum of the interval vector as a new sparse point vector.
Definition: sivector.hpp:604
sivector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition: sivector.hpp:310
sivector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:405
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
sivector & operator|=(const rvector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:425
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
friend srvector absmin(const sivector &)
Computes the component-wise minimum absolute values for a vector v.
Definition: sivector.hpp:626
sivector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition: sivector.hpp:334
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
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
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
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
friend srvector Inf(const sivector &)
Returns the infimum of the interval vector as a new sparse point vector.
Definition: sivector.hpp:593
sivector(const int s)
Constructor for creating an empty vector of size s.
Definition: sivector.hpp:73
sivector & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: sivector.hpp:420
sivector & operator&=(const sivector &v)
Operator for element-wise intersection with another vector, result is assigned to the vector.
Definition: sivector.hpp:460
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
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
Definition: scivector.hpp:919
sivector & operator=(const interval &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: sivector.hpp:224
sivector & operator=(const srvector &v)
Assign a sparse real vector to a sparse interval vector.
Definition: sivector.hpp:208
friend srvector absmax(const sivector &)
Computes the component-wise maximum absolute values for a vector v.
Definition: sivector.hpp:638
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
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
friend sivector Blow(const sivector &, const real &)
Performs an epsilon inflation of the vector v.
Definition: sivector.hpp:678
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
friend sivector abs(const sivector &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition: sivector.hpp:615
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
sivector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: sivector.hpp:385
sivector(const srvector &v)
Creates a sparse interval vector out of a sparse real vector.
Definition: sivector.hpp:127
std::vector< interval > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: sivector.hpp:157
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
sivector & operator|=(const ivector &v)
Operator for element-wise convex hull with another vector, result is assigned to the vector.
Definition: sivector.hpp:430
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
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
A sparse real vector.
Definition: srvector.hpp:58
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: srvector.hpp:170
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition: srvector.hpp:160
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
rvector absmax(const imatrix_subv &mv) noexcept
Returns the absolute maximum value of the matrix.
Definition: imatrix.inl:502
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
rvector absmin(const imatrix_subv &mv) noexcept
Returns the absolute minimum value of the matrix.
Definition: imatrix.inl:496
real AbsMax(const interval &x)
Computes the greatest absolute value .
Definition: interval.cpp:303
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
int Zero(ivector &x)
Checks if vector is zero vector.
Definition: ivector.cpp:80
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition: interval.cpp:293