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 
37 namespace cxsc {
38 
39 class srvector_slice;
40 class srmatrix;
41 class srmatrix_slice;
42 class srmatrix_subv;
43 class scvector_slice;
44 class scmatrix;
45 class scmatrix_slice;
46 class scmatrix_subv;
47 class scivector;
48 class scivector_slice;
49 class scimatrix;
50 class scimatrix_slice;
51 class scimatrix_subv;
52 
54 
58 class 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&);
137  scvector(const srmatrix_subv& A);
139  scvector(const scmatrix_subv& A);
140 
142 
147  std::vector<int>& row_indices() {
148  return p;
149  }
150 
152  std::vector<complex>& values() {
156  return x;
157  }
158 
160 
165  const std::vector<int>& row_indices() const {
166  return p;
167  }
168 
170  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 
209  scvector& operator=(const real& v) {
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 
334  scvector& operator*=(const real& s) {
335  return sp_vs_multassign(*this,s);
336  }
337 
340  return sp_vs_multassign(*this,s);
341  }
342 
344  scvector& operator/=(const real& s) {
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 
450 inline 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 
461 inline 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 
492 inline void SetLb(scvector& v, const int i) {
493  v.lb = i;
494  v.ub = v.lb + v.n - 1;
495 }
496 
498 
501 inline void SetUb(scvector& v, const int j) {
502  v.ub = j;
503  v.lb = v.ub - v.n + 1;
504 }
505 
507 inline int Lb(const scvector& v) {
508  return v.lb;
509 }
510 
512 inline int Ub(const scvector& v) {
513  return v.ub;
514 }
515 
517 inline 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 
528 inline 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 
539 inline 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 
555 inline int VecLen(const scvector& v) {
556  return v.n;
557 }
558 
560 inline void Resize(scvector& v) {
561  sp_v_resize(v);
562 }
563 
565 
568 inline void Resize(scvector& v, const int n) {
569  sp_v_resize(v,n);
570 }
571 
573 
577 inline void Resize(scvector& v, const int l, const int u) {
578  sp_v_resize(v,l,u);
579 }
580 
582 inline scvector operator-(const scvector& v) {
583  return sp_v_negative(v);
584 }
585 
587 
593 inline complex operator*(const scvector& v1, const cvector& v2) {
594  return spf_vv_mult<scvector,cvector,complex,sparse_cdot>(v1,v2);
595 }
596 
598 
604 inline complex operator*(const scvector& v1, const rvector& v2) {
605  return spf_vv_mult<scvector,rvector,complex,sparse_cdot>(v1,v2);
606 }
607 
609 
615 inline complex operator*(const srvector& v1, const cvector& v2) {
616  return spf_vv_mult<srvector,cvector,complex,sparse_cdot>(v1,v2);
617 }
618 
620 
626 inline complex operator*(const rvector& v1, const scvector& v2) {
627  return fsp_vv_mult<rvector,scvector,complex,sparse_cdot>(v1,v2);
628 }
629 
631 
637 inline complex operator*(const cvector& v1, const srvector& v2) {
638  return fsp_vv_mult<cvector,srvector,complex,sparse_cdot>(v1,v2);
639 }
640 
642 
648 inline complex operator*(const cvector& v1, const scvector& v2) {
649  return fsp_vv_mult<cvector,scvector,complex,sparse_cdot>(v1,v2);
650 }
651 
653 
659 inline 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 
670 inline 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 
681 inline 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 
692 inline 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 
703 inline 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 
714 inline 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 
725 inline complex operator*(const scvector& v1, const srvector& v2) {
726  return spsp_vv_mult<scvector,srvector,complex,sparse_cdot>(v1,v2);
727 }
728 
730 
736 inline complex operator*(const srvector& v1, const scvector& v2) {
737  return spsp_vv_mult<srvector,scvector,complex,sparse_cdot>(v1,v2);
738 }
739 
741 
747 inline complex operator*(const scvector& v1, const scvector& v2) {
748  return spsp_vv_mult<scvector,scvector,complex,sparse_cdot>(v1,v2);
749 }
750 
752 inline scvector operator*(const scvector& v, const real& s) {
753  return sp_vs_mult<scvector,real,scvector>(v,s);
754 }
755 
757 inline scvector operator*(const scvector& v, const complex& s) {
758  return sp_vs_mult<scvector,complex,scvector>(v,s);
759 }
760 
762 inline scvector operator*(const srvector& v, const complex& s) {
763  return sp_vs_mult<srvector,complex,scvector>(v,s);
764 }
765 
767 inline scvector operator/(const scvector& v, const real& s) {
768  return sp_vs_div<scvector,real,scvector>(v,s);
769 }
770 
772 inline scvector operator/(const scvector& v, const complex& s) {
773  return sp_vs_div<scvector,complex,scvector>(v,s);
774 }
775 
777 inline scvector operator/(const srvector& v, const complex& s) {
778  return sp_vs_div<srvector,complex,scvector>(v,s);
779 }
780 
782 inline scvector operator*(const real& s, const scvector& v) {
783  return sp_sv_mult<real,scvector,scvector>(s,v);
784 }
785 
787 inline scvector operator*(const complex& s, const scvector& v) {
788  return sp_sv_mult<complex,scvector,scvector>(s,v);
789 }
790 
792 inline scvector operator*(const complex& s, const srvector& v) {
793  return sp_sv_mult<complex,srvector,scvector>(s,v);
794 }
795 
797 inline cvector operator+(const cvector& v1, const srvector& v2) {
798  return fsp_vv_add<cvector,srvector,cvector>(v1,v2);
799 }
800 
802 inline cvector operator+(const rvector& v1, const scvector& v2) {
803  return fsp_vv_add<rvector,scvector,cvector>(v1,v2);
804 }
805 
807 inline cvector operator+(const cvector& v1, const scvector& v2) {
808  return fsp_vv_add<cvector,scvector,cvector>(v1,v2);
809 }
810 
812 inline cvector operator+(const scvector& v1, const rvector& v2) {
813  return spf_vv_add<scvector,rvector,cvector>(v1,v2);
814 }
815 
817 inline cvector operator+(const srvector& v1, const cvector& v2) {
818  return spf_vv_add<srvector,cvector,cvector>(v1,v2);
819 }
820 
822 inline cvector operator+(const scvector& v1, const cvector& v2) {
823  return spf_vv_add<scvector,cvector,cvector>(v1,v2);
824 }
825 
827 inline cvector operator+(const cvector_slice& v1, const srvector& v2) {
828  return fsp_vv_add<cvector_slice,srvector,cvector>(v1,v2);
829 }
830 
832 inline cvector operator+(const rvector_slice& v1, const scvector& v2) {
833  return fsp_vv_add<rvector_slice,scvector,cvector>(v1,v2);
834 }
835 
837 inline cvector operator+(const cvector_slice& v1, const scvector& v2) {
838  return fsp_vv_add<cvector_slice,scvector,cvector>(v1,v2);
839 }
840 
842 inline cvector operator+(const scvector& v1, const rvector_slice& v2) {
843  return spf_vv_add<scvector,rvector_slice,cvector>(v1,v2);
844 }
845 
847 inline cvector operator+(const srvector& v1, const cvector_slice& v2) {
848  return spf_vv_add<srvector,cvector_slice,cvector>(v1,v2);
849 }
850 
852 inline cvector operator+(const scvector& v1, const cvector_slice& v2) {
853  return spf_vv_add<scvector,cvector_slice,cvector>(v1,v2);
854 }
855 
857 inline scvector operator+(const scvector& v1, const srvector& v2) {
858  return spsp_vv_add<scvector,srvector,scvector,complex>(v1,v2);
859 }
860 
862 inline scvector operator+(const srvector& v1, const scvector& v2) {
863  return spsp_vv_add<srvector,scvector,scvector,complex>(v1,v2);
864 }
865 
867 inline scvector operator+(const scvector& v1, const scvector& v2) {
868  return spsp_vv_add<scvector,scvector,scvector,complex>(v1,v2);
869 }
870 
872 inline cvector operator-(const cvector& v1, const srvector& v2) {
873  return fsp_vv_sub<cvector,srvector,cvector>(v1,v2);
874 }
875 
877 inline cvector operator-(const rvector& v1, const scvector& v2) {
878  return fsp_vv_sub<rvector,scvector,cvector>(v1,v2);
879 }
880 
882 inline cvector operator-(const cvector& v1, const scvector& v2) {
883  return fsp_vv_sub<cvector,scvector,cvector>(v1,v2);
884 }
885 
887 inline cvector operator-(const scvector& v1, const rvector& v2) {
888  return spf_vv_sub<scvector,rvector,cvector>(v1,v2);
889 }
890 
892 inline cvector operator-(const srvector& v1, const cvector& v2) {
893  return spf_vv_sub<srvector,cvector,cvector>(v1,v2);
894 }
895 
897 inline cvector operator-(const scvector& v1, const cvector& v2) {
898  return spf_vv_sub<scvector,cvector,cvector>(v1,v2);
899 }
900 
902 inline cvector operator-(const cvector_slice& v1, const srvector& v2) {
903  return fsp_vv_sub<cvector_slice,srvector,cvector>(v1,v2);
904 }
905 
907 inline cvector operator-(const rvector_slice& v1, const scvector& v2) {
908  return fsp_vv_sub<rvector_slice,scvector,cvector>(v1,v2);
909 }
910 
912 inline cvector operator-(const cvector_slice& v1, const scvector& v2) {
913  return fsp_vv_sub<cvector_slice,scvector,cvector>(v1,v2);
914 }
915 
917 inline cvector operator-(const scvector& v1, const rvector_slice& v2) {
918  return spf_vv_sub<scvector,rvector_slice,cvector>(v1,v2);
919 }
920 
922 inline cvector operator-(const srvector& v1, const cvector_slice& v2) {
923  return spf_vv_sub<srvector,cvector_slice,cvector>(v1,v2);
924 }
925 
927 inline cvector operator-(const scvector& v1, const cvector_slice& v2) {
928  return spf_vv_sub<scvector,cvector_slice,cvector>(v1,v2);
929 }
930 
932 inline scvector operator-(const scvector& v1, const srvector& v2) {
933  return spsp_vv_sub<scvector,srvector,scvector,complex>(v1,v2);
934 }
935 
937 inline scvector operator-(const srvector& v1, const scvector& v2) {
938  return spsp_vv_sub<srvector,scvector,scvector,complex>(v1,v2);
939 }
940 
942 inline scvector operator-(const scvector& v1, const scvector& v2) {
943  return spsp_vv_sub<scvector,scvector,scvector,complex>(v1,v2);
944 }
945 
946 inline cvector& cvector::operator+=(const srvector& v2) {
947  return fsp_vv_addassign(*this,v2);
948 }
949 
950 inline cvector& cvector::operator+=(const scvector& v2) {
951  return fsp_vv_addassign(*this,v2);
952 }
953 
954 inline cvector_slice& cvector_slice::operator+=(const srvector& v2) {
955  return fsp_vv_addassign(*this,v2);
956 }
957 
958 inline cvector_slice& cvector_slice::operator+=(const scvector& v2) {
959  return fsp_vv_addassign(*this,v2);
960 }
961 
962 inline cvector& cvector::operator-=(const srvector& v2) {
963  return fsp_vv_subassign(*this,v2);
964 }
965 
966 inline cvector& cvector::operator-=(const scvector& v2) {
967  return fsp_vv_subassign(*this,v2);
968 }
969 
970 inline cvector_slice& cvector_slice::operator-=(const srvector& v2) {
971  return fsp_vv_subassign(*this,v2);
972 }
973 
974 inline cvector_slice& cvector_slice::operator-=(const scvector& v2) {
975  return fsp_vv_subassign(*this,v2);
976 }
977 
979 
982 inline bool operator==(const scvector& v1, const scvector& v2) {
983  return spsp_vv_comp(v1,v2);
984 }
985 
987 
990 inline bool operator==(const scvector& v1, const srvector& v2) {
991  return spsp_vv_comp(v1,v2);
992 }
993 
995 
998 inline bool operator==(const srvector& v1, const scvector& v2) {
999  return spsp_vv_comp(v1,v2);
1000 }
1001 
1003 
1006 inline bool operator==(const scvector& v1, const rvector& v2) {
1007  return spf_vv_comp(v1,v2);
1008 }
1009 
1011 
1014 inline bool operator==(const srvector& v1, const cvector& v2) {
1015  return spf_vv_comp(v1,v2);
1016 }
1017 
1019 
1022 inline bool operator==(const scvector& v1, const cvector& v2) {
1023  return spf_vv_comp(v1,v2);
1024 }
1025 
1027 
1030 inline bool operator==(const cvector& v1, const srvector& v2) {
1031  return fsp_vv_comp(v1,v2);
1032 }
1033 
1035 
1038 inline bool operator==(const rvector& v1, const scvector& v2) {
1039  return fsp_vv_comp(v1,v2);
1040 }
1041 
1043 
1046 inline bool operator==(const cvector& v1, const scvector& v2) {
1047  return fsp_vv_comp(v1,v2);
1048 }
1049 
1051 
1054 inline bool operator==(const scvector& v1, const rvector_slice& v2) {
1055  return spf_vv_comp(v1,v2);
1056 }
1057 
1059 
1062 inline bool operator==(const srvector& v1, const cvector_slice& v2) {
1063  return spf_vv_comp(v1,v2);
1064 }
1065 
1067 
1070 inline bool operator==(const scvector& v1, const cvector_slice& v2) {
1071  return spf_vv_comp(v1,v2);
1072 }
1073 
1075 
1078 inline bool operator==(const cvector_slice& v1, const srvector& v2) {
1079  return fsp_vv_comp(v1,v2);
1080 }
1081 
1083 
1086 inline bool operator==(const rvector_slice& v1, const scvector& v2) {
1087  return fsp_vv_comp(v1,v2);
1088 }
1089 
1091 
1094 inline bool operator==(const cvector_slice& v1, const scvector& v2) {
1095  return fsp_vv_comp(v1,v2);
1096 }
1097 
1099 
1102 inline bool operator!=(const scvector& v1, const srvector& v2) {
1103  return !spsp_vv_comp(v1,v2);
1104 }
1105 
1107 
1110 inline bool operator!=(const srvector& v1, const scvector& v2) {
1111  return !spsp_vv_comp(v1,v2);
1112 }
1113 
1115 
1118 inline bool operator!=(const scvector& v1, const scvector& v2) {
1119  return !spsp_vv_comp(v1,v2);
1120 }
1121 
1123 
1126 inline bool operator!=(const scvector& v1, const rvector& v2) {
1127  return !spf_vv_comp(v1,v2);
1128 }
1129 
1131 
1134 inline bool operator!=(const srvector& v1, const cvector& v2) {
1135  return !spf_vv_comp(v1,v2);
1136 }
1137 
1139 
1142 inline bool operator!=(const scvector& v1, const cvector& v2) {
1143  return !spf_vv_comp(v1,v2);
1144 }
1145 
1147 
1150 inline bool operator!=(const cvector& v1, const srvector& v2) {
1151  return !fsp_vv_comp(v1,v2);
1152 }
1153 
1155 
1158 inline bool operator!=(const rvector& v1, const scvector& v2) {
1159  return !fsp_vv_comp(v1,v2);
1160 }
1161 
1163 
1166 inline bool operator!=(const cvector& v1, const scvector& v2) {
1167  return !fsp_vv_comp(v1,v2);
1168 }
1169 
1171 
1174 inline bool operator!=(const scvector& v1, const rvector_slice& v2) {
1175  return !spf_vv_comp(v1,v2);
1176 }
1177 
1179 
1182 inline bool operator!=(const srvector& v1, const cvector_slice& v2) {
1183  return !spf_vv_comp(v1,v2);
1184 }
1185 
1187 
1190 inline bool operator!=(const scvector& v1, const cvector_slice& v2) {
1191  return !spf_vv_comp(v1,v2);
1192 }
1193 
1195 
1198 inline bool operator!=(const cvector_slice& v1, const srvector& v2) {
1199  return !fsp_vv_comp(v1,v2);
1200 }
1201 
1203 
1206 inline bool operator!=(const rvector_slice& v1, const scvector& v2) {
1207  return !fsp_vv_comp(v1,v2);
1208 }
1209 
1211 
1214 inline bool operator!=(const cvector_slice& v1, const scvector& v2) {
1215  return !fsp_vv_comp(v1,v2);
1216 }
1217 
1219 
1224 inline std::ostream& operator<<(std::ostream& os, const scvector& v) {
1225  return sp_v_output<scvector,complex>(os,v);
1226 }
1227 
1229 
1234 inline 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 
1555 inline 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 
1566 inline 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 
1585 inline 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 
1593 inline scvector operator-(const scvector_slice& v) {
1594  return sl_v_negative<scvector_slice,scvector>(v);
1595 }
1596 
1598 inline int Lb(const scvector_slice& v) {
1599  return v.lb;
1600 }
1601 
1603 inline int Ub(const scvector_slice& v) {
1604  return v.ub;
1605 }
1606 
1608 inline srvector Re(const scvector_slice& v) {
1609  return Re(scvector(v));
1610 }
1611 
1613 inline srvector Im(const scvector_slice& v) {
1614  return Im(scvector(v));
1615 }
1616 
1618 inline int VecLen(const scvector_slice& v) {
1619  return v.n;
1620 }
1621 
1623 
1629 inline 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 
1640 inline 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 
1651 inline 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 
1662 inline 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 
1673 inline 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 
1684 inline 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 
1695 inline 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 
1706 inline 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 
1717 inline 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 
1728 inline 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 
1739 inline 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 
1750 inline 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 
1761 inline 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 
1772 inline 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 
1783 inline 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 
1794 inline 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 
1805 inline 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 
1816 inline 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 
1827 inline 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 
1838 inline 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 
1849 inline 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 
1854 inline scvector operator*(const scvector_slice& v, const real& s) {
1855  return sp_vs_mult<scvector_slice,real,scvector>(v,s);
1856 }
1857 
1859 inline scvector operator*(const scvector_slice& v, const complex& s) {
1860  return sp_vs_mult<scvector_slice,complex,scvector>(v,s);
1861 }
1862 
1864 inline scvector operator*(const srvector_slice& v, const complex& s) {
1865  return sp_vs_mult<srvector_slice,complex,scvector>(v,s);
1866 }
1867 
1869 inline scvector operator/(const scvector_slice& v, const real& s) {
1870  return sp_vs_div<scvector_slice,real,scvector>(v,s);
1871 }
1872 
1874 inline scvector operator/(const scvector_slice& v, const complex& s) {
1875  return sp_vs_div<scvector_slice,complex,scvector>(v,s);
1876 }
1877 
1879 inline scvector operator/(const srvector_slice& v, const complex& s) {
1880  return sp_vs_div<srvector_slice,complex,scvector>(v,s);
1881 }
1882 
1884 inline scvector operator*(const real& s, const scvector_slice& v) {
1885  return sp_sv_mult<real,scvector_slice,scvector>(s,v);
1886 }
1887 
1889 inline scvector operator*(const complex& s, const scvector_slice& v) {
1890  return sp_sv_mult<complex,scvector_slice,scvector>(s,v);
1891 }
1892 
1894 inline scvector operator*(const complex& s, const srvector_slice& v) {
1895  return sp_sv_mult<complex,srvector_slice,scvector>(s,v);
1896 }
1897 
1899 inline cvector operator+(const cvector& v1, const srvector_slice& v2) {
1900  return fsl_vv_add<cvector,srvector_slice,cvector>(v1,v2);
1901 }
1902 
1904 inline cvector operator+(const rvector& v1, const scvector_slice& v2) {
1905  return fsl_vv_add<rvector,scvector_slice,cvector>(v1,v2);
1906 }
1907 
1909 inline cvector operator+(const cvector& v1, const scvector_slice& v2) {
1910  return fsl_vv_add<cvector,scvector_slice,cvector>(v1,v2);
1911 }
1912 
1914 inline cvector operator+(const scvector_slice& v1, const rvector& v2) {
1915  return slf_vv_add<scvector_slice,rvector,cvector>(v1,v2);
1916 }
1917 
1919 inline cvector operator+(const srvector_slice& v1, const cvector& v2) {
1920  return slf_vv_add<srvector_slice,cvector,cvector>(v1,v2);
1921 }
1922 
1924 inline cvector operator+(const scvector_slice& v1, const cvector& v2) {
1925  return slf_vv_add<scvector_slice,cvector,cvector>(v1,v2);
1926 }
1927 
1929 inline cvector operator+(const cvector_slice& v1, const srvector_slice& v2) {
1930  return fsl_vv_add<cvector_slice,srvector_slice,cvector>(v1,v2);
1931 }
1932 
1934 inline cvector operator+(const rvector_slice& v1, const scvector_slice& v2) {
1935  return fsl_vv_add<rvector_slice,scvector_slice,cvector>(v1,v2);
1936 }
1937 
1939 inline cvector operator+(const cvector_slice& v1, const scvector_slice& v2) {
1940  return fsl_vv_add<cvector_slice,scvector_slice,cvector>(v1,v2);
1941 }
1942 
1944 inline cvector operator+(const scvector_slice& v1, const rvector_slice& v2) {
1945  return slf_vv_add<scvector_slice,rvector_slice,cvector>(v1,v2);
1946 }
1947 
1949 inline cvector operator+(const srvector_slice& v1, const cvector_slice& v2) {
1950  return slf_vv_add<srvector_slice,cvector_slice,cvector>(v1,v2);
1951 }
1952 
1954 inline cvector operator+(const scvector_slice& v1, const cvector_slice& v2) {
1955  return slf_vv_add<scvector_slice,cvector_slice,cvector>(v1,v2);
1956 }
1957 
1959 inline 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 
1964 inline 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 
1969 inline 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 
1974 inline scvector operator+(const scvector& v1, const srvector_slice& v2) {
1975  return spsl_vv_add<scvector,srvector_slice,scvector,complex>(v1,v2);
1976 }
1977 
1979 inline scvector operator+(const srvector& v1, const scvector_slice& v2) {
1980  return spsl_vv_add<srvector,scvector_slice,scvector,complex>(v1,v2);
1981 }
1982 
1984 inline scvector operator+(const scvector& v1, const scvector_slice& v2) {
1985  return spsl_vv_add<scvector,scvector_slice,scvector,complex>(v1,v2);
1986 }
1987 
1989 inline scvector operator+(const scvector_slice& v1, const srvector& v2) {
1990  return slsp_vv_add<scvector_slice,srvector,scvector,complex>(v1,v2);
1991 }
1992 
1994 inline scvector operator+(const srvector_slice& v1, const scvector& v2) {
1995  return slsp_vv_add<srvector_slice,scvector,scvector,complex>(v1,v2);
1996 }
1997 
1999 inline scvector operator+(const scvector_slice& v1, const scvector& v2) {
2000  return slsp_vv_add<scvector_slice,scvector,scvector,complex>(v1,v2);
2001 }
2002 
2004 inline cvector operator-(const cvector& v1, const srvector_slice& v2) {
2005  return fsl_vv_sub<cvector,srvector_slice,cvector>(v1,v2);
2006 }
2007 
2009 inline cvector operator-(const rvector& v1, const scvector_slice& v2) {
2010  return fsl_vv_sub<rvector,scvector_slice,cvector>(v1,v2);
2011 }
2012 
2014 inline cvector operator-(const cvector& v1, const scvector_slice& v2) {
2015  return fsl_vv_sub<cvector,scvector_slice,cvector>(v1,v2);
2016 }
2017 
2019 inline cvector operator-(const scvector_slice& v1, const rvector& v2) {
2020  return slf_vv_sub<scvector_slice,rvector,cvector>(v1,v2);
2021 }
2022 
2024 inline cvector operator-(const srvector_slice& v1, const cvector& v2) {
2025  return slf_vv_sub<srvector_slice,cvector,cvector>(v1,v2);
2026 }
2027 
2029 inline cvector operator-(const scvector_slice& v1, const cvector& v2) {
2030  return slf_vv_sub<scvector_slice,cvector,cvector>(v1,v2);
2031 }
2032 
2034 inline cvector operator-(const cvector_slice& v1, const srvector_slice& v2) {
2035  return fsl_vv_sub<cvector_slice,srvector_slice,cvector>(v1,v2);
2036 }
2037 
2039 inline cvector operator-(const rvector_slice& v1, const scvector_slice& v2) {
2040  return fsl_vv_sub<rvector_slice,scvector_slice,cvector>(v1,v2);
2041 }
2042 
2044 inline cvector operator-(const cvector_slice& v1, const scvector_slice& v2) {
2045  return fsl_vv_sub<cvector_slice,scvector_slice,cvector>(v1,v2);
2046 }
2047 
2049 inline cvector operator-(const scvector_slice& v1, const rvector_slice& v2) {
2050  return slf_vv_sub<scvector_slice,rvector_slice,cvector>(v1,v2);
2051 }
2052 
2054 inline cvector operator-(const srvector_slice& v1, const cvector_slice& v2) {
2055  return slf_vv_sub<srvector_slice,cvector_slice,cvector>(v1,v2);
2056 }
2057 
2059 inline cvector operator-(const scvector_slice& v1, const cvector_slice& v2) {
2060  return slf_vv_sub<scvector_slice,cvector_slice,cvector>(v1,v2);
2061 }
2062 
2064 inline 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 
2069 inline 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 
2074 inline 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 
2079 inline scvector operator-(const scvector& v1, const srvector_slice& v2) {
2080  return spsl_vv_sub<scvector,srvector_slice,scvector,complex>(v1,v2);
2081 }
2082 
2084 inline scvector operator-(const srvector& v1, const scvector_slice& v2) {
2085  return spsl_vv_sub<srvector,scvector_slice,scvector,complex>(v1,v2);
2086 }
2087 
2089 inline scvector operator-(const scvector& v1, const scvector_slice& v2) {
2090  return spsl_vv_sub<scvector,scvector_slice,scvector,complex>(v1,v2);
2091 }
2092 
2094 inline scvector operator-(const scvector_slice& v1, const srvector& v2) {
2095  return slsp_vv_sub<scvector_slice,srvector,scvector,complex>(v1,v2);
2096 }
2097 
2099 inline scvector operator-(const srvector_slice& v1, const scvector& v2) {
2100  return slsp_vv_sub<srvector_slice,scvector,scvector,complex>(v1,v2);
2101 }
2102 
2104 inline scvector operator-(const scvector_slice& v1, const scvector& v2) {
2105  return slsp_vv_sub<scvector_slice,scvector,scvector,complex>(v1,v2);
2106 }
2107 
2108 inline cvector& cvector::operator+=(const srvector_slice& v2) {
2109  return fsl_vv_addassign(*this,v2);
2110 }
2111 
2112 inline cvector& cvector::operator+=(const scvector_slice& v2) {
2113  return fsl_vv_addassign(*this,v2);
2114 }
2115 
2116 inline cvector_slice& cvector_slice::operator+=(const srvector_slice& v2) {
2117  return fsl_vv_addassign(*this,v2);
2118 }
2119 
2120 inline 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 
2132 inline cvector& cvector::operator-=(const srvector_slice& v2) {
2133  return fsl_vv_subassign(*this,v2);
2134 }
2135 
2136 inline cvector& cvector::operator-=(const scvector_slice& v2) {
2137  return fsl_vv_subassign(*this,v2);
2138 }
2139 
2140 inline cvector_slice& cvector_slice::operator-=(const srvector_slice& v2) {
2141  return fsl_vv_subassign(*this,v2);
2142 }
2143 
2144 inline 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 
2160 inline bool operator==(const scvector_slice& v1, const srvector_slice& v2) {
2161  return slsl_vv_comp(v1,v2);
2162 }
2163 
2165 
2168 inline bool operator==(const srvector_slice& v1, const scvector_slice& v2) {
2169  return slsl_vv_comp(v1,v2);
2170 }
2171 
2173 
2176 inline bool operator==(const scvector_slice& v1, const scvector_slice& v2) {
2177  return slsl_vv_comp(v1,v2);
2178 }
2179 
2181 
2184 inline bool operator==(const scvector_slice& v1, const srvector& v2) {
2185  return slsp_vv_comp(v1,v2);
2186 }
2187 
2189 
2192 inline bool operator==(const srvector_slice& v1, const scvector& v2) {
2193  return slsp_vv_comp(v1,v2);
2194 }
2195 
2197 
2200 inline bool operator==(const scvector_slice& v1, const scvector& v2) {
2201  return slsp_vv_comp(v1,v2);
2202 }
2203 
2205 
2208 inline bool operator==(const scvector& v1, const srvector_slice& v2) {
2209  return spsl_vv_comp(v1,v2);
2210 }
2211 
2213 
2216 inline bool operator==(const srvector& v1, const scvector_slice& v2) {
2217  return spsl_vv_comp(v1,v2);
2218 }
2219 
2221 
2224 inline bool operator==(const scvector& v1, const scvector_slice& v2) {
2225  return spsl_vv_comp(v1,v2);
2226 }
2227 
2229 
2232 inline bool operator==(const scvector_slice& v1, const rvector& v2) {
2233  return slf_vv_comp(v1,v2);
2234 }
2235 
2237 
2240 inline bool operator==(const srvector_slice& v1, const cvector& v2) {
2241  return slf_vv_comp(v1,v2);
2242 }
2243 
2245 
2248 inline bool operator==(const scvector_slice& v1, const cvector& v2) {
2249  return slf_vv_comp(v1,v2);
2250 }
2251 
2253 
2256 inline bool operator==(const cvector& v1, const srvector_slice& v2) {
2257  return fsl_vv_comp(v1,v2);
2258 }
2259 
2261 
2264 inline bool operator==(const rvector& v1, const scvector_slice& v2) {
2265  return fsl_vv_comp(v1,v2);
2266 }
2267 
2269 
2272 inline bool operator==(const cvector& v1, const scvector_slice& v2) {
2273  return fsl_vv_comp(v1,v2);
2274 }
2275 
2277 
2280 inline bool operator==(const scvector_slice& v1, const rvector_slice& v2) {
2281  return slf_vv_comp(v1,v2);
2282 }
2283 
2285 
2288 inline bool operator==(const srvector_slice& v1, const cvector_slice& v2) {
2289  return slf_vv_comp(v1,v2);
2290 }
2291 
2293 
2296 inline bool operator==(const scvector_slice& v1, const cvector_slice& v2) {
2297  return slf_vv_comp(v1,v2);
2298 }
2299 
2301 
2304 inline bool operator==(const cvector_slice& v1, const srvector_slice& v2) {
2305  return fsl_vv_comp(v1,v2);
2306 }
2307 
2309 
2312 inline bool operator==(const rvector_slice& v1, const scvector_slice& v2) {
2313  return fsl_vv_comp(v1,v2);
2314 }
2315 
2317 
2320 inline bool operator==(const cvector_slice& v1, const scvector_slice& v2) {
2321  return fsl_vv_comp(v1,v2);
2322 }
2323 
2325 
2328 inline bool operator!=(const scvector_slice& v1, const srvector_slice& v2) {
2329  return !slsl_vv_comp(v1,v2);
2330 }
2331 
2333 
2336 inline bool operator!=(const srvector_slice& v1, const scvector_slice& v2) {
2337  return !slsl_vv_comp(v1,v2);
2338 }
2339 
2341 
2344 inline bool operator!=(const scvector_slice& v1, const scvector_slice& v2) {
2345  return !slsl_vv_comp(v1,v2);
2346 }
2347 
2349 
2352 inline bool operator!=(const scvector_slice& v1, const rvector& v2) {
2353  return !slf_vv_comp(v1,v2);
2354 }
2355 
2357 
2360 inline bool operator!=(const srvector_slice& v1, const cvector& v2) {
2361  return !slf_vv_comp(v1,v2);
2362 }
2363 
2365 
2368 inline bool operator!=(const scvector_slice& v1, const cvector& v2) {
2369  return !slf_vv_comp(v1,v2);
2370 }
2371 
2373 
2376 inline bool operator!=(const cvector& v1, const srvector_slice& v2) {
2377  return !fsl_vv_comp(v1,v2);
2378 }
2379 
2381 
2384 inline bool operator!=(const rvector& v1, const scvector_slice& v2) {
2385  return !fsl_vv_comp(v1,v2);
2386 }
2387 
2389 
2392 inline bool operator!=(const cvector& v1, const scvector_slice& v2) {
2393  return !fsl_vv_comp(v1,v2);
2394 }
2395 
2397 
2400 inline bool operator!=(const scvector_slice& v1, const srvector& v2) {
2401  return !slsp_vv_comp(v1,v2);
2402 }
2403 
2405 
2408 inline bool operator!=(const srvector_slice& v1, const scvector& v2) {
2409  return !slsp_vv_comp(v1,v2);
2410 }
2411 
2413 
2416 inline bool operator!=(const scvector_slice& v1, const scvector& v2) {
2417  return !slsp_vv_comp(v1,v2);
2418 }
2419 
2421 
2424 inline bool operator!=(const scvector& v1, const srvector_slice& v2) {
2425  return !spsl_vv_comp(v1,v2);
2426 }
2427 
2429 
2432 inline bool operator!=(const srvector& v1, const scvector_slice& v2) {
2433  return !spsl_vv_comp(v1,v2);
2434 }
2435 
2437 
2440 inline bool operator!=(const scvector& v1, const scvector_slice& v2) {
2441  return !spsl_vv_comp(v1,v2);
2442 }
2443 
2445 
2448 inline bool operator!=(const scvector_slice& v1, const rvector_slice& v2) {
2449  return !slf_vv_comp(v1,v2);
2450 }
2451 
2453 
2456 inline bool operator!=(const srvector_slice& v1, const cvector_slice& v2) {
2457  return !slf_vv_comp(v1,v2);
2458 }
2459 
2461 
2464 inline bool operator!=(const scvector_slice& v1, const cvector_slice& v2) {
2465  return !slf_vv_comp(v1,v2);
2466 }
2467 
2469 
2472 inline bool operator!=(const cvector_slice& v1, const srvector_slice& v2) {
2473  return !fsl_vv_comp(v1,v2);
2474 }
2475 
2477 
2480 inline bool operator!=(const rvector_slice& v1, const scvector_slice& v2) {
2481  return !fsl_vv_comp(v1,v2);
2482 }
2483 
2485 
2488 inline bool operator!=(const cvector_slice& v1, const scvector_slice& v2) {
2489  return !fsl_vv_comp(v1,v2);
2490 }
2491 
2493 
2498 inline std::ostream& operator<<(std::ostream& os, const scvector_slice& v) {
2499  return sl_v_output<scvector_slice,complex>(os,v);
2500 }
2501 
2503 
2508 inline std::istream& operator>>(std::istream& is, scvector_slice& v) {
2509  return sl_v_input<scvector_slice,complex>(is,v);
2510 }
2511 
2513 
2516 inline 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 
2524 inline 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 
2532 inline 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 
2540 inline 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 
2548 inline 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 
2556 inline 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 
2564 inline 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 
2572 inline 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 
2580 inline 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 
2588 inline 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 
2596 inline 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 
2604 inline 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 
2612 inline 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 
2620 inline 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 
2628 inline 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 
2636 inline 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 
2644 inline 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 
2652 inline 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 
2660 inline 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 
2668 inline 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 
2676 inline 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 
2684 inline 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 
2692 inline 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 
2700 inline 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 
2708 inline 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 
2716 inline 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 
2724 inline 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 
2732 inline 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 
2740 inline 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 
2748 inline 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 
2756 inline 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 
2764 inline 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 
2772 inline 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 
2780 inline 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 
2788 inline 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 
2796 inline 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 
2805 inline 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 
2814 inline 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 
2823 inline 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 
2832 inline 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 
2841 inline 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 
2850 inline 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 
2859 inline 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 
2868 inline 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 
2877 inline 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 
2886 inline 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 
2895 inline 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 
2904 inline 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 
2913 inline 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 
2922 inline 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 
2931 inline 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 
2940 inline 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 
2949 inline 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 
2958 inline 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 
2967 inline 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 
2976 inline 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 
2985 inline 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 
2989 inline 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 
2998 inline 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 
3007 inline 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 
3016 inline 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 
3025 inline 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 
3034 inline 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 
3043 inline 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 
3052 inline 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 
3061 inline 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 
3070 inline 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 
3079 inline 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 
3088 inline 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 
3097 inline 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 
3106 inline 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 
3115 inline 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 
3123 inline 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 
3134 inline 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 
3145 inline 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 
3156 inline 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 
3167 inline 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 
3178 inline 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 
3189 inline 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 
3200 inline 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 
3211 inline 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 
3222 inline 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 
3233 inline 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 
3244 inline 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 
3255 inline 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 
3266 inline 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 
3277 inline 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 
3288 inline 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 
3299 inline 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 
3310 inline 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 
3321 inline 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 
3332 inline 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 
3343 inline 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 
3354 inline 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 
3365 inline 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 
3376 inline 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 
3387 inline 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 
3398 inline 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 
3409 inline 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 
3420 inline 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 
3431 inline 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 
3442 inline 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 
3453 inline 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 
3464 inline 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 
3475 inline 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 
3486 inline 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 
3497 inline 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 
3508 inline 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
friend srvector Im(const scvector_slice &)
Returns the imaginary part of the complex vector slice.
Definition: scvector.hpp:1613
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 & 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
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
Definition: scvector.hpp:1280
scvector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition: scvector.hpp:323
scvector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
Definition: scvector.hpp:1344
scvector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scvector.hpp:405
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 & 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
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: scvector.hpp:188
friend scvector Inf(const scivector &)
Returns the infimum of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:930
scvector_slice & operator=(const scvector &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1369
friend int VecLen(const scvector_slice &)
Returns the length of the vector slice.
Definition: scvector.hpp:1618
std::vector< real > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: srvector.hpp:136
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
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
scvector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1444
scvector_slice & operator=(const scvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1359
scvector & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scvector.hpp:410
std::vector< complex > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: scvector.hpp:155
The Data Type intmatrix.
Definition: intmatrix.hpp:313
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 & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scvector.hpp:390
friend int Lb(const scvector_slice &)
Returns the lower index bound of the vector slice v.
Definition: scvector.hpp:1598
friend srvector Re(const scvector_slice &)
Returns the real part of the complex vector slice.
Definition: scvector.hpp:1608
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
scvector_slice & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1419
cvector_slice & operator+=(const cvector &rv)
Implementation of addition and allocation operation.
Definition: cvector.inl:538
scvector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1424
scvector_slice & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1439
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
friend srvector abs(const scvector &)
Returns the vector of component-wise absolute values of v.
Definition: scvector.hpp:539
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
scvector_slice & operator=(const cvector &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1379
scvector & operator+=(const scvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scvector.hpp:379
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...
Definition: scvector.hpp:1409
void set_k(unsigned int i)
Set precision for computation of dot products.
Definition: cdot.hpp:93
friend int Lb(const scvector &)
Returns the lower index bound of the vector v.
Definition: scvector.hpp:507
scvector_slice & operator=(const cvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1389
The Data Type civector.
Definition: civector.hpp:56
scvector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1464
scvector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scvector.hpp:364
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
friend scvector mid(const scivector &)
Compute the midpoint vector of v.
Definition: scivector.hpp:886
scvector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scvector.hpp:374
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
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
scvector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1454
scvector & operator *=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition: scvector.hpp:334
scvector & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scvector.hpp:369
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
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
Definition: scvector.hpp:1285
cvector & operator=(const cvector &rv)
Implementation of standard assigning operator.
Definition: cvector.inl:276
scvector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scvector.hpp:354
A sparse complex interval vector.
Definition: scivector.hpp:62
scvector_slice & operator-=(const cvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1469
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
friend scvector Sup(const scivector &)
Returns the supremum of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:941
The Data Type cidotprecision.
Definition: cidot.hpp:57
friend void SetLb(scvector &, const int)
Sets the lower index bound of the vector v to i.
Definition: scvector.hpp:492
A sparse real vector.
Definition: srvector.hpp:58
The Data Type rvector_slice.
Definition: rvector.hpp:1063
A sparse complex vector.
Definition: scvector.hpp:58
The Data Type cvector.
Definition: cvector.hpp:57
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
complex operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: scvector.hpp:1317
scvector_slice & operator-=(const cvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1459
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
scvector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scvector.hpp:209
scvector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1434
scvector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1414
scvector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1474
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_slice & operator=(const complex &v)
Assigns v to all elements of the vector slice.
Definition: scvector.hpp:1349
The Data Type rvector.
Definition: rvector.hpp:57
scvector_slice & operator+=(const scvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1449
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
civector operator *(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
The Data Type cdotprecision.
Definition: cdot.hpp:60
friend void SetUb(scvector &, const int)
Sets the upper index bound of the vector v to i.
Definition: scvector.hpp:501
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
scvector_slice & operator+=(const cvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1429
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 int s)
Constructor for creating an empty vector of size s.
Definition: scvector.hpp:72
scvector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition: scvector.hpp:300
friend int Ub(const scvector &)
Returns the upper index bound of the vector v.
Definition: scvector.hpp:512
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
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
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
cvector_slice & operator=(const scvector &sl)
Implementation of standard assigning operator.
Definition: scvector.hpp:1545
The Data Type civector_slice.
Definition: civector.hpp:1014
scvector()
Default constructor, creates an empty vector of size 0.
Definition: scvector.hpp:68
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(const srvector &v)
Constructor for creating a sparse complex vector our of a sparse real vector.
Definition: scvector.hpp:126
scvector & operator+=(const cvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: scvector.hpp:359
complex & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
Definition: scvector.hpp:1294
The Scalar Type complex.
Definition: complex.hpp:49
friend scvector diam(const scivector &)
Computes the diameter of v.
Definition: scivector.hpp:897
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...
Definition: scvector.hpp:1404
int get_k() const
Get currently set precision for computation of dot products.
Definition: cidot.hpp:89
scvector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1364
scvector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scvector.hpp:395
cvector()
Constructor of class cvector.
Definition: cvector.inl:31
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_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1354
scvector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1374
friend srvector Re(const scvector &)
Returns the real part of the complex vector v.
Definition: scvector.hpp:517
scvector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1484
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
scvector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: scvector.hpp:1384
scvector & operator=(const srvector &v)
Assigns a sparse real vector to a sparse complex vector.
Definition: scvector.hpp:198
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.
Definition: scvector.hpp:1329
friend int VecLen(const scvector &)
Returns the length of the vector (the dimension)
Definition: scvector.hpp:555
scvector_slice & operator-=(const scvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1479
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
int Ub(const cimatrix &rm, const int &i)
Returns the upper bound index.
Definition: cimatrix.inl:1163
scvector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: scvector.hpp:385
scvector_slice & operator *=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: scvector.hpp:1394
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
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
The Data Type cvector_slice.
Definition: cvector.hpp:844
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
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
scvector & operator=(const complex &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: scvector.hpp:214
The Scalar Type real.
Definition: real.hpp:113
scvector_slice & operator-=(const scvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: scvector.hpp:1489
The Data Type intvector.
Definition: intvector.hpp:51
friend int Ub(const scvector_slice &)
Returns the upper index bound of the vector slice v.
Definition: scvector.hpp:1603
friend srvector Im(const scvector &)
Returns the imaginary part of the complex vector v.
Definition: scvector.hpp:528
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737