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.
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.
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.
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
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator
ivector & operator&=(const sivector &)
Implementation of assignment and intersection operator
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
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.
A sparse complex interval vector.
Definition scivector.hpp:62
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
friend srvector mid(const sivector_slice &)
Computes the midpoint vector of v.
sivector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
sivector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend int Ub(const sivector_slice &)
Returns the upper index bound of the vector slice v.
sivector_slice & operator&=(const sivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
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.
sivector_slice & operator|=(const srvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator-=(const sivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend sivector abs(const sivector_slice &)
Computes the component-wise absolute values as the interval hull of for a vector v.
friend srvector diam(const sivector_slice &)
Computes the diameter of v.
sivector_slice & operator|=(const rvector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator=(const sivector &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator&=(const ivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
sivector_slice & operator+=(const sivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
sivector_slice & operator+=(const sivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator|=(const rvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator|=(const srvector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
sivector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator+=(const ivector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator-=(const ivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
sivector_slice & operator-=(const sivector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
sivector_slice & operator-=(const ivector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
sivector_slice & operator|=(const sivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
friend int VecLen(const sivector_slice &)
Returns the length of the vector slice.
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...
sivector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
sivector_slice & operator&=(const ivector_slice &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
sivector_slice & operator+=(const ivector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator=(const ivector &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator=(const sivector_slice &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator*=(const interval &s)
Operator for multiplication with an interval, result is assigned to the vector slice.
sivector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator&=(const sivector &v)
Operator for element-wise intersection with a vector, result is assigned to the vector slice.
interval operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
sivector_slice & operator|=(const ivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
friend srvector Inf(const sivector_slice &)
Returns the infimum vector slice v.
interval & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
sivector_slice & operator|=(const ivector &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
sivector_slice & operator/=(const interval &s)
Operator for division of each element of the vector slice with an interval, result is assigned to the...
friend srvector Sup(const sivector_slice &)
Returns the supremum of the vector slice v.
friend int Lb(const sivector_slice &)
Returns the lower index bound of the vector slice v.
sivector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
sivector_slice & operator=(const ivector_slice &v)
Overwrite the vector slice with the elements of v.
sivector_slice & operator=(const interval &v)
Assigns v to all elements of the vector slice.
sivector_slice & operator|=(const sivector_slice &v)
Operator for element-wise convex hull with a vector, result is assigned to the vector slice.
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
friend sivector Im(const scivector &)
Returns the imaginary part of the vector v.
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 srvector Inf(const sivector &)
Returns the infimum of the interval vector as a new sparse point vector.
Definition sivector.hpp:593
sivector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition sivector.hpp:395
friend void SetLb(sivector &, const int)
Sets the lower index bound of the vector v to i.
Definition sivector.hpp:546
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 srvector Sup(const sivector &)
Returns the supremum of the interval vector as a new sparse point vector.
Definition sivector.hpp:604
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
friend int Ub(const sivector &)
Returns the upper index bound of the vector v.
Definition sivector.hpp:566
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
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 srvector mid(const sivector &)
Compute the midpoint vector of v.
Definition sivector.hpp:650
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
friend srvector diam(const sivector &)
Computes the diameter of v.
Definition sivector.hpp:662
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 void SetUb(sivector &, const int)
Sets the upper index bound of the vector v to i.
Definition sivector.hpp:555
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 absmin(const sivector &)
Computes the component-wise minimum absolute values for a vector v.
Definition sivector.hpp:626
friend int Lb(const sivector &)
Returns the lower index bound of the vector v.
Definition sivector.hpp:561
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
friend sivector Blow(const sivector &, const real &)
Performs an epsilon inflation of the vector v.
Definition sivector.hpp:678
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
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
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
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 sivector Re(const scivector &)
Returns the real part of the vector v.
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
friend sivector abs(const sivector &)
Computes the component-wise absolute values as the interval hull of for a vector v.
Definition sivector.hpp:615
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
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 srvector absmax(const sivector &)
Computes the component-wise maximum absolute values for a vector v.
Definition sivector.hpp:638
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
friend int VecLen(const sivector &)
Returns the length of the vector (the dimension)
Definition sivector.hpp:673
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.
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.
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.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
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.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
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.
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition interval.cpp:293