C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
scvector.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: scvector.hpp,v 1.17 2014/01/30 17:23:48 cxsc Exp $ */
25
26#ifndef _CXSC_SCVECTOR_HPP_INCLUDED
27#define _CXSC_SCVECTOR_HPP_INCLUDED
28
29#include <complex.hpp>
30#include <cvector.hpp>
31#include <vector>
32#include <iostream>
33#include <srvector.hpp>
34#include <sparsecdot.hpp>
35#include <sparsevector.hpp>
36
37namespace cxsc {
38
39class srvector_slice;
40class srmatrix;
41class srmatrix_slice;
42class srmatrix_subv;
43class scvector_slice;
44class scmatrix;
45class scmatrix_slice;
46class scmatrix_subv;
47class scivector;
48class scivector_slice;
49class scimatrix;
50class scimatrix_slice;
51class scimatrix_subv;
52
54
58class scvector {
59 private:
60 std::vector<int> p;
61 std::vector<complex> x;
62 int lb;
63 int ub;
64 int n;
65
66 public:
68 scvector() : lb(0), ub(-1) , n(0) {
69 }
70
72 explicit scvector(const int s) : lb(1), ub(s), n(s) {
73 p.reserve((int)(s*0.1));
74 x.reserve((int)(s*0.1));
75 }
76
78 scvector(const int s, const int b) : lb(1), ub(s), n(s) {
79 p.reserve(b);
80 x.reserve(b);
81 }
82
84 scvector(const cvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
85 for(int i=lb ; i<=ub ; i++) {
86 if(v[i] != 0.0) {
87 p.push_back(i-lb);
88 x.push_back(v[i]);
89 }
90 }
91 }
92
94 scvector(const rvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
95 for(int i=lb ; i<=ub ; i++) {
96 if(v[i] != 0.0) {
97 p.push_back(i-lb);
98 x.push_back(complex(v[i]));
99 }
100 }
101 }
102
104 scvector(const int n, const int nnz, const intvector& index, const cvector& values) : lb(1), ub(n) {
105 this->n = n;
106 for(int i=0 ; i<nnz ; i++) {
107 if(values[i+Lb(values)] != 0.0) {
108 p.push_back(index[i+Lb(index)]);
109 x.push_back(values[i+Lb(values)]);
110 }
111 }
112 }
113
115 scvector(const int n, const int nnz, const int* index, const complex* values) : lb(1), ub(n) {
116 this->n = n;
117 for(int i=0 ; i<nnz ; i++) {
118 if(values[i] != 0.0) {
119 p.push_back(index[i]);
120 x.push_back(values[i]);
121 }
122 }
123 }
124
126 scvector(const srvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
127 x.reserve(v.get_nnz());
128 for(int i=0 ; i<v.get_nnz() ; i++)
129 x.push_back(complex(v.x[i]));
130 }
131
133 scvector(const srvector_slice&);
135 scvector(const scvector_slice&);
139 scvector(const scmatrix_subv& A);
140
142
147 std::vector<int>& row_indices() {
148 return p;
149 }
150
152
155 std::vector<complex>& values() {
156 return x;
157 }
158
160
165 const std::vector<int>& row_indices() const {
166 return p;
167 }
168
170
173 const std::vector<complex>& values() const {
174 return x;
175 }
176
178 int get_nnz() const {
179 return x.size();
180 }
181
183 real density() const {
184 return (double)x.size()/n;
185 }
186
188 void dropzeros() {
189 for(int i=0 ; i<get_nnz() ; i++) {
190 if(x[i] == 0.0) {
191 x.erase(x.begin()+i);
192 p.erase(p.begin()+i);
193 }
194 }
195 }
196
199 n = v.n;
200 p = v.p;
201 x.clear();
202 x.reserve(v.get_nnz());
203 for(unsigned int i=0 ; i<v.x.size() ; i++)
204 x[i] = complex(v.x[i]);
205 return *this;
206 }
207
210 return sp_vs_assign<scvector,real,complex>(*this,v);
211 }
212
215 return sp_vs_assign<scvector,complex,complex>(*this,v);
216 }
217
220 return spf_vv_assign<scvector,rvector,complex>(*this,v);
221 }
222
225 return spf_vv_assign<scvector,cvector,complex>(*this,v);
226 }
227
230 return spf_vv_assign<scvector,rvector_slice,complex>(*this,v);
231 }
232
235 return spf_vv_assign<scvector,cvector_slice,complex>(*this,v);
236 }
237
242
244
248 complex& operator[](const int i) {
249#if(CXSC_INDEX_CHECK)
250 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector::operator[](const int)"));
251#endif
252 int k;
253
254 for(k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
255 if(p[k] == i-lb)
256 return x[k];
257 }
258
259 p.insert(p.begin() + k, i-lb);
260 x.insert(x.begin() + k, complex(0.0));
261
262 return x[k];
263 }
264
266
270 complex operator[](const int i) const {
271#if(CXSC_INDEX_CHECK)
272 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector::operator[](const int)"));
273#endif
274 return (*this)(i);
275 }
276
278
282 const complex operator()(const int i) const {
283#if(CXSC_INDEX_CHECK)
284 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector::operator()(const int)"));
285#endif
286 complex r(0.0);
287
288 for(int k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
289 if(p[k] == i-lb)
290 r = x[k];
291 }
292
293 return r;
294 }
295
297
301 scvector v(n,get_nnz());
302 intvector pinv = perminv(per);
303
304 std::map<int,complex> work;
305 for(int i=0 ; i<get_nnz() ; i++)
306 work.insert(std::make_pair(pinv[Lb(pinv)+p[i]], x[i]));
307
308 for(std::map<int,complex>::iterator it=work.begin() ; it!=work.end() ; it++) {
309 v.p.push_back(it->first);
310 v.x.push_back(it->second);
311 }
312
313 return v;
314 }
315
317
324 intvector p = permvec(P);
325 return (*this)(p);
326 }
327
329
331 scvector_slice operator()(const int, const int);
332
335 return sp_vs_multassign(*this,s);
336 }
337
340 return sp_vs_multassign(*this,s);
341 }
342
345 return sp_vs_divassign(*this,s);
346 }
347
350 return sp_vs_divassign(*this,s);
351 }
352
355 return spf_vv_addassign(*this,v);
356 }
357
360 return spf_vv_addassign(*this,v);
361 }
362
365 return spf_vv_addassign(*this,v);
366 }
367
370 return spf_vv_addassign(*this,v);
371 }
372
375 return spsp_vv_addassign(*this,v);
376 }
377
380 return spsp_vv_addassign(*this,v);
381 }
382
383
386 return spf_vv_subassign(*this,v);
387 }
388
391 return spf_vv_subassign(*this,v);
392 }
393
396 return spf_vv_subassign(*this,v);
397 }
398
401 return spf_vv_subassign(*this,v);
402 }
403
406 return spsp_vv_subassign(*this,v);
407 }
408
411 return spsp_vv_subassign(*this,v);
412 }
413
422
423 friend void SetLb(scvector&, const int);
424 friend void SetUb(scvector&, const int);
425 friend int Lb(const scvector&);
426 friend int Ub(const scvector&);
427 friend srvector Re(const scvector&);
428 friend srvector Im (const scvector&);
429 friend scvector Inf(const scivector&);
430 friend scvector Sup (const scivector&);
431 friend scvector mid(const scivector&);
432 friend scvector diam(const scivector&);
433 friend scvector mid(const scivector_slice&);
434 friend scvector diam(const scivector_slice&);
435 friend int VecLen(const scvector&);
436 friend srvector abs(const scvector&);
437
438 friend class srvector_slice;
439 friend class scvector_slice;
440 friend class scivector_slice;
441 friend class scivector;
442 friend class cvector;
443 friend class cvector_slice;
444 friend class civector;
445 friend class civector_slice;
446
447#include "vector_friend_declarations.inl"
448};
449
450inline cvector::cvector(const scvector& v) {
451 l = v.lb;
452 u = v.ub;
453 size = v.n;
454 dat = new complex[v.n];
455 for(int i=0 ; i<v.n ; i++)
456 dat[i] = 0.0;
457 for(int i=0 ; i<v.get_nnz() ; i++)
458 dat[v.p[i]] = v.x[i];
459}
460
461inline cvector::cvector(const srvector& v) {
462 l = v.lb;
463 u = v.ub;
464 size = v.n;
465 dat = new complex[v.n];
466 for(int i=0 ; i<v.n ; i++)
467 dat[i] = 0.0;
468 for(int i=0 ; i<v.get_nnz() ; i++)
469 dat[v.p[i]] = v.x[i];
470}
471
473 return fsp_vv_assign<cvector,scvector,complex>(*this,v);
474}
475
477 return fsl_vv_assign<cvector,scvector_slice,complex>(*this,v);
478}
479
481 return fsp_vv_assign<cvector,srvector,complex>(*this,v);
482}
483
485 return fsl_vv_assign<cvector,srvector_slice,complex>(*this,v);
486}
487
489
492inline void SetLb(scvector& v, const int i) {
493 v.lb = i;
494 v.ub = v.lb + v.n - 1;
495}
496
498
501inline void SetUb(scvector& v, const int j) {
502 v.ub = j;
503 v.lb = v.ub - v.n + 1;
504}
505
507inline int Lb(const scvector& v) {
508 return v.lb;
509}
510
512inline int Ub(const scvector& v) {
513 return v.ub;
514}
515
517inline srvector Re(const scvector& v) {
518 srvector res(v.n, v.get_nnz());
519 res.lb = v.lb;
520 res.ub = v.ub;
521 res.p = v.p;
522 for(int i=0 ; i<v.get_nnz() ; i++)
523 res.x[i] = Re(v.x[i]);
524 return res;
525}
526
528inline srvector Im(const scvector& v) {
529 srvector res(v.n, v.get_nnz());
530 res.lb = v.lb;
531 res.ub = v.ub;
532 res.p = v.p;
533 for(int i=0 ; i<v.get_nnz() ; i++)
534 res.x[i] = Im(v.x[i]);
535 return res;
536}
537
539inline srvector abs(const scvector& v) {
540 srvector ret(VecLen(v));
541 const std::vector<int>& rv = v.row_indices();
542 const std::vector<complex>& xv = v.values();
543 std::vector<int>& r = ret.row_indices();
544 std::vector<real>& x = ret.values();
545
546 for(unsigned int i=0 ; i<xv.size() ; i++) {
547 x.push_back(abs(xv[i]));
548 r.push_back(rv[i]);
549 }
550
551 return ret;
552}
553
555inline int VecLen(const scvector& v) {
556 return v.n;
557}
558
560inline void Resize(scvector& v) {
561 sp_v_resize(v);
562}
563
565
568inline void Resize(scvector& v, const int n) {
569 sp_v_resize(v,n);
570}
571
573
577inline void Resize(scvector& v, const int l, const int u) {
578 sp_v_resize(v,l,u);
579}
580
582inline scvector operator-(const scvector& v) {
583 return sp_v_negative(v);
584}
585
587
593inline complex operator*(const scvector& v1, const cvector& v2) {
594 return spf_vv_mult<scvector,cvector,complex,sparse_cdot>(v1,v2);
595}
596
598
604inline complex operator*(const scvector& v1, const rvector& v2) {
605 return spf_vv_mult<scvector,rvector,complex,sparse_cdot>(v1,v2);
606}
607
609
615inline complex operator*(const srvector& v1, const cvector& v2) {
616 return spf_vv_mult<srvector,cvector,complex,sparse_cdot>(v1,v2);
617}
618
620
626inline complex operator*(const rvector& v1, const scvector& v2) {
627 return fsp_vv_mult<rvector,scvector,complex,sparse_cdot>(v1,v2);
628}
629
631
637inline complex operator*(const cvector& v1, const srvector& v2) {
638 return fsp_vv_mult<cvector,srvector,complex,sparse_cdot>(v1,v2);
639}
640
642
648inline complex operator*(const cvector& v1, const scvector& v2) {
649 return fsp_vv_mult<cvector,scvector,complex,sparse_cdot>(v1,v2);
650}
651
653
659inline complex operator*(const scvector& v1, const rvector_slice& v2) {
660 return spf_vv_mult<scvector,rvector_slice,complex,sparse_cdot>(v1,v2);
661}
662
664
670inline complex operator*(const scvector& v1, const cvector_slice& v2) {
671 return spf_vv_mult<scvector,cvector_slice,complex,sparse_cdot>(v1,v2);
672}
673
675
681inline complex operator*(const srvector& v1, const cvector_slice& v2) {
682 return spf_vv_mult<srvector,cvector_slice,complex,sparse_cdot>(v1,v2);
683}
684
686
692inline complex operator*(const cvector_slice& v1, const srvector& v2) {
693 return fsp_vv_mult<cvector_slice,srvector,complex,sparse_cdot>(v1,v2);
694}
695
697
703inline complex operator*(const cvector_slice& v1, const scvector& v2) {
704 return fsp_vv_mult<cvector_slice,scvector,complex,sparse_cdot>(v1,v2);
705}
706
708
714inline complex operator*(const rvector_slice& v1, const scvector& v2) {
715 return fsp_vv_mult<rvector_slice,scvector,complex,sparse_cdot>(v1,v2);
716}
717
719
725inline complex operator*(const scvector& v1, const srvector& v2) {
726 return spsp_vv_mult<scvector,srvector,complex,sparse_cdot>(v1,v2);
727}
728
730
736inline complex operator*(const srvector& v1, const scvector& v2) {
737 return spsp_vv_mult<srvector,scvector,complex,sparse_cdot>(v1,v2);
738}
739
741
747inline complex operator*(const scvector& v1, const scvector& v2) {
748 return spsp_vv_mult<scvector,scvector,complex,sparse_cdot>(v1,v2);
749}
750
752inline scvector operator*(const scvector& v, const real& s) {
753 return sp_vs_mult<scvector,real,scvector>(v,s);
754}
755
757inline scvector operator*(const scvector& v, const complex& s) {
758 return sp_vs_mult<scvector,complex,scvector>(v,s);
759}
760
762inline scvector operator*(const srvector& v, const complex& s) {
763 return sp_vs_mult<srvector,complex,scvector>(v,s);
764}
765
767inline scvector operator/(const scvector& v, const real& s) {
768 return sp_vs_div<scvector,real,scvector>(v,s);
769}
770
772inline scvector operator/(const scvector& v, const complex& s) {
773 return sp_vs_div<scvector,complex,scvector>(v,s);
774}
775
777inline scvector operator/(const srvector& v, const complex& s) {
778 return sp_vs_div<srvector,complex,scvector>(v,s);
779}
780
782inline scvector operator*(const real& s, const scvector& v) {
783 return sp_sv_mult<real,scvector,scvector>(s,v);
784}
785
787inline scvector operator*(const complex& s, const scvector& v) {
788 return sp_sv_mult<complex,scvector,scvector>(s,v);
789}
790
792inline scvector operator*(const complex& s, const srvector& v) {
793 return sp_sv_mult<complex,srvector,scvector>(s,v);
794}
795
797inline cvector operator+(const cvector& v1, const srvector& v2) {
798 return fsp_vv_add<cvector,srvector,cvector>(v1,v2);
799}
800
802inline cvector operator+(const rvector& v1, const scvector& v2) {
803 return fsp_vv_add<rvector,scvector,cvector>(v1,v2);
804}
805
807inline cvector operator+(const cvector& v1, const scvector& v2) {
808 return fsp_vv_add<cvector,scvector,cvector>(v1,v2);
809}
810
812inline cvector operator+(const scvector& v1, const rvector& v2) {
813 return spf_vv_add<scvector,rvector,cvector>(v1,v2);
814}
815
817inline cvector operator+(const srvector& v1, const cvector& v2) {
818 return spf_vv_add<srvector,cvector,cvector>(v1,v2);
819}
820
822inline cvector operator+(const scvector& v1, const cvector& v2) {
823 return spf_vv_add<scvector,cvector,cvector>(v1,v2);
824}
825
827inline cvector operator+(const cvector_slice& v1, const srvector& v2) {
828 return fsp_vv_add<cvector_slice,srvector,cvector>(v1,v2);
829}
830
832inline cvector operator+(const rvector_slice& v1, const scvector& v2) {
833 return fsp_vv_add<rvector_slice,scvector,cvector>(v1,v2);
834}
835
837inline cvector operator+(const cvector_slice& v1, const scvector& v2) {
838 return fsp_vv_add<cvector_slice,scvector,cvector>(v1,v2);
839}
840
842inline cvector operator+(const scvector& v1, const rvector_slice& v2) {
843 return spf_vv_add<scvector,rvector_slice,cvector>(v1,v2);
844}
845
847inline cvector operator+(const srvector& v1, const cvector_slice& v2) {
848 return spf_vv_add<srvector,cvector_slice,cvector>(v1,v2);
849}
850
852inline cvector operator+(const scvector& v1, const cvector_slice& v2) {
853 return spf_vv_add<scvector,cvector_slice,cvector>(v1,v2);
854}
855
857inline scvector operator+(const scvector& v1, const srvector& v2) {
858 return spsp_vv_add<scvector,srvector,scvector,complex>(v1,v2);
859}
860
862inline scvector operator+(const srvector& v1, const scvector& v2) {
863 return spsp_vv_add<srvector,scvector,scvector,complex>(v1,v2);
864}
865
867inline scvector operator+(const scvector& v1, const scvector& v2) {
868 return spsp_vv_add<scvector,scvector,scvector,complex>(v1,v2);
869}
870
872inline cvector operator-(const cvector& v1, const srvector& v2) {
873 return fsp_vv_sub<cvector,srvector,cvector>(v1,v2);
874}
875
877inline cvector operator-(const rvector& v1, const scvector& v2) {
878 return fsp_vv_sub<rvector,scvector,cvector>(v1,v2);
879}
880
882inline cvector operator-(const cvector& v1, const scvector& v2) {
883 return fsp_vv_sub<cvector,scvector,cvector>(v1,v2);
884}
885
887inline cvector operator-(const scvector& v1, const rvector& v2) {
888 return spf_vv_sub<scvector,rvector,cvector>(v1,v2);
889}
890
892inline cvector operator-(const srvector& v1, const cvector& v2) {
893 return spf_vv_sub<srvector,cvector,cvector>(v1,v2);
894}
895
897inline cvector operator-(const scvector& v1, const cvector& v2) {
898 return spf_vv_sub<scvector,cvector,cvector>(v1,v2);
899}
900
902inline cvector operator-(const cvector_slice& v1, const srvector& v2) {
903 return fsp_vv_sub<cvector_slice,srvector,cvector>(v1,v2);
904}
905
907inline cvector operator-(const rvector_slice& v1, const scvector& v2) {
908 return fsp_vv_sub<rvector_slice,scvector,cvector>(v1,v2);
909}
910
912inline cvector operator-(const cvector_slice& v1, const scvector& v2) {
913 return fsp_vv_sub<cvector_slice,scvector,cvector>(v1,v2);
914}
915
917inline cvector operator-(const scvector& v1, const rvector_slice& v2) {
918 return spf_vv_sub<scvector,rvector_slice,cvector>(v1,v2);
919}
920
922inline cvector operator-(const srvector& v1, const cvector_slice& v2) {
923 return spf_vv_sub<srvector,cvector_slice,cvector>(v1,v2);
924}
925
927inline cvector operator-(const scvector& v1, const cvector_slice& v2) {
928 return spf_vv_sub<scvector,cvector_slice,cvector>(v1,v2);
929}
930
932inline scvector operator-(const scvector& v1, const srvector& v2) {
933 return spsp_vv_sub<scvector,srvector,scvector,complex>(v1,v2);
934}
935
937inline scvector operator-(const srvector& v1, const scvector& v2) {
938 return spsp_vv_sub<srvector,scvector,scvector,complex>(v1,v2);
939}
940
942inline scvector operator-(const scvector& v1, const scvector& v2) {
943 return spsp_vv_sub<scvector,scvector,scvector,complex>(v1,v2);
944}
945
946inline cvector& cvector::operator+=(const srvector& v2) {
947 return fsp_vv_addassign(*this,v2);
948}
949
950inline cvector& cvector::operator+=(const scvector& v2) {
951 return fsp_vv_addassign(*this,v2);
952}
953
954inline cvector_slice& cvector_slice::operator+=(const srvector& v2) {
955 return fsp_vv_addassign(*this,v2);
956}
957
958inline cvector_slice& cvector_slice::operator+=(const scvector& v2) {
959 return fsp_vv_addassign(*this,v2);
960}
961
962inline cvector& cvector::operator-=(const srvector& v2) {
963 return fsp_vv_subassign(*this,v2);
964}
965
966inline cvector& cvector::operator-=(const scvector& v2) {
967 return fsp_vv_subassign(*this,v2);
968}
969
970inline cvector_slice& cvector_slice::operator-=(const srvector& v2) {
971 return fsp_vv_subassign(*this,v2);
972}
973
974inline cvector_slice& cvector_slice::operator-=(const scvector& v2) {
975 return fsp_vv_subassign(*this,v2);
976}
977
979
982inline bool operator==(const scvector& v1, const scvector& v2) {
983 return spsp_vv_comp(v1,v2);
984}
985
987
990inline bool operator==(const scvector& v1, const srvector& v2) {
991 return spsp_vv_comp(v1,v2);
992}
993
995
998inline bool operator==(const srvector& v1, const scvector& v2) {
999 return spsp_vv_comp(v1,v2);
1000}
1001
1003
1006inline bool operator==(const scvector& v1, const rvector& v2) {
1007 return spf_vv_comp(v1,v2);
1008}
1009
1011
1014inline bool operator==(const srvector& v1, const cvector& v2) {
1015 return spf_vv_comp(v1,v2);
1016}
1017
1019
1022inline bool operator==(const scvector& v1, const cvector& v2) {
1023 return spf_vv_comp(v1,v2);
1024}
1025
1027
1030inline bool operator==(const cvector& v1, const srvector& v2) {
1031 return fsp_vv_comp(v1,v2);
1032}
1033
1035
1038inline bool operator==(const rvector& v1, const scvector& v2) {
1039 return fsp_vv_comp(v1,v2);
1040}
1041
1043
1046inline bool operator==(const cvector& v1, const scvector& v2) {
1047 return fsp_vv_comp(v1,v2);
1048}
1049
1051
1054inline bool operator==(const scvector& v1, const rvector_slice& v2) {
1055 return spf_vv_comp(v1,v2);
1056}
1057
1059
1062inline bool operator==(const srvector& v1, const cvector_slice& v2) {
1063 return spf_vv_comp(v1,v2);
1064}
1065
1067
1070inline bool operator==(const scvector& v1, const cvector_slice& v2) {
1071 return spf_vv_comp(v1,v2);
1072}
1073
1075
1078inline bool operator==(const cvector_slice& v1, const srvector& v2) {
1079 return fsp_vv_comp(v1,v2);
1080}
1081
1083
1086inline bool operator==(const rvector_slice& v1, const scvector& v2) {
1087 return fsp_vv_comp(v1,v2);
1088}
1089
1091
1094inline bool operator==(const cvector_slice& v1, const scvector& v2) {
1095 return fsp_vv_comp(v1,v2);
1096}
1097
1099
1102inline bool operator!=(const scvector& v1, const srvector& v2) {
1103 return !spsp_vv_comp(v1,v2);
1104}
1105
1107
1110inline bool operator!=(const srvector& v1, const scvector& v2) {
1111 return !spsp_vv_comp(v1,v2);
1112}
1113
1115
1118inline bool operator!=(const scvector& v1, const scvector& v2) {
1119 return !spsp_vv_comp(v1,v2);
1120}
1121
1123
1126inline bool operator!=(const scvector& v1, const rvector& v2) {
1127 return !spf_vv_comp(v1,v2);
1128}
1129
1131
1134inline bool operator!=(const srvector& v1, const cvector& v2) {
1135 return !spf_vv_comp(v1,v2);
1136}
1137
1139
1142inline bool operator!=(const scvector& v1, const cvector& v2) {
1143 return !spf_vv_comp(v1,v2);
1144}
1145
1147
1150inline bool operator!=(const cvector& v1, const srvector& v2) {
1151 return !fsp_vv_comp(v1,v2);
1152}
1153
1155
1158inline bool operator!=(const rvector& v1, const scvector& v2) {
1159 return !fsp_vv_comp(v1,v2);
1160}
1161
1163
1166inline bool operator!=(const cvector& v1, const scvector& v2) {
1167 return !fsp_vv_comp(v1,v2);
1168}
1169
1171
1174inline bool operator!=(const scvector& v1, const rvector_slice& v2) {
1175 return !spf_vv_comp(v1,v2);
1176}
1177
1179
1182inline bool operator!=(const srvector& v1, const cvector_slice& v2) {
1183 return !spf_vv_comp(v1,v2);
1184}
1185
1187
1190inline bool operator!=(const scvector& v1, const cvector_slice& v2) {
1191 return !spf_vv_comp(v1,v2);
1192}
1193
1195
1198inline bool operator!=(const cvector_slice& v1, const srvector& v2) {
1199 return !fsp_vv_comp(v1,v2);
1200}
1201
1203
1206inline bool operator!=(const rvector_slice& v1, const scvector& v2) {
1207 return !fsp_vv_comp(v1,v2);
1208}
1209
1211
1214inline bool operator!=(const cvector_slice& v1, const scvector& v2) {
1215 return !fsp_vv_comp(v1,v2);
1216}
1217
1219
1224inline std::ostream& operator<<(std::ostream& os, const scvector& v) {
1225 return sp_v_output<scvector,complex>(os,v);
1226}
1227
1229
1234inline std::istream& operator>>(std::istream& is, scvector& v) {
1235 return sp_v_input<scvector,complex>(is,v);
1236}
1237
1238
1240
1246 private:
1247 std::vector<int>& p;
1248 std::vector<complex>& x;
1249 scvector& orig;
1250 int start,end;
1251 int lb;
1252 int ub;
1253 int n;
1254 int nnz;
1255 int offset;
1256
1258
1262 scvector_slice(scvector& v, int l, int u) : p(v.p), x(v.x), orig(v), lb(l), ub(u), n(u-l+1) {
1263 int i;
1264
1265 for(i=0 ; i<v.get_nnz() && p[i]<lb-v.lb ; i++);
1266
1267 start = i;
1268
1269 for(i=start ; i<v.get_nnz() && p[i]<=ub-v.lb ; i++);
1270
1271 end = i-1;
1272
1273 nnz = end-start+1;
1274 offset = lb-v.lb;
1275 }
1276
1277 public:
1278
1280 int get_nnz() const {
1281 return nnz;
1282 }
1283
1285 real density() const {
1286 return (double)nnz/n;
1287 }
1288
1290
1294 complex& operator[](const int i) {
1295#if(CXSC_INDEX_CHECK)
1296 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector_slice::operator[](const int)"));
1297#endif
1298 int k;
1299
1300 for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
1301 if(p[k]-offset == i-lb)
1302 return x[k];
1303 }
1304
1305 p.insert(p.begin() + k, i-lb);
1306 x.insert(x.begin() + k, complex(0.0));
1307 end++;
1308
1309 return x[k];
1310 }
1311
1313
1317 complex operator[](const int i) const {
1318#if(CXSC_INDEX_CHECK)
1319 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector_slice::operator[](const int)"));
1320#endif
1321 return (*this)(i);
1322 }
1323
1325
1329 const complex operator()(const int i) const {
1330#if(CXSC_INDEX_CHECK)
1331 if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector_slice::operator()(const int)"));
1332#endif
1333 complex r(0.0);
1334
1335 for(int k=start ; k<end && p[k]-start<=i-lb ; k++) {
1336 if(p[k]-start == i-lb)
1337 r = x[k];
1338 }
1339
1340 return r;
1341 }
1342
1345 return sl_vs_assign<scvector_slice,real,complex,std::vector<complex>::iterator>(*this,v);
1346 }
1347
1350 return sl_vs_assign<scvector_slice,complex,complex,std::vector<complex>::iterator>(*this,v);
1351 }
1352
1355 return slsl_vv_assign<scvector_slice,srvector_slice,complex,std::vector<complex>::iterator>(*this,v);
1356 }
1357
1360 return slsl_vv_assign<scvector_slice,scvector_slice,complex,std::vector<complex>::iterator>(*this,v);
1361 }
1362
1365 return slsp_vv_assign<scvector_slice,srvector,complex,std::vector<complex>::iterator>(*this,v);
1366 }
1367
1370 return slsp_vv_assign<scvector_slice,scvector,complex,std::vector<complex>::iterator>(*this,v);
1371 }
1372
1375 return slf_vv_assign<scvector_slice,rvector,complex,std::vector<complex>::iterator>(*this,v);
1376 }
1377
1380 return slf_vv_assign<scvector_slice,cvector,complex,std::vector<complex>::iterator>(*this,v);
1381 }
1382
1385 return slf_vv_assign<scvector_slice,rvector_slice,complex,std::vector<complex>::iterator>(*this,v);
1386 }
1387
1390 return slf_vv_assign<scvector_slice,cvector_slice,complex,std::vector<complex>::iterator>(*this,v);
1391 }
1392
1395 return sl_vs_multassign(*this,s);
1396 }
1397
1400 return sl_vs_multassign(*this,s);
1401 }
1402
1405 return sl_vs_divassign(*this,s);
1406 }
1407
1410 return sl_vs_divassign(*this,s);
1411 }
1412
1415 return slf_vv_addassign<scvector_slice,rvector,complex>(*this,v);
1416 }
1417
1420 return slf_vv_addassign<scvector_slice,cvector,complex>(*this,v);
1421 }
1422
1425 return slf_vv_addassign<scvector_slice,rvector_slice,complex>(*this,v);
1426 }
1427
1430 return slf_vv_addassign<scvector_slice,cvector_slice,complex>(*this,v);
1431 }
1432
1435 return slsp_vv_addassign(*this,v);
1436 }
1437
1440 return slsp_vv_addassign(*this,v);
1441 }
1442
1445 return slsl_vv_addassign(*this,v);
1446 }
1447
1450 return slsl_vv_addassign(*this,v);
1451 }
1452
1455 return slf_vv_subassign<scvector_slice,rvector,complex>(*this,v);
1456 }
1457
1460 return slf_vv_subassign<scvector_slice,cvector,complex>(*this,v);
1461 }
1462
1465 return slf_vv_subassign<scvector_slice,rvector_slice,complex>(*this,v);
1466 }
1467
1470 return slf_vv_subassign<scvector_slice,cvector_slice,complex>(*this,v);
1471 }
1472
1475 return slsp_vv_subassign(*this,v);
1476 }
1477
1480 return slsp_vv_subassign(*this,v);
1481 }
1482
1485 return slsl_vv_subassign(*this,v);
1486 }
1487
1490 return slsl_vv_subassign(*this,v);
1491 }
1492
1493 friend int Lb(const scvector_slice&);
1494 friend int Ub(const scvector_slice&);
1495 friend srvector Re(const scvector_slice&);
1496 friend srvector Im(const scvector_slice&);
1497 friend int VecLen(const scvector_slice&);
1498
1499// friend srvector operator*(const srmatrix&, const srvector_slice&); //ok
1500// friend srvector operator*(const srmatrix_slice&, const srvector_slice&); //ok
1501
1502 friend class srvector;
1503 friend class scvector;
1504 friend class scivector;
1505 friend class cvector;
1506 friend class cvector_slice;
1507 friend class civector;
1508 friend class civector_slice;
1509
1510#include "vector_friend_declarations.inl"
1511};
1512
1514 l = v.lb;
1515 u = v.ub;
1516 size = v.n;
1517 dat = new complex[v.n];
1518 for(int i=0 ; i<v.n ; i++)
1519 dat[i] = 0.0;
1520 for(int i=v.start ; i<=v.end ; i++)
1521 dat[v.p[i]] = v.x[i];
1522}
1523
1525 l = v.lb;
1526 u = v.ub;
1527 size = v.n;
1528 dat = new complex[v.n];
1529 for(int i=0 ; i<v.n ; i++)
1530 dat[i] = 0.0;
1531 for(int i=v.start ; i<=v.end ; i++)
1532 dat[v.p[i]] = v.x[i];
1533}
1534
1536 *this = rvector(v);
1537 return *this;
1538}
1539
1541 *this = rvector(v);
1542 return *this;
1543}
1544
1546 *this = cvector(v);
1547 return *this;
1548}
1549
1551 *this = cvector(v);
1552 return *this;
1553}
1554
1555inline scvector::scvector(const srvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
1556 p.reserve(s.nnz);
1557 x.reserve(s.nnz);
1558
1559 for(int i=s.start ; i<=s.end ; i++) {
1560 p.push_back(s.p[i]-s.offset);
1561 x.push_back(complex(s.x[i]));
1562 }
1563
1564}
1565
1566inline scvector::scvector(const scvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
1567 p.reserve(s.nnz);
1568 x.reserve(s.nnz);
1569
1570 for(int i=s.start ; i<=s.end ; i++) {
1571 p.push_back(s.p[i]-s.offset);
1572 x.push_back(s.x[i]);
1573 }
1574
1575}
1576
1578 return spsl_vv_assign<scvector,srvector_slice,complex>(*this,v);
1579}
1580
1582 return spsl_vv_assign<scvector,scvector_slice,complex>(*this,v);
1583}
1584
1585inline scvector_slice scvector::operator()(const int i, const int j) {
1586#if(CXSC_INDEX_CHECK)
1587 if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scvector_slice::operator()(const int, const int)"));
1588#endif
1589 return scvector_slice(*this,i,j);
1590}
1591
1593inline scvector operator-(const scvector_slice& v) {
1594 return sl_v_negative<scvector_slice,scvector>(v);
1595}
1596
1598inline int Lb(const scvector_slice& v) {
1599 return v.lb;
1600}
1601
1603inline int Ub(const scvector_slice& v) {
1604 return v.ub;
1605}
1606
1608inline srvector Re(const scvector_slice& v) {
1609 return Re(scvector(v));
1610}
1611
1613inline srvector Im(const scvector_slice& v) {
1614 return Im(scvector(v));
1615}
1616
1618inline int VecLen(const scvector_slice& v) {
1619 return v.n;
1620}
1621
1623
1629inline complex operator*(const scvector_slice& v1, const rvector& v2) {
1630 return slf_vv_mult<scvector_slice,rvector,complex,sparse_cdot>(v1,v2);
1631}
1632
1634
1640inline complex operator*(const srvector_slice& v1, const cvector& v2) {
1641 return slf_vv_mult<srvector_slice,cvector,complex,sparse_cdot>(v1,v2);
1642}
1643
1645
1651inline complex operator*(const scvector_slice& v1, const cvector& v2) {
1652 return slf_vv_mult<scvector_slice,cvector,complex,sparse_cdot>(v1,v2);
1653}
1654
1656
1662inline complex operator*(const cvector& v1, const srvector_slice& v2) {
1663 return fsl_vv_mult<cvector,srvector_slice,complex,sparse_cdot>(v1,v2);
1664}
1665
1667
1673inline complex operator*(const rvector& v1, const scvector_slice& v2) {
1674 return fsl_vv_mult<rvector,scvector_slice,complex,sparse_cdot>(v1,v2);
1675}
1676
1678
1684inline complex operator*(const cvector& v1, const scvector_slice& v2) {
1685 return fsl_vv_mult<cvector,scvector_slice,complex,sparse_cdot>(v1,v2);
1686}
1687
1689
1695inline complex operator*(const scvector_slice& v1, const rvector_slice& v2) {
1696 return slf_vv_mult<scvector_slice,rvector_slice,complex,sparse_cdot>(v1,v2);
1697}
1698
1700
1706inline complex operator*(const srvector_slice& v1, const cvector_slice& v2) {
1707 return slf_vv_mult<srvector_slice,cvector_slice,complex,sparse_cdot>(v1,v2);
1708}
1709
1711
1717inline complex operator*(const scvector_slice& v1, const cvector_slice& v2) {
1718 return slf_vv_mult<scvector_slice,cvector_slice,complex,sparse_cdot>(v1,v2);
1719}
1720
1722
1728inline complex operator*(const cvector_slice& v1, const srvector_slice& v2) {
1729 return fsl_vv_mult<cvector_slice,srvector_slice,complex,sparse_cdot>(v1,v2);
1730}
1731
1733
1739inline complex operator*(const rvector_slice& v1, const scvector_slice& v2) {
1740 return fsl_vv_mult<rvector_slice,scvector_slice,complex,sparse_cdot>(v1,v2);
1741}
1742
1744
1750inline complex operator*(const cvector_slice& v1, const scvector_slice& v2) {
1751 return fsl_vv_mult<cvector_slice,scvector_slice,complex,sparse_cdot>(v1,v2);
1752}
1753
1755
1761inline complex operator*(const scvector& v1, const srvector_slice& v2) {
1762 return spsl_vv_mult<scvector,srvector_slice,complex,sparse_cdot>(v1,v2);
1763}
1764
1766
1772inline complex operator*(const srvector& v1, const scvector_slice& v2) {
1773 return spsl_vv_mult<srvector,scvector_slice,complex,sparse_cdot>(v1,v2);
1774}
1775
1777
1783inline complex operator*(const scvector& v1, const scvector_slice& v2) {
1784 return spsl_vv_mult<scvector,scvector_slice,complex,sparse_cdot>(v1,v2);
1785}
1786
1788
1794inline complex operator*(const scvector_slice& v1, const srvector& v2) {
1795 return slsp_vv_mult<scvector_slice,srvector,complex,sparse_cdot>(v1,v2);
1796}
1797
1799
1805inline complex operator*(const srvector_slice& v1, const scvector& v2) {
1806 return slsp_vv_mult<srvector_slice,scvector,complex,sparse_cdot>(v1,v2);
1807}
1808
1810
1816inline complex operator*(const scvector_slice& v1, const scvector& v2) {
1817 return slsp_vv_mult<scvector_slice,scvector,complex,sparse_cdot>(v1,v2);
1818}
1819
1821
1827inline complex operator*(const scvector_slice& v1, const srvector_slice& v2) {
1828 return slsl_vv_mult<scvector_slice,srvector_slice,complex,sparse_cdot>(v1,v2);
1829}
1830
1832
1838inline complex operator*(const srvector_slice& v1, const scvector_slice& v2) {
1839 return slsl_vv_mult<srvector_slice,scvector_slice,complex,sparse_cdot>(v1,v2);
1840}
1841
1843
1849inline complex operator*(const scvector_slice& v1, const scvector_slice& v2) {
1850 return slsl_vv_mult<scvector_slice,scvector_slice,complex,sparse_cdot>(v1,v2);
1851}
1852
1854inline scvector operator*(const scvector_slice& v, const real& s) {
1855 return sp_vs_mult<scvector_slice,real,scvector>(v,s);
1856}
1857
1859inline scvector operator*(const scvector_slice& v, const complex& s) {
1860 return sp_vs_mult<scvector_slice,complex,scvector>(v,s);
1861}
1862
1864inline scvector operator*(const srvector_slice& v, const complex& s) {
1865 return sp_vs_mult<srvector_slice,complex,scvector>(v,s);
1866}
1867
1869inline scvector operator/(const scvector_slice& v, const real& s) {
1870 return sp_vs_div<scvector_slice,real,scvector>(v,s);
1871}
1872
1874inline scvector operator/(const scvector_slice& v, const complex& s) {
1875 return sp_vs_div<scvector_slice,complex,scvector>(v,s);
1876}
1877
1879inline scvector operator/(const srvector_slice& v, const complex& s) {
1880 return sp_vs_div<srvector_slice,complex,scvector>(v,s);
1881}
1882
1884inline scvector operator*(const real& s, const scvector_slice& v) {
1885 return sp_sv_mult<real,scvector_slice,scvector>(s,v);
1886}
1887
1889inline scvector operator*(const complex& s, const scvector_slice& v) {
1890 return sp_sv_mult<complex,scvector_slice,scvector>(s,v);
1891}
1892
1894inline scvector operator*(const complex& s, const srvector_slice& v) {
1895 return sp_sv_mult<complex,srvector_slice,scvector>(s,v);
1896}
1897
1899inline cvector operator+(const cvector& v1, const srvector_slice& v2) {
1900 return fsl_vv_add<cvector,srvector_slice,cvector>(v1,v2);
1901}
1902
1904inline cvector operator+(const rvector& v1, const scvector_slice& v2) {
1905 return fsl_vv_add<rvector,scvector_slice,cvector>(v1,v2);
1906}
1907
1909inline cvector operator+(const cvector& v1, const scvector_slice& v2) {
1910 return fsl_vv_add<cvector,scvector_slice,cvector>(v1,v2);
1911}
1912
1914inline cvector operator+(const scvector_slice& v1, const rvector& v2) {
1915 return slf_vv_add<scvector_slice,rvector,cvector>(v1,v2);
1916}
1917
1919inline cvector operator+(const srvector_slice& v1, const cvector& v2) {
1920 return slf_vv_add<srvector_slice,cvector,cvector>(v1,v2);
1921}
1922
1924inline cvector operator+(const scvector_slice& v1, const cvector& v2) {
1925 return slf_vv_add<scvector_slice,cvector,cvector>(v1,v2);
1926}
1927
1929inline cvector operator+(const cvector_slice& v1, const srvector_slice& v2) {
1930 return fsl_vv_add<cvector_slice,srvector_slice,cvector>(v1,v2);
1931}
1932
1934inline cvector operator+(const rvector_slice& v1, const scvector_slice& v2) {
1935 return fsl_vv_add<rvector_slice,scvector_slice,cvector>(v1,v2);
1936}
1937
1939inline cvector operator+(const cvector_slice& v1, const scvector_slice& v2) {
1940 return fsl_vv_add<cvector_slice,scvector_slice,cvector>(v1,v2);
1941}
1942
1944inline cvector operator+(const scvector_slice& v1, const rvector_slice& v2) {
1945 return slf_vv_add<scvector_slice,rvector_slice,cvector>(v1,v2);
1946}
1947
1949inline cvector operator+(const srvector_slice& v1, const cvector_slice& v2) {
1950 return slf_vv_add<srvector_slice,cvector_slice,cvector>(v1,v2);
1951}
1952
1954inline cvector operator+(const scvector_slice& v1, const cvector_slice& v2) {
1955 return slf_vv_add<scvector_slice,cvector_slice,cvector>(v1,v2);
1956}
1957
1959inline scvector operator+(const scvector_slice& v1, const srvector_slice& v2) {
1960 return slsl_vv_add<scvector_slice,srvector_slice,scvector,complex>(v1,v2);
1961}
1962
1964inline scvector operator+(const srvector_slice& v1, const scvector_slice& v2) {
1965 return slsl_vv_add<srvector_slice,scvector_slice,scvector,complex>(v1,v2);
1966}
1967
1969inline scvector operator+(const scvector_slice& v1, const scvector_slice& v2) {
1970 return slsl_vv_add<scvector_slice,scvector_slice,scvector,complex>(v1,v2);
1971}
1972
1974inline scvector operator+(const scvector& v1, const srvector_slice& v2) {
1975 return spsl_vv_add<scvector,srvector_slice,scvector,complex>(v1,v2);
1976}
1977
1979inline scvector operator+(const srvector& v1, const scvector_slice& v2) {
1980 return spsl_vv_add<srvector,scvector_slice,scvector,complex>(v1,v2);
1981}
1982
1984inline scvector operator+(const scvector& v1, const scvector_slice& v2) {
1985 return spsl_vv_add<scvector,scvector_slice,scvector,complex>(v1,v2);
1986}
1987
1989inline scvector operator+(const scvector_slice& v1, const srvector& v2) {
1990 return slsp_vv_add<scvector_slice,srvector,scvector,complex>(v1,v2);
1991}
1992
1994inline scvector operator+(const srvector_slice& v1, const scvector& v2) {
1995 return slsp_vv_add<srvector_slice,scvector,scvector,complex>(v1,v2);
1996}
1997
1999inline scvector operator+(const scvector_slice& v1, const scvector& v2) {
2000 return slsp_vv_add<scvector_slice,scvector,scvector,complex>(v1,v2);
2001}
2002
2004inline cvector operator-(const cvector& v1, const srvector_slice& v2) {
2005 return fsl_vv_sub<cvector,srvector_slice,cvector>(v1,v2);
2006}
2007
2009inline cvector operator-(const rvector& v1, const scvector_slice& v2) {
2010 return fsl_vv_sub<rvector,scvector_slice,cvector>(v1,v2);
2011}
2012
2014inline cvector operator-(const cvector& v1, const scvector_slice& v2) {
2015 return fsl_vv_sub<cvector,scvector_slice,cvector>(v1,v2);
2016}
2017
2019inline cvector operator-(const scvector_slice& v1, const rvector& v2) {
2020 return slf_vv_sub<scvector_slice,rvector,cvector>(v1,v2);
2021}
2022
2024inline cvector operator-(const srvector_slice& v1, const cvector& v2) {
2025 return slf_vv_sub<srvector_slice,cvector,cvector>(v1,v2);
2026}
2027
2029inline cvector operator-(const scvector_slice& v1, const cvector& v2) {
2030 return slf_vv_sub<scvector_slice,cvector,cvector>(v1,v2);
2031}
2032
2034inline cvector operator-(const cvector_slice& v1, const srvector_slice& v2) {
2035 return fsl_vv_sub<cvector_slice,srvector_slice,cvector>(v1,v2);
2036}
2037
2039inline cvector operator-(const rvector_slice& v1, const scvector_slice& v2) {
2040 return fsl_vv_sub<rvector_slice,scvector_slice,cvector>(v1,v2);
2041}
2042
2044inline cvector operator-(const cvector_slice& v1, const scvector_slice& v2) {
2045 return fsl_vv_sub<cvector_slice,scvector_slice,cvector>(v1,v2);
2046}
2047
2049inline cvector operator-(const scvector_slice& v1, const rvector_slice& v2) {
2050 return slf_vv_sub<scvector_slice,rvector_slice,cvector>(v1,v2);
2051}
2052
2054inline cvector operator-(const srvector_slice& v1, const cvector_slice& v2) {
2055 return slf_vv_sub<srvector_slice,cvector_slice,cvector>(v1,v2);
2056}
2057
2059inline cvector operator-(const scvector_slice& v1, const cvector_slice& v2) {
2060 return slf_vv_sub<scvector_slice,cvector_slice,cvector>(v1,v2);
2061}
2062
2064inline scvector operator-(const scvector_slice& v1, const srvector_slice& v2) {
2065 return slsl_vv_sub<scvector_slice,srvector_slice,scvector,complex>(v1,v2);
2066}
2067
2069inline scvector operator-(const srvector_slice& v1, const scvector_slice& v2) {
2070 return slsl_vv_sub<srvector_slice,scvector_slice,scvector,complex>(v1,v2);
2071}
2072
2074inline scvector operator-(const scvector_slice& v1, const scvector_slice& v2) {
2075 return slsl_vv_sub<scvector_slice,scvector_slice,scvector,complex>(v1,v2);
2076}
2077
2079inline scvector operator-(const scvector& v1, const srvector_slice& v2) {
2080 return spsl_vv_sub<scvector,srvector_slice,scvector,complex>(v1,v2);
2081}
2082
2084inline scvector operator-(const srvector& v1, const scvector_slice& v2) {
2085 return spsl_vv_sub<srvector,scvector_slice,scvector,complex>(v1,v2);
2086}
2087
2089inline scvector operator-(const scvector& v1, const scvector_slice& v2) {
2090 return spsl_vv_sub<scvector,scvector_slice,scvector,complex>(v1,v2);
2091}
2092
2094inline scvector operator-(const scvector_slice& v1, const srvector& v2) {
2095 return slsp_vv_sub<scvector_slice,srvector,scvector,complex>(v1,v2);
2096}
2097
2099inline scvector operator-(const srvector_slice& v1, const scvector& v2) {
2100 return slsp_vv_sub<srvector_slice,scvector,scvector,complex>(v1,v2);
2101}
2102
2104inline scvector operator-(const scvector_slice& v1, const scvector& v2) {
2105 return slsp_vv_sub<scvector_slice,scvector,scvector,complex>(v1,v2);
2106}
2107
2108inline cvector& cvector::operator+=(const srvector_slice& v2) {
2109 return fsl_vv_addassign(*this,v2);
2110}
2111
2112inline cvector& cvector::operator+=(const scvector_slice& v2) {
2113 return fsl_vv_addassign(*this,v2);
2114}
2115
2116inline cvector_slice& cvector_slice::operator+=(const srvector_slice& v2) {
2117 return fsl_vv_addassign(*this,v2);
2118}
2119
2120inline cvector_slice& cvector_slice::operator+=(const scvector_slice& v2) {
2121 return fsl_vv_addassign(*this,v2);
2122}
2123
2125 return spsl_vv_addassign(*this,v2);
2126}
2127
2129 return spsl_vv_addassign(*this,v2);
2130}
2131
2132inline cvector& cvector::operator-=(const srvector_slice& v2) {
2133 return fsl_vv_subassign(*this,v2);
2134}
2135
2136inline cvector& cvector::operator-=(const scvector_slice& v2) {
2137 return fsl_vv_subassign(*this,v2);
2138}
2139
2140inline cvector_slice& cvector_slice::operator-=(const srvector_slice& v2) {
2141 return fsl_vv_subassign(*this,v2);
2142}
2143
2144inline cvector_slice& cvector_slice::operator-=(const scvector_slice& v2) {
2145 return fsl_vv_subassign(*this,v2);
2146}
2147
2149 return spsl_vv_subassign(*this,v2);
2150}
2151
2153 return spsl_vv_subassign(*this,v2);
2154}
2155
2157
2160inline bool operator==(const scvector_slice& v1, const srvector_slice& v2) {
2161 return slsl_vv_comp(v1,v2);
2162}
2163
2165
2168inline bool operator==(const srvector_slice& v1, const scvector_slice& v2) {
2169 return slsl_vv_comp(v1,v2);
2170}
2171
2173
2176inline bool operator==(const scvector_slice& v1, const scvector_slice& v2) {
2177 return slsl_vv_comp(v1,v2);
2178}
2179
2181
2184inline bool operator==(const scvector_slice& v1, const srvector& v2) {
2185 return slsp_vv_comp(v1,v2);
2186}
2187
2189
2192inline bool operator==(const srvector_slice& v1, const scvector& v2) {
2193 return slsp_vv_comp(v1,v2);
2194}
2195
2197
2200inline bool operator==(const scvector_slice& v1, const scvector& v2) {
2201 return slsp_vv_comp(v1,v2);
2202}
2203
2205
2208inline bool operator==(const scvector& v1, const srvector_slice& v2) {
2209 return spsl_vv_comp(v1,v2);
2210}
2211
2213
2216inline bool operator==(const srvector& v1, const scvector_slice& v2) {
2217 return spsl_vv_comp(v1,v2);
2218}
2219
2221
2224inline bool operator==(const scvector& v1, const scvector_slice& v2) {
2225 return spsl_vv_comp(v1,v2);
2226}
2227
2229
2232inline bool operator==(const scvector_slice& v1, const rvector& v2) {
2233 return slf_vv_comp(v1,v2);
2234}
2235
2237
2240inline bool operator==(const srvector_slice& v1, const cvector& v2) {
2241 return slf_vv_comp(v1,v2);
2242}
2243
2245
2248inline bool operator==(const scvector_slice& v1, const cvector& v2) {
2249 return slf_vv_comp(v1,v2);
2250}
2251
2253
2256inline bool operator==(const cvector& v1, const srvector_slice& v2) {
2257 return fsl_vv_comp(v1,v2);
2258}
2259
2261
2264inline bool operator==(const rvector& v1, const scvector_slice& v2) {
2265 return fsl_vv_comp(v1,v2);
2266}
2267
2269
2272inline bool operator==(const cvector& v1, const scvector_slice& v2) {
2273 return fsl_vv_comp(v1,v2);
2274}
2275
2277
2280inline bool operator==(const scvector_slice& v1, const rvector_slice& v2) {
2281 return slf_vv_comp(v1,v2);
2282}
2283
2285
2288inline bool operator==(const srvector_slice& v1, const cvector_slice& v2) {
2289 return slf_vv_comp(v1,v2);
2290}
2291
2293
2296inline bool operator==(const scvector_slice& v1, const cvector_slice& v2) {
2297 return slf_vv_comp(v1,v2);
2298}
2299
2301
2304inline bool operator==(const cvector_slice& v1, const srvector_slice& v2) {
2305 return fsl_vv_comp(v1,v2);
2306}
2307
2309
2312inline bool operator==(const rvector_slice& v1, const scvector_slice& v2) {
2313 return fsl_vv_comp(v1,v2);
2314}
2315
2317
2320inline bool operator==(const cvector_slice& v1, const scvector_slice& v2) {
2321 return fsl_vv_comp(v1,v2);
2322}
2323
2325
2328inline bool operator!=(const scvector_slice& v1, const srvector_slice& v2) {
2329 return !slsl_vv_comp(v1,v2);
2330}
2331
2333
2336inline bool operator!=(const srvector_slice& v1, const scvector_slice& v2) {
2337 return !slsl_vv_comp(v1,v2);
2338}
2339
2341
2344inline bool operator!=(const scvector_slice& v1, const scvector_slice& v2) {
2345 return !slsl_vv_comp(v1,v2);
2346}
2347
2349
2352inline bool operator!=(const scvector_slice& v1, const rvector& v2) {
2353 return !slf_vv_comp(v1,v2);
2354}
2355
2357
2360inline bool operator!=(const srvector_slice& v1, const cvector& v2) {
2361 return !slf_vv_comp(v1,v2);
2362}
2363
2365
2368inline bool operator!=(const scvector_slice& v1, const cvector& v2) {
2369 return !slf_vv_comp(v1,v2);
2370}
2371
2373
2376inline bool operator!=(const cvector& v1, const srvector_slice& v2) {
2377 return !fsl_vv_comp(v1,v2);
2378}
2379
2381
2384inline bool operator!=(const rvector& v1, const scvector_slice& v2) {
2385 return !fsl_vv_comp(v1,v2);
2386}
2387
2389
2392inline bool operator!=(const cvector& v1, const scvector_slice& v2) {
2393 return !fsl_vv_comp(v1,v2);
2394}
2395
2397
2400inline bool operator!=(const scvector_slice& v1, const srvector& v2) {
2401 return !slsp_vv_comp(v1,v2);
2402}
2403
2405
2408inline bool operator!=(const srvector_slice& v1, const scvector& v2) {
2409 return !slsp_vv_comp(v1,v2);
2410}
2411
2413
2416inline bool operator!=(const scvector_slice& v1, const scvector& v2) {
2417 return !slsp_vv_comp(v1,v2);
2418}
2419
2421
2424inline bool operator!=(const scvector& v1, const srvector_slice& v2) {
2425 return !spsl_vv_comp(v1,v2);
2426}
2427
2429
2432inline bool operator!=(const srvector& v1, const scvector_slice& v2) {
2433 return !spsl_vv_comp(v1,v2);
2434}
2435
2437
2440inline bool operator!=(const scvector& v1, const scvector_slice& v2) {
2441 return !spsl_vv_comp(v1,v2);
2442}
2443
2445
2448inline bool operator!=(const scvector_slice& v1, const rvector_slice& v2) {
2449 return !slf_vv_comp(v1,v2);
2450}
2451
2453
2456inline bool operator!=(const srvector_slice& v1, const cvector_slice& v2) {
2457 return !slf_vv_comp(v1,v2);
2458}
2459
2461
2464inline bool operator!=(const scvector_slice& v1, const cvector_slice& v2) {
2465 return !slf_vv_comp(v1,v2);
2466}
2467
2469
2472inline bool operator!=(const cvector_slice& v1, const srvector_slice& v2) {
2473 return !fsl_vv_comp(v1,v2);
2474}
2475
2477
2480inline bool operator!=(const rvector_slice& v1, const scvector_slice& v2) {
2481 return !fsl_vv_comp(v1,v2);
2482}
2483
2485
2488inline bool operator!=(const cvector_slice& v1, const scvector_slice& v2) {
2489 return !fsl_vv_comp(v1,v2);
2490}
2491
2493
2498inline std::ostream& operator<<(std::ostream& os, const scvector_slice& v) {
2499 return sl_v_output<scvector_slice,complex>(os,v);
2500}
2501
2503
2508inline std::istream& operator>>(std::istream& is, scvector_slice& v) {
2509 return sl_v_input<scvector_slice,complex>(is,v);
2510}
2511
2513
2516inline void accumulate(cdotprecision& dot, const scvector& x, const scvector& y) {
2517 spsp_vv_accu<cdotprecision,scvector,scvector,sparse_cdot>(dot,x,y);
2518}
2519
2521
2524inline void accumulate(cdotprecision& dot, const scvector& x, const srvector& y) {
2525 spsp_vv_accu<cdotprecision,scvector,srvector,sparse_cdot>(dot,x,y);
2526}
2527
2529
2532inline void accumulate(cdotprecision& dot, const srvector& x, const scvector& y) {
2533 spsp_vv_accu<cdotprecision,srvector,scvector,sparse_cdot>(dot,x,y);
2534}
2535
2537
2540inline void accumulate(cdotprecision& dot, const scvector& x, const cvector& y) {
2541 spf_vv_accu<cdotprecision,scvector,cvector,sparse_cdot>(dot,x,y);
2542}
2543
2545
2548inline void accumulate(cdotprecision& dot, const scvector& x, const rvector& y) {
2549 spf_vv_accu<cdotprecision,scvector,rvector,sparse_cdot>(dot,x,y);
2550}
2551
2553
2556inline void accumulate(cdotprecision& dot, const srvector& x, const cvector& y) {
2557 spf_vv_accu<cdotprecision,srvector,cvector,sparse_cdot>(dot,x,y);
2558}
2559
2561
2564inline void accumulate(cdotprecision& dot, const scvector& x, const cvector_slice& y) {
2565 spf_vv_accu<cdotprecision,scvector,cvector_slice,sparse_cdot>(dot,x,y);
2566}
2567
2569
2572inline void accumulate(cdotprecision& dot, const scvector& x, const rvector_slice& y) {
2573 spf_vv_accu<cdotprecision,scvector,rvector_slice,sparse_cdot>(dot,x,y);
2574}
2575
2577
2580inline void accumulate(cdotprecision& dot, const srvector& x, const cvector_slice& y) {
2581 spf_vv_accu<cdotprecision,srvector,cvector_slice,sparse_cdot>(dot,x,y);
2582}
2583
2585
2588inline void accumulate(cdotprecision& dot, const cvector& x, const scvector& y) {
2589 fsp_vv_accu<cdotprecision,cvector,scvector,sparse_cdot>(dot,x,y);
2590}
2591
2593
2596inline void accumulate(cdotprecision& dot, const cvector& x, const srvector& y) {
2597 fsp_vv_accu<cdotprecision,cvector,srvector,sparse_cdot>(dot,x,y);
2598}
2599
2601
2604inline void accumulate(cdotprecision& dot, const rvector& x, const scvector& y) {
2605 fsp_vv_accu<cdotprecision,rvector,scvector,sparse_cdot>(dot,x,y);
2606}
2607
2609
2612inline void accumulate(cdotprecision& dot, const cvector_slice& x, const scvector& y) {
2613 fsp_vv_accu<cdotprecision,cvector_slice,scvector,sparse_cdot>(dot,x,y);
2614}
2615
2617
2620inline void accumulate(cdotprecision& dot, const cvector_slice& x, const srvector& y) {
2621 fsp_vv_accu<cdotprecision,cvector_slice,srvector,sparse_cdot>(dot,x,y);
2622}
2623
2625
2628inline void accumulate(cdotprecision& dot, const rvector_slice& x, const scvector& y) {
2629 fsp_vv_accu<cdotprecision,rvector_slice,scvector,sparse_cdot>(dot,x,y);
2630}
2631
2633
2636inline void accumulate(cdotprecision& dot, const scvector_slice& x, const cvector& y) {
2637 slf_vv_accu<cdotprecision,scvector_slice,cvector,sparse_cdot>(dot,x,y);
2638}
2639
2641
2644inline void accumulate(cdotprecision& dot, const scvector_slice& x, const rvector& y) {
2645 slf_vv_accu<cdotprecision,scvector_slice,rvector,sparse_cdot>(dot,x,y);
2646}
2647
2649
2652inline void accumulate(cdotprecision& dot, const srvector_slice& x, const cvector& y) {
2653 slf_vv_accu<cdotprecision,srvector_slice,cvector,sparse_cdot>(dot,x,y);
2654}
2655
2657
2660inline void accumulate(cdotprecision& dot, const scvector_slice& x, const cvector_slice& y) {
2661 slf_vv_accu<cdotprecision,scvector_slice,cvector_slice,sparse_cdot>(dot,x,y);
2662}
2663
2665
2668inline void accumulate(cdotprecision& dot, const scvector_slice& x, const rvector_slice& y) {
2669 slf_vv_accu<cdotprecision,scvector_slice,rvector_slice,sparse_cdot>(dot,x,y);
2670}
2671
2673
2676inline void accumulate(cdotprecision& dot, const srvector_slice& x, const cvector_slice& y) {
2677 slf_vv_accu<cdotprecision,srvector_slice,cvector_slice,sparse_cdot>(dot,x,y);
2678}
2679
2681
2684inline void accumulate(cdotprecision& dot, const cvector& x, const scvector_slice& y) {
2685 fsl_vv_accu<cdotprecision,cvector,scvector_slice,sparse_cdot>(dot,x,y);
2686}
2687
2689
2692inline void accumulate(cdotprecision& dot, const cvector& x, const srvector_slice& y) {
2693 fsl_vv_accu<cdotprecision,cvector,srvector_slice,sparse_cdot>(dot,x,y);
2694}
2695
2697
2700inline void accumulate(cdotprecision& dot, const rvector& x, const scvector_slice& y) {
2701 fsl_vv_accu<cdotprecision,rvector,scvector_slice,sparse_cdot>(dot,x,y);
2702}
2703
2705
2708inline void accumulate(cdotprecision& dot, const cvector_slice& x, const scvector_slice& y) {
2709 fsl_vv_accu<cdotprecision,cvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
2710}
2711
2713
2716inline void accumulate(cdotprecision& dot, const cvector_slice& x, const srvector_slice& y) {
2717 fsl_vv_accu<cdotprecision,cvector_slice,srvector_slice,sparse_cdot>(dot,x,y);
2718}
2719
2721
2724inline void accumulate(cdotprecision& dot, const rvector_slice& x, const scvector_slice& y) {
2725 fsl_vv_accu<cdotprecision,rvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
2726}
2727
2729
2732inline void accumulate(cdotprecision& dot, const scvector_slice& x, const scvector_slice& y) {
2733 slsl_vv_accu<cdotprecision,scvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
2734}
2735
2737
2740inline void accumulate(cdotprecision& dot, const scvector_slice& x, const srvector_slice& y) {
2741 slsl_vv_accu<cdotprecision,scvector_slice,srvector_slice,sparse_cdot>(dot,x,y);
2742}
2743
2745
2748inline void accumulate(cdotprecision& dot, const srvector_slice& x, const scvector_slice& y) {
2749 slsl_vv_accu<cdotprecision,srvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
2750}
2751
2753
2756inline void accumulate(cdotprecision& dot, const scvector& x, const scvector_slice& y) {
2757 spsl_vv_accu<cdotprecision,scvector,scvector_slice,sparse_cdot>(dot,x,y);
2758}
2759
2761
2764inline void accumulate(cdotprecision& dot, const scvector& x, const srvector_slice& y) {
2765 spsl_vv_accu<cdotprecision,scvector,srvector_slice,sparse_cdot>(dot,x,y);
2766}
2767
2769
2772inline void accumulate(cdotprecision& dot, const srvector& x, const scvector_slice& y) {
2773 spsl_vv_accu<cdotprecision,srvector,scvector_slice,sparse_cdot>(dot,x,y);
2774}
2775
2777
2780inline void accumulate(cdotprecision& dot, const scvector_slice& x, const scvector& y) {
2781 slsp_vv_accu<cdotprecision,scvector_slice,scvector,sparse_cdot>(dot,x,y);
2782}
2783
2785
2788inline void accumulate(cdotprecision& dot, const scvector_slice& x, const srvector& y) {
2789 slsp_vv_accu<cdotprecision,scvector_slice,srvector,sparse_cdot>(dot,x,y);
2790}
2791
2793
2796inline void accumulate(cdotprecision& dot, const srvector_slice& x, const scvector& y) {
2797 slsp_vv_accu<cdotprecision,srvector_slice,scvector,sparse_cdot>(dot,x,y);
2798}
2799
2801
2805inline void accumulate_approx(cdotprecision& dot, const scvector& x, const scvector& y) {
2806 spsp_vv_accuapprox<cdotprecision,scvector,scvector,sparse_cdot>(dot,x,y);
2807}
2808
2810
2814inline void accumulate_approx(cdotprecision& dot, const scvector& x, const srvector& y) {
2815 spsp_vv_accuapprox<cdotprecision,scvector,srvector,sparse_cdot>(dot,x,y);
2816}
2817
2819
2823inline void accumulate_approx(cdotprecision& dot, const srvector& x, const scvector& y) {
2824 spsp_vv_accuapprox<cdotprecision,srvector,scvector,sparse_cdot>(dot,x,y);
2825}
2826
2828
2832inline void accumulate_approx(cdotprecision& dot, const scvector& x, const cvector& y) {
2833 spf_vv_accuapprox<cdotprecision,scvector,cvector,sparse_cdot>(dot,x,y);
2834}
2835
2837
2841inline void accumulate_approx(cdotprecision& dot, const scvector& x, const rvector& y) {
2842 spf_vv_accuapprox<cdotprecision,scvector,rvector,sparse_cdot>(dot,x,y);
2843}
2844
2846
2850inline void accumulate_approx(cdotprecision& dot, const srvector& x, const cvector& y) {
2851 spf_vv_accuapprox<cdotprecision,srvector,cvector,sparse_cdot>(dot,x,y);
2852}
2853
2855
2859inline void accumulate_approx(cdotprecision& dot, const scvector& x, const cvector_slice& y) {
2860 spf_vv_accuapprox<cdotprecision,scvector,cvector_slice,sparse_cdot>(dot,x,y);
2861}
2862
2864
2868inline void accumulate_approx(cdotprecision& dot, const scvector& x, const rvector_slice& y) {
2869 spf_vv_accuapprox<cdotprecision,scvector,rvector_slice,sparse_cdot>(dot,x,y);
2870}
2871
2873
2877inline void accumulate_approx(cdotprecision& dot, const srvector& x, const cvector_slice& y) {
2878 spf_vv_accuapprox<cdotprecision,srvector,cvector_slice,sparse_cdot>(dot,x,y);
2879}
2880
2882
2886inline void accumulate_approx(cdotprecision& dot, const cvector& x, const scvector& y) {
2887 fsp_vv_accuapprox<cdotprecision,cvector,scvector,sparse_cdot>(dot,x,y);
2888}
2889
2891
2895inline void accumulate_approx(cdotprecision& dot, const cvector& x, const srvector& y) {
2896 fsp_vv_accuapprox<cdotprecision,cvector,srvector,sparse_cdot>(dot,x,y);
2897}
2898
2900
2904inline void accumulate_approx(cdotprecision& dot, const rvector& x, const scvector& y) {
2905 fsp_vv_accuapprox<cdotprecision,rvector,scvector,sparse_cdot>(dot,x,y);
2906}
2907
2909
2913inline void accumulate_approx(cdotprecision& dot, const cvector_slice& x, const scvector& y) {
2914 fsp_vv_accuapprox<cdotprecision,cvector_slice,scvector,sparse_cdot>(dot,x,y);
2915}
2916
2918
2922inline void accumulate_approx(cdotprecision& dot, const cvector_slice& x, const srvector& y) {
2923 fsp_vv_accuapprox<cdotprecision,cvector_slice,srvector,sparse_cdot>(dot,x,y);
2924}
2925
2927
2931inline void accumulate_approx(cdotprecision& dot, const rvector_slice& x, const scvector& y) {
2932 fsp_vv_accuapprox<cdotprecision,rvector_slice,scvector,sparse_cdot>(dot,x,y);
2933}
2934
2936
2940inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const cvector& y) {
2941 slf_vv_accuapprox<cdotprecision,scvector_slice,cvector,sparse_cdot>(dot,x,y);
2942}
2943
2945
2949inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const rvector& y) {
2950 slf_vv_accuapprox<cdotprecision,scvector_slice,rvector,sparse_cdot>(dot,x,y);
2951}
2952
2954
2958inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const cvector& y) {
2959 slf_vv_accuapprox<cdotprecision,srvector_slice,cvector,sparse_cdot>(dot,x,y);
2960}
2961
2963
2967inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const cvector_slice& y) {
2968 slf_vv_accuapprox<cdotprecision,scvector_slice,cvector_slice,sparse_cdot>(dot,x,y);
2969}
2970
2972
2976inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const rvector_slice& y) {
2977 slf_vv_accuapprox<cdotprecision,scvector_slice,rvector_slice,sparse_cdot>(dot,x,y);
2978}
2979
2981
2985inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const cvector_slice& y) {
2986 slf_vv_accuapprox<cdotprecision,srvector_slice,cvector_slice,sparse_cdot>(dot,x,y);
2987}
2988
2989inline void accumulate_approx(cdotprecision& dot, const cvector& x, const scvector_slice& y) {
2990 fsl_vv_accuapprox<cdotprecision,cvector,scvector_slice,sparse_cdot>(dot,x,y);
2991}
2992
2994
2998inline void accumulate_approx(cdotprecision& dot, const cvector& x, const srvector_slice& y) {
2999 fsl_vv_accuapprox<cdotprecision,cvector,srvector_slice,sparse_cdot>(dot,x,y);
3000}
3001
3003
3007inline void accumulate_approx(cdotprecision& dot, const rvector& x, const scvector_slice& y) {
3008 fsl_vv_accuapprox<cdotprecision,rvector,scvector_slice,sparse_cdot>(dot,x,y);
3009}
3010
3012
3016inline void accumulate_approx(cdotprecision& dot, const cvector_slice& x, const scvector_slice& y) {
3017 fsl_vv_accuapprox<cdotprecision,cvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
3018}
3019
3021
3025inline void accumulate_approx(cdotprecision& dot, const cvector_slice& x, const srvector_slice& y) {
3026 fsl_vv_accuapprox<cdotprecision,cvector_slice,srvector_slice,sparse_cdot>(dot,x,y);
3027}
3028
3030
3034inline void accumulate_approx(cdotprecision& dot, const rvector_slice& x, const scvector_slice& y) {
3035 fsl_vv_accuapprox<cdotprecision,rvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
3036}
3037
3039
3043inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const scvector_slice& y) {
3044 slsl_vv_accuapprox<cdotprecision,scvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
3045}
3046
3048
3052inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const srvector_slice& y) {
3053 slsl_vv_accuapprox<cdotprecision,scvector_slice,srvector_slice,sparse_cdot>(dot,x,y);
3054}
3055
3057
3061inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const scvector_slice& y) {
3062 slsl_vv_accuapprox<cdotprecision,srvector_slice,scvector_slice,sparse_cdot>(dot,x,y);
3063}
3064
3066
3070inline void accumulate_approx(cdotprecision& dot, const scvector& x, const scvector_slice& y) {
3071 spsl_vv_accuapprox<cdotprecision,scvector,scvector_slice,sparse_cdot>(dot,x,y);
3072}
3073
3075
3079inline void accumulate_approx(cdotprecision& dot, const scvector& x, const srvector_slice& y) {
3080 spsl_vv_accuapprox<cdotprecision,scvector,srvector_slice,sparse_cdot>(dot,x,y);
3081}
3082
3084
3088inline void accumulate_approx(cdotprecision& dot, const srvector& x, const scvector_slice& y) {
3089 spsl_vv_accuapprox<cdotprecision,srvector,scvector_slice,sparse_cdot>(dot,x,y);
3090}
3091
3093
3097inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const scvector& y) {
3098 slsp_vv_accuapprox<cdotprecision,scvector_slice,scvector,sparse_cdot>(dot,x,y);
3099}
3100
3102
3106inline void accumulate_approx(cdotprecision& dot, const scvector_slice& x, const srvector& y) {
3107 slsp_vv_accuapprox<cdotprecision,scvector_slice,srvector,sparse_cdot>(dot,x,y);
3108}
3109
3111
3115inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const scvector& y) {
3116 slsp_vv_accuapprox<cdotprecision,srvector_slice,scvector,sparse_cdot>(dot,x,y);
3117}
3118
3120
3123inline void accumulate(cidotprecision& dot, const scvector& x, const scvector& y) {
3124 cdotprecision tmp(0.0);
3125 tmp.set_k(dot.get_k());
3126 accumulate(tmp,x,y);
3127 dot += tmp;
3128}
3129
3131
3134inline void accumulate(cidotprecision& dot, const scvector& x, const srvector& y) {
3135 cdotprecision tmp(0.0);
3136 tmp.set_k(dot.get_k());
3137 accumulate(tmp,x,y);
3138 dot += tmp;
3139}
3140
3142
3145inline void accumulate(cidotprecision& dot, const srvector& x, const scvector& y) {
3146 cdotprecision tmp(0.0);
3147 tmp.set_k(dot.get_k());
3148 accumulate(tmp,x,y);
3149 dot += tmp;
3150}
3151
3153
3156inline void accumulate(cidotprecision& dot, const scvector& x, const cvector& y) {
3157 cdotprecision tmp(0.0);
3158 tmp.set_k(dot.get_k());
3159 accumulate(tmp,x,y);
3160 dot += tmp;
3161}
3162
3164
3167inline void accumulate(cidotprecision& dot, const scvector& x, const rvector& y) {
3168 cdotprecision tmp(0.0);
3169 tmp.set_k(dot.get_k());
3170 accumulate(tmp,x,y);
3171 dot += tmp;
3172}
3173
3175
3178inline void accumulate(cidotprecision& dot, const srvector& x, const cvector& y) {
3179 cdotprecision tmp(0.0);
3180 tmp.set_k(dot.get_k());
3181 accumulate(tmp,x,y);
3182 dot += tmp;
3183}
3184
3186
3189inline void accumulate(cidotprecision& dot, const scvector& x, const cvector_slice& y) {
3190 cdotprecision tmp(0.0);
3191 tmp.set_k(dot.get_k());
3192 accumulate(tmp,x,y);
3193 dot += tmp;
3194}
3195
3197
3200inline void accumulate(cidotprecision& dot, const scvector& x, const rvector_slice& y) {
3201 cdotprecision tmp(0.0);
3202 tmp.set_k(dot.get_k());
3203 accumulate(tmp,x,y);
3204 dot += tmp;
3205}
3206
3208
3211inline void accumulate(cidotprecision& dot, const srvector& x, const cvector_slice& y) {
3212 cdotprecision tmp(0.0);
3213 tmp.set_k(dot.get_k());
3214 accumulate(tmp,x,y);
3215 dot += tmp;
3216}
3217
3219
3222inline void accumulate(cidotprecision& dot, const cvector& x, const scvector& y) {
3223 cdotprecision tmp(0.0);
3224 tmp.set_k(dot.get_k());
3225 accumulate(tmp,x,y);
3226 dot += tmp;
3227}
3228
3230
3233inline void accumulate(cidotprecision& dot, const cvector& x, const srvector& y) {
3234 cdotprecision tmp(0.0);
3235 tmp.set_k(dot.get_k());
3236 accumulate(tmp,x,y);
3237 dot += tmp;
3238}
3239
3241
3244inline void accumulate(cidotprecision& dot, const rvector& x, const scvector& y) {
3245 cdotprecision tmp(0.0);
3246 tmp.set_k(dot.get_k());
3247 accumulate(tmp,x,y);
3248 dot += tmp;
3249}
3250
3252
3255inline void accumulate(cidotprecision& dot, const cvector_slice& x, const scvector& y) {
3256 cdotprecision tmp(0.0);
3257 tmp.set_k(dot.get_k());
3258 accumulate(tmp,x,y);
3259 dot += tmp;
3260}
3261
3263
3266inline void accumulate(cidotprecision& dot, const cvector_slice& x, const srvector& y) {
3267 cdotprecision tmp(0.0);
3268 tmp.set_k(dot.get_k());
3269 accumulate(tmp,x,y);
3270 dot += tmp;
3271}
3272
3274
3277inline void accumulate(cidotprecision& dot, const rvector_slice& x, const scvector& y) {
3278 cdotprecision tmp(0.0);
3279 tmp.set_k(dot.get_k());
3280 accumulate(tmp,x,y);
3281 dot += tmp;
3282}
3283
3285
3288inline void accumulate(cidotprecision& dot, const scvector_slice& x, const cvector& y) {
3289 cdotprecision tmp(0.0);
3290 tmp.set_k(dot.get_k());
3291 accumulate(tmp,x,y);
3292 dot += tmp;
3293}
3294
3296
3299inline void accumulate(cidotprecision& dot, const scvector_slice& x, const rvector& y) {
3300 cdotprecision tmp(0.0);
3301 tmp.set_k(dot.get_k());
3302 accumulate(tmp,x,y);
3303 dot += tmp;
3304}
3305
3307
3310inline void accumulate(cidotprecision& dot, const srvector_slice& x, const cvector& y) {
3311 cdotprecision tmp(0.0);
3312 tmp.set_k(dot.get_k());
3313 accumulate(tmp,x,y);
3314 dot += tmp;
3315}
3316
3318
3321inline void accumulate(cidotprecision& dot, const scvector_slice& x, const cvector_slice& y) {
3322 cdotprecision tmp(0.0);
3323 tmp.set_k(dot.get_k());
3324 accumulate(tmp,x,y);
3325 dot += tmp;
3326}
3327
3329
3332inline void accumulate(cidotprecision& dot, const scvector_slice& x, const rvector_slice& y) {
3333 cdotprecision tmp(0.0);
3334 tmp.set_k(dot.get_k());
3335 accumulate(tmp,x,y);
3336 dot += tmp;
3337}
3338
3340
3343inline void accumulate(cidotprecision& dot, const srvector_slice& x, const cvector_slice& y) {
3344 cdotprecision tmp(0.0);
3345 tmp.set_k(dot.get_k());
3346 accumulate(tmp,x,y);
3347 dot += tmp;
3348}
3349
3351
3354inline void accumulate(cidotprecision& dot, const cvector& x, const scvector_slice& y) {
3355 cdotprecision tmp(0.0);
3356 tmp.set_k(dot.get_k());
3357 accumulate(tmp,x,y);
3358 dot += tmp;
3359}
3360
3362
3365inline void accumulate(cidotprecision& dot, const cvector& x, const srvector_slice& y) {
3366 cdotprecision tmp(0.0);
3367 tmp.set_k(dot.get_k());
3368 accumulate(tmp,x,y);
3369 dot += tmp;
3370}
3371
3373
3376inline void accumulate(cidotprecision& dot, const rvector& x, const scvector_slice& y) {
3377 cdotprecision tmp(0.0);
3378 tmp.set_k(dot.get_k());
3379 accumulate(tmp,x,y);
3380 dot += tmp;
3381}
3382
3384
3387inline void accumulate(cidotprecision& dot, const cvector_slice& x, const scvector_slice& y) {
3388 cdotprecision tmp(0.0);
3389 tmp.set_k(dot.get_k());
3390 accumulate(tmp,x,y);
3391 dot += tmp;
3392}
3393
3395
3398inline void accumulate(cidotprecision& dot, const cvector_slice& x, const srvector_slice& y) {
3399 cdotprecision tmp(0.0);
3400 tmp.set_k(dot.get_k());
3401 accumulate(tmp,x,y);
3402 dot += tmp;
3403}
3404
3406
3409inline void accumulate(cidotprecision& dot, const rvector_slice& x, const scvector_slice& y) {
3410 cdotprecision tmp(0.0);
3411 tmp.set_k(dot.get_k());
3412 accumulate(tmp,x,y);
3413 dot += tmp;
3414}
3415
3417
3420inline void accumulate(cidotprecision& dot, const scvector_slice& x, const scvector_slice& y) {
3421 cdotprecision tmp(0.0);
3422 tmp.set_k(dot.get_k());
3423 accumulate(tmp,x,y);
3424 dot += tmp;
3425}
3426
3428
3431inline void accumulate(cidotprecision& dot, const scvector_slice& x, const srvector_slice& y) {
3432 cdotprecision tmp(0.0);
3433 tmp.set_k(dot.get_k());
3434 accumulate(tmp,x,y);
3435 dot += tmp;
3436}
3437
3439
3442inline void accumulate(cidotprecision& dot, const srvector_slice& x, const scvector_slice& y) {
3443 cdotprecision tmp(0.0);
3444 tmp.set_k(dot.get_k());
3445 accumulate(tmp,x,y);
3446 dot += tmp;
3447}
3448
3450
3453inline void accumulate(cidotprecision& dot, const scvector& x, const scvector_slice& y) {
3454 cdotprecision tmp(0.0);
3455 tmp.set_k(dot.get_k());
3456 accumulate(tmp,x,y);
3457 dot += tmp;
3458}
3459
3461
3464inline void accumulate(cidotprecision& dot, const scvector& x, const srvector_slice& y) {
3465 cdotprecision tmp(0.0);
3466 tmp.set_k(dot.get_k());
3467 accumulate(tmp,x,y);
3468 dot += tmp;
3469}
3470
3472
3475inline void accumulate(cidotprecision& dot, const srvector& x, const scvector_slice& y) {
3476 cdotprecision tmp(0.0);
3477 tmp.set_k(dot.get_k());
3478 accumulate(tmp,x,y);
3479 dot += tmp;
3480}
3481
3483
3486inline void accumulate(cidotprecision& dot, const scvector_slice& x, const scvector& y) {
3487 cdotprecision tmp(0.0);
3488 tmp.set_k(dot.get_k());
3489 accumulate(tmp,x,y);
3490 dot += tmp;
3491}
3492
3494
3497inline void accumulate(cidotprecision& dot, const scvector_slice& x, const srvector& y) {
3498 cdotprecision tmp(0.0);
3499 tmp.set_k(dot.get_k());
3500 accumulate(tmp,x,y);
3501 dot += tmp;
3502}
3503
3505
3508inline void accumulate(cidotprecision& dot, const srvector_slice& x, const scvector& y) {
3509 cdotprecision tmp(0.0);
3510 tmp.set_k(dot.get_k());
3511 accumulate(tmp,x,y);
3512 dot += tmp;
3513}
3514
3515} //namespace cxsc
3516
3517#include "sparsevector.inl"
3518
3519#endif
The Data Type cdotprecision.
Definition cdot.hpp:61
void set_k(unsigned int i)
Set precision for computation of dot products.
Definition cdot.hpp:93
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 Scalar Type complex.
Definition complex.hpp:50
The Data Type cvector_slice.
Definition cvector.hpp:845
cvector_slice & operator-=(const cvector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition cvector.inl:597
cvector_slice & operator+=(const cvector &rv) noexcept
Implementation of addition and allocation operation.
Definition cvector.inl:538
cvector_slice & operator=(const scvector &sl)
Implementation of standard assigning operator.
The Data Type cvector.
Definition cvector.hpp:58
cvector() noexcept
Constructor of class cvector.
Definition cvector.inl:31
cvector & operator=(const cvector &rv) noexcept
Implementation of standard assigning operator.
Definition cvector.inl:276
The Data Type intmatrix.
The Data Type intvector.
Definition intvector.hpp:52
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.
scvector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scvector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scvector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
scvector_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
scvector_slice & operator-=(const scvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend int VecLen(const scvector_slice &)
Returns the length of the vector slice.
friend srvector Im(const scvector_slice &)
Returns the imaginary part of the complex vector slice.
scvector_slice & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scvector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
const complex operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
friend int Ub(const scvector_slice &)
Returns the upper index bound of the vector slice v.
scvector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
scvector_slice & operator/=(const real &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
scvector_slice & operator/=(const complex &s)
Operator for division of each element of the vector slice with a scalar, result is assigned to the ve...
scvector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
scvector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scvector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
complex operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
scvector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scvector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
scvector_slice & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scvector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
complex & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
scvector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scvector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
friend srvector Re(const scvector_slice &)
Returns the real part of the complex vector slice.
scvector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
scvector_slice & operator+=(const scvector &v)
Operator for element-wise addition 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...
friend int Lb(const scvector_slice &)
Returns the lower index bound of the vector slice v.
scvector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
scvector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
scvector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
A sparse complex vector.
Definition scvector.hpp:58
scvector(const srmatrix_subv &A)
Creates a sparse vector out of a row or column of a sparse matrix.
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition scvector.hpp:147
scvector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition scvector.hpp:94
scvector & operator=(const cvector_slice &v)
Assign the dense vector slice v to a sparse vector. Only the non zero elements of v are used.
Definition scvector.hpp:234
scvector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition scvector.hpp:354
scvector & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition scvector.hpp:390
scvector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition scvector.hpp:214
friend int Ub(const scvector &)
Returns the upper index bound of the vector v.
Definition scvector.hpp:512
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
friend srvector Re(const scvector &)
Returns the real part of the complex vector v.
Definition scvector.hpp:517
scvector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition scvector.hpp:379
scvector & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition scvector.hpp:400
scvector(const int n, const int nnz, const intvector &index, const cvector &values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition scvector.hpp:104
friend srvector abs(const scvector &)
Returns the vector of component-wise absolute values of v.
Definition scvector.hpp:539
scvector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition scvector.hpp:323
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition scvector.hpp:188
scvector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition scvector.hpp:344
friend int VecLen(const scvector &)
Returns the length of the vector (the dimension)
Definition scvector.hpp:555
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
Definition scvector.hpp:183
friend scvector diam(const scivector &)
Computes the diameter of v.
scvector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition scvector.hpp:374
scvector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition scvector.hpp:405
scvector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition scvector.hpp:209
scvector(const srvector &v)
Constructor for creating a sparse complex vector our of a sparse real vector.
Definition scvector.hpp:126
scvector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition scvector.hpp:300
scvector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition scvector.hpp:359
scvector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector
Definition scvector.hpp:334
const complex operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition scvector.hpp:282
friend srvector Im(const scvector &)
Returns the imaginary part of the complex vector v.
Definition scvector.hpp:528
friend scvector Sup(const scivector &)
Returns the supremum of the complex interval vector as a new sparse point vector.
scvector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition scvector.hpp:364
friend int Lb(const scvector &)
Returns the lower index bound of the vector v.
Definition scvector.hpp:507
friend void SetLb(scvector &, const int)
Sets the lower index bound of the vector v to i.
Definition scvector.hpp:492
scvector()
Default constructor, creates an empty vector of size 0
Definition scvector.hpp:68
scvector & operator*=(const complex &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition scvector.hpp:339
scvector & operator=(const cvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition scvector.hpp:224
scvector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition scvector.hpp:385
const std::vector< complex > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition scvector.hpp:173
scvector(const int n, const int nnz, const int *index, const complex *values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition scvector.hpp:115
scvector & operator=(const srvector &v)
Assigns a sparse real vector to a sparse complex vector.
Definition scvector.hpp:198
complex & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
Definition scvector.hpp:248
scvector & 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 scvector.hpp:229
scvector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition scvector.hpp:410
int get_nnz() const
Returns the number of non zero elements of this vector (note that this includes explicitly stored zer...
Definition scvector.hpp:178
scvector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
Definition scvector.hpp:78
std::vector< complex > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition scvector.hpp:155
scvector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition scvector.hpp:369
friend void SetUb(scvector &, const int)
Sets the upper index bound of the vector v to i.
Definition scvector.hpp:501
scvector(const int s)
Constructor for creating an empty vector of size s.
Definition scvector.hpp:72
scvector & operator/=(const complex &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition scvector.hpp:349
complex operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition scvector.hpp:270
scvector(const cvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition scvector.hpp:84
scvector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition scvector.hpp:219
scvector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition scvector.hpp:395
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition scvector.hpp:165
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
Represents a row or column vector of a sparse matrix.
Helper class for slices of sparse vectors.
Definition srvector.hpp:868
A sparse real vector.
Definition srvector.hpp:58
std::vector< real > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition srvector.hpp:136
std::vector< int > & row_indices()
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition srvector.hpp:127
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.
void accumulate_approx(cdotprecision &dp, const cmatrix_subv &rv1, const cmatrix_subv &rv2)
The accurate scalar product of the last two arguments added to the value of the first argument (witho...
Definition cmatrix.cpp:99
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
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.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
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.