C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
srvector.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: srvector.hpp,v 1.16 2014/01/30 17:23:49 cxsc Exp $ */
25 
26 #ifndef _CXSC_SRVECTOR_HPP_INCLUDED
27 #define _CXSC_SRVECTOR_HPP_INCLUDED
28 
29 #include <real.hpp>
30 #include <intvector.hpp>
31 #include <rvector.hpp>
32 #include <intmatrix.hpp>
33 #include <vector>
34 #include <map>
35 #include <iostream>
36 #include <except.hpp>
37 #include <cidot.hpp>
38 #include <sparsedot.hpp>
39 #include <sparsevector.hpp>
40 
41 namespace cxsc {
42 
43 class srvector_slice;
44 class srmatrix;
45 class srmatrix_slice;
46 class srmatrix_subv;
47 
48 class scvector;
49 class sivector;
50 class sivector_slice;
51 class scivector;
52 
54 
58 class srvector {
59  private:
60  std::vector<int> p;
61  std::vector<real> x;
62  int lb;
63  int ub;
64  int n;
65 
66  public:
68  srvector() : lb(0), ub(-1) , n(0) {
69  }
70 
72  explicit srvector(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  srvector(const int s, const int b) : lb(1), ub(s), n(s) {
79  p.reserve(b);
80  x.reserve(b);
81  }
82 
84  srvector(const rvector& 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  srvector(const int n, const int nnz, const intvector& index, const rvector& values) : lb(1), ub(n) {
95  this->n = n;
96  for(int i=0 ; i<nnz ; i++) {
97  if(values[Lb(values)+i] != 0.0) {
98  p.push_back(index[Lb(index)+i]);
99  x.push_back(values[Lb(values)+i]);
100  }
101  }
102 
103  }
104 
106  srvector(const int n, const int nnz, const int *index, const real *values) : lb(1), ub(n) {
107  this->n = n;
108  for(int i=0 ; i<nnz ; i++) {
109  if(values[i] != 0.0) {
110  p.push_back(index[i]);
111  x.push_back(values[i]);
112  }
113  }
114  }
115 
117  srvector(const srvector_slice&);
119  srvector(const srmatrix_subv& A);
120 
122 
127  std::vector<int>& row_indices() {
128  return p;
129  }
130 
132 
136  std::vector<real>& values() {
137  return x;
138  }
139 
141 
146  const std::vector<int>& row_indices() const {
147  return p;
148  }
149 
151 
155  const std::vector<real>& values() const {
156  return x;
157  }
158 
160  int get_nnz() const {
161  return x.size();
162  }
163 
165  real density() const {
166  return (double)x.size()/n;
167  }
168 
170  void dropzeros() {
171  for(int i=0 ; i<get_nnz() ; i++) {
172  if(x[i] == 0.0) {
173  x.erase(x.begin()+i);
174  p.erase(p.begin()+i);
175  }
176  }
177  }
178 
180  srvector& operator=(const real& v) {
181  return sp_vs_assign<srvector,real,real>(*this,v);
182  }
183 
186  return spf_vv_assign<srvector,rvector,real>(*this,v);
187  }
188 
191  return spf_vv_assign<srvector,rvector_slice,real>(*this,v);
192  }
193 
196 
198 
202  real& operator[](const int i) {
203 #if(CXSC_INDEX_CHECK)
204  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector::operator[](const int)"));
205 #endif
206  int k;
207 
208  for(k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
209  if(p[k] == i-lb)
210  return x[k];
211  }
212 
213  p.insert(p.begin() + k, i-lb);
214  x.insert(x.begin() + k, 0.0);
215 
216  return x[k];
217  }
218 
220 
224  real operator[](const int i) const {
225 #if(CXSC_INDEX_CHECK)
226  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector::operator[](const int)"));
227 #endif
228  return (*this)(i);
229  }
230 
232 
236  const real operator()(const int i) const {
237 #if(CXSC_INDEX_CHECK)
238  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector::operator()(const int)"));
239 #endif
240  real r = 0.0;
241 
242  for(int k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
243  if(p[k] == i-lb)
244  r = x[k];
245  }
246 
247  return r;
248  }
249 
251 
253  srvector_slice operator()(const int i, const int j);
254 
256 
260  srvector v(n,get_nnz());
261  intvector pinv = perminv(per);
262 
263  std::map<int,real> work;
264  for(int i=0 ; i<get_nnz() ; i++)
265  work.insert(std::make_pair(pinv[Lb(pinv)+p[i]], x[i]));
266 
267  for(std::map<int,real>::iterator it=work.begin() ; it!=work.end() ; it++) {
268  v.p.push_back(it->first);
269  v.x.push_back(it->second);
270  }
271 
272  return v;
273  }
274 
276 
283  intvector p = permvec(P);
284  return (*this)(p);
285  }
286 
288  srvector& operator*=(const real& s) {
289  return sp_vs_multassign(*this,s);
290  }
291 
293  srvector& operator/=(const real& s) {
294  return sp_vs_divassign(*this,s);
295  }
296 
299  {
300  return spf_vv_addassign(*this,v);
301  }
302 
305  return spf_vv_addassign(*this,v);
306  }
307 
310  return spsp_vv_addassign(*this,v);
311  }
312 
315 
318  return spf_vv_subassign(*this,v);
319  }
320 
323  return spf_vv_subassign(*this,v);
324  }
325 
328  return spsp_vv_subassign(*this,v);
329  }
330 
333 
334  friend int Lb(const srvector&);
335  friend int Ub(const srvector&);
336  friend void SetLb(srvector&, const int);
337  friend void SetUb(srvector&, const int);
338 
339  friend int VecLen(const srvector&);
340  friend srvector Re(const scvector&);
341  friend srvector Im(const scvector&);
342  friend srvector Inf(const sivector&);
343  friend srvector Sup(const sivector&);
344  friend srvector InfRe(const scivector&);
345  friend srvector SupRe(const scivector&);
346  friend srvector InfIm(const scivector&);
347  friend srvector SupIm(const scivector&);
348  friend srvector mid(const sivector&);
349  friend srvector diam(const sivector&);
350  friend srvector absmin(const sivector&);
351  friend srvector absmax(const sivector&);
352  friend srvector abs(const srvector&);
353  friend srvector mid(const sivector_slice&);
354  friend srvector diam(const sivector_slice&);
355 
356 
357  friend class srvector_slice;
358  friend class scvector_slice;
359  friend class scvector;
360  friend class sivector_slice;
361  friend class sivector;
362  friend class scivector_slice;
363  friend class scivector;
364  friend class srmatrix_subv;
365  friend class rvector;
366  friend class rvector_slice;
367  friend class ivector;
368  friend class ivector_slice;
369  friend class cvector;
370  friend class cvector_slice;
371  friend class civector;
372  friend class civector_slice;
373 
374 
375 #include "vector_friend_declarations.inl"
376 };
377 
378 inline rvector::rvector(const srvector& v) {
379  l = v.lb;
380  u = v.ub;
381  size = v.n;
382  dat = new real[v.n];
383  for(int i=0 ; i<v.n ; i++)
384  dat[i] = 0.0;
385  for(int i=0 ; i<v.get_nnz() ; i++)
386  dat[v.p[i]] = v.x[i];
387 }
388 
390  return fsp_vv_assign<rvector,srvector,real>(*this,v);
391 }
392 
394  return fsl_vv_assign<rvector,srvector_slice,real>(*this,v);
395 }
396 
397 
399 
402 inline void SetLb(srvector& v, const int i) {
403  v.lb = i;
404  v.ub = v.lb + v.n - 1;
405 }
406 
408 
411 inline void SetUb(srvector& v, const int j) {
412  v.ub = j;
413  v.lb = v.ub - v.n + 1;
414 }
415 
417 inline int Lb(const srvector& v) {
418  return v.lb;
419 }
420 
422 inline int Ub(const srvector& v) {
423  return v.ub;
424 }
425 
427 inline int VecLen(const srvector& v) {
428  return v.n;
429 }
430 
432 inline void Resize(srvector& v) {
433  sp_v_resize(v);
434 }
435 
437 
440 inline void Resize(srvector& v, const int n) {
441  sp_v_resize(v,n);
442 }
443 
445 
449 inline void Resize(srvector& v, const int l, const int u) {
450  sp_v_resize(v,l,u);
451 }
452 
454 inline srvector operator-(const srvector& v) {
455  return sp_v_negative(v);
456 }
457 
459 
465 inline real operator*(const srvector& v1, const rvector& v2) {
466  return spf_vv_mult<srvector,rvector,real,sparse_dot>(v1,v2);
467 }
468 
470 
476 inline real operator*(const rvector& v1, const srvector& v2) {
477  return fsp_vv_mult<rvector,srvector,real,sparse_dot>(v1,v2);
478 }
479 
481 
487 inline real operator*(const srvector& v1, const rvector_slice& v2) {
488  return spf_vv_mult<srvector,rvector_slice,real,sparse_dot>(v1,v2);
489 }
490 
492 
498 inline real operator*(const rvector_slice& v1, const srvector& v2) {
499  return fsp_vv_mult<rvector_slice,srvector,real,sparse_dot>(v1,v2);
500 }
501 
503 
509 inline real operator*(const srvector& v1, const srvector& v2) {
510  return spsp_vv_mult<srvector,srvector,real,sparse_dot>(v1,v2);
511 }
512 
514 inline srvector operator*(const srvector& v, const real& s) {
515  return sp_vs_mult<srvector,real,srvector>(v,s);
516 }
517 
519 inline srvector operator/(const srvector& v, const real& s) {
520  return sp_vs_div<srvector,real,srvector>(v,s);
521 }
522 
524 inline srvector operator*(const real& s, const srvector& v) {
525  return sp_sv_mult<real,srvector,srvector>(s,v);
526 }
527 
529 inline rvector operator+(const rvector& v1, const srvector& v2) {
530  return fsp_vv_add<rvector,srvector,rvector>(v1,v2);
531 }
532 
534 inline rvector operator+(const srvector& v1, const rvector& v2) {
535  return spf_vv_add<srvector,rvector,rvector>(v1,v2);
536 }
537 
539 inline rvector operator+(const rvector_slice& v1, const srvector& v2) {
540  return fsp_vv_add<rvector_slice,srvector,rvector>(v1,v2);
541 }
542 
544 inline rvector operator+(const srvector& v1, const rvector_slice& v2) {
545  return spf_vv_add<srvector,rvector_slice,rvector>(v1,v2);
546 }
547 
549 inline srvector operator+(const srvector& v1, const srvector& v2) {
550  return spsp_vv_add<srvector,srvector,srvector,real>(v1,v2);
551 }
552 
554 inline rvector operator-(const rvector& v1, const srvector& v2) {
555  return fsp_vv_sub<rvector,srvector,rvector>(v1,v2);
556 }
557 
559 inline rvector operator-(const srvector& v1, const rvector& v2) {
560  return spf_vv_sub<srvector,rvector,rvector>(v1,v2);
561 }
562 
564 inline rvector operator-(const rvector_slice& v1, const srvector& v2) {
565  return fsp_vv_sub<rvector_slice,srvector,rvector>(v1,v2);
566 }
567 
569 inline rvector operator-(const srvector& v1, const rvector_slice& v2) {
570  return spf_vv_sub<srvector,rvector_slice,rvector>(v1,v2);
571 }
572 
574 inline srvector operator-(const srvector& v1, const srvector& v2) {
575  return spsp_vv_sub<srvector,srvector,srvector,real>(v1,v2);
576 }
577 
579  return fsp_vv_addassign(*this,v2);
580 }
581 
583  return fsp_vv_addassign(*this,v2);
584 }
585 
587  return fsp_vv_subassign(*this,v2);
588 }
589 
591  return fsp_vv_subassign(*this,v2);
592 }
593 
595 
598 inline bool operator==(const srvector& v1, const srvector& v2) {
599  return spsp_vv_comp(v1,v2);
600 }
601 
603 
606 inline bool operator==(const srvector& v1, const rvector& v2) {
607  return spf_vv_comp(v1,v2);
608 }
609 
611 
614 inline bool operator==(const rvector& v1, const srvector& v2) {
615  return fsp_vv_comp(v1,v2);
616 }
617 
619 
622 inline bool operator==(const srvector& v1, const rvector_slice& v2) {
623  return spf_vv_comp(v1,v2);
624 }
625 
627 
630 inline bool operator==(const rvector_slice& v1, const srvector& v2) {
631  return fsp_vv_comp(v1,v2);
632 }
633 
635 
638 inline bool operator!=(const srvector& v1, const srvector& v2) {
639  return !spsp_vv_comp(v1,v2);
640 }
641 
643 
646 inline bool operator!=(const srvector& v1, const rvector& v2) {
647  return !spf_vv_comp(v1,v2);
648 }
649 
651 
654 inline bool operator!=(const rvector& v1, const srvector& v2) {
655  return !fsp_vv_comp(v1,v2);
656 }
657 
659 
662 inline bool operator!=(const srvector& v1, const rvector_slice& v2) {
663  return !spf_vv_comp(v1,v2);
664 }
665 
667 
670 inline bool operator!=(const rvector_slice& v1, const srvector& v2) {
671  return !fsp_vv_comp(v1,v2);
672 }
673 
675 
678 inline bool operator<(const srvector& v1, const srvector& v2) {
679  return spsp_vv_less<srvector,srvector,real>(v1,v2);
680 }
681 
683 
686 inline bool operator<(const srvector& v1, const rvector& v2) {
687  return spf_vv_less<srvector,rvector,real>(v1,v2);
688 }
689 
691 
694 inline bool operator<(const rvector& v1, const srvector& v2) {
695  return fsp_vv_less<rvector,srvector,real>(v1,v2);
696 }
697 
699 
702 inline bool operator<(const srvector& v1, const rvector_slice& v2) {
703  return spf_vv_less<srvector,rvector_slice,real>(v1,v2);
704 }
705 
707 
710 inline bool operator<(const rvector_slice& v1, const srvector& v2) {
711  return fsp_vv_less<rvector_slice,srvector,real>(v1,v2);
712 }
713 
715 
718 inline bool operator<=(const srvector& v1, const srvector& v2) {
719  return spsp_vv_leq<srvector,srvector,real>(v1,v2);
720 }
721 
723 
726 inline bool operator<=(const srvector& v1, const rvector& v2) {
727  return spf_vv_leq<srvector,rvector,real>(v1,v2);
728 }
729 
731 
734 inline bool operator<=(const rvector& v1, const srvector& v2) {
735  return fsp_vv_leq<rvector,srvector,real>(v1,v2);
736 }
737 
739 
742 inline bool operator<=(const srvector& v1, const rvector_slice& v2) {
743  return spf_vv_leq<srvector,rvector_slice,real>(v1,v2);
744 }
745 
747 
750 inline bool operator<=(const rvector_slice& v1, const srvector& v2) {
751  return fsp_vv_leq<rvector_slice,srvector,real>(v1,v2);
752 }
753 
755 
758 inline bool operator>(const srvector& v1, const srvector& v2) {
759  return spsp_vv_greater<srvector,srvector,real>(v1,v2);
760 }
761 
763 
766 inline bool operator>(const srvector& v1, const rvector& v2) {
767  return spf_vv_greater<srvector,rvector,real>(v1,v2);
768 }
769 
771 
774 inline bool operator>(const rvector& v1, const srvector& v2) {
775  return fsp_vv_greater<rvector,srvector,real>(v1,v2);
776 }
777 
779 
782 inline bool operator>(const srvector& v1, const rvector_slice& v2) {
783  return spf_vv_greater<srvector,rvector_slice,real>(v1,v2);
784 }
785 
787 
790 inline bool operator>(const rvector_slice& v1, const srvector& v2) {
791  return fsp_vv_greater<rvector_slice,srvector,real>(v1,v2);
792 }
793 
795 
798 inline bool operator>=(const srvector& v1, const srvector& v2) {
799  return spsp_vv_geq<srvector,srvector,real>(v1,v2);
800 }
801 
803 
806 inline bool operator>=(const srvector& v1, const rvector& v2) {
807  return spf_vv_geq<srvector,rvector,real>(v1,v2);
808 }
809 
811 
814 inline bool operator>=(const rvector& v1, const srvector& v2) {
815  return fsp_vv_geq<rvector,srvector,real>(v1,v2);
816 }
817 
819 
822 inline bool operator>=(const srvector& v1, const rvector_slice& v2) {
823  return spf_vv_geq<srvector,rvector_slice,real>(v1,v2);
824 }
825 
827 
830 inline bool operator>=(const rvector_slice& v1, const srvector& v2) {
831  return fsp_vv_geq<rvector_slice,srvector,real>(v1,v2);
832 }
833 
835 
838 inline bool operator!(const srvector& x) {
839  return sp_v_not(x);
840 }
841 
843 
848 inline std::ostream& operator<<(std::ostream& os, const srvector& v) {
849  return sp_v_output<srvector,real>(os,v);
850 }
851 
853 
858 inline std::istream& operator>>(std::istream& is, srvector& v) {
859  return sp_v_input<srvector,real>(is,v);
860 }
861 
863 
869  private:
870  std::vector<int>& p;
871  std::vector<real>& x;
872  srvector& orig;
873  int start,end;
874  int lb;
875  int ub;
876  int n;
877  int nnz;
878  int offset;
879 
881 
885  srvector_slice(srvector& v, int l, int u) : p(v.p), x(v.x), orig(v), lb(l), ub(u), n(u-l+1) {
886  int i;
887 
888  for(i=0 ; i<v.get_nnz() && p[i]<lb-v.lb ; i++);
889 
890  start = i;
891 
892  for(i=start ; i<v.get_nnz() && p[i]<=ub-v.lb ; i++);
893 
894  end = i-1;
895 
896  nnz = end-start+1;
897  offset = lb-v.lb;
898  }
899 
900  public:
902  int get_nnz() const {
903  return nnz;
904  }
906  real density() const {
907  return (double)nnz/n;
908  }
909 
911 
915  real& operator[](const int i) {
916 #if(CXSC_INDEX_CHECK)
917  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector_slice::operator[](const int)"));
918 #endif
919  int k;
920 
921  for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
922  if(p[k]-offset == i-lb)
923  return x[k];
924  }
925 
926  p.insert(p.begin() + k, i-lb);
927  x.insert(x.begin() + k, 0.0);
928  end++;
929 
930  return x[k];
931  }
932 
934 
938  real operator[](const int i) const {
939 #if(CXSC_INDEX_CHECK)
940  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector_slice::operator[](const int)"));
941 #endif
942  return (*this)(i);
943  }
944 
946 
950  const real operator()(const int i) const {
951 #if(CXSC_INDEX_CHECK)
952  if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector_slice::operator()(const int)"));
953 #endif
954  real r = 0.0;
955 
956  for(int k=start ; k<end && p[k]-start<=i-lb ; k++) {
957  if(p[k]-start == i-lb)
958  r = x[k];
959  }
960 
961  return r;
962  }
963 
966  return sl_vs_assign<srvector_slice,real,real,std::vector<real>::iterator>(*this,v);
967  }
968 
971  return slsl_vv_assign<srvector_slice,srvector_slice,real,std::vector<real>::iterator>(*this,v);
972  }
973 
976  return slsp_vv_assign<srvector_slice,srvector,real,std::vector<real>::iterator>(*this,v);
977  }
978 
981  return slf_vv_assign<srvector_slice,rvector,real,std::vector<real>::iterator>(*this,v);
982  }
983 
986  return slf_vv_assign<srvector_slice,rvector,real,std::vector<real>::iterator>(*this,v);
987  }
988 
991  return sl_vs_multassign(*this,s);
992  }
993 
996  return sl_vs_divassign(*this,s);
997  }
998 
1001  return slf_vv_addassign<srvector_slice,rvector,real>(*this,v);
1002  }
1003 
1006  return slf_vv_addassign<srvector_slice,rvector_slice,real>(*this,v);
1007  }
1008 
1011  return slsp_vv_addassign(*this,v);
1012  }
1013 
1016  return slsl_vv_addassign(*this,v);
1017  }
1018 
1021  return slf_vv_subassign<srvector_slice,rvector,real>(*this,v);
1022  }
1023 
1026  return slf_vv_subassign<srvector_slice,rvector_slice,real>(*this,v);
1027  }
1028 
1031  return slsp_vv_subassign(*this,v);
1032  }
1033 
1036  return slsl_vv_subassign(*this,v);
1037  }
1038 
1039 
1040  friend int Lb(const srvector_slice&);
1041  friend int Ub(const srvector_slice&);
1042  friend int VecLen(const srvector_slice&);
1043 
1044  friend srvector operator*(const srmatrix&, const srvector_slice&); //ok
1045  friend srvector operator*(const srmatrix_slice&, const srvector_slice&); //ok
1046 
1047  friend class srvector;
1048  friend class scvector;
1049  friend class sivector;
1050  friend class scivector;
1051  friend class srmatrix_subv;
1052  friend class rvector;
1053  friend class rvector_slice;
1054  friend class ivector;
1055  friend class ivector_slice;
1056  friend class cvector;
1057  friend class cvector_slice;
1058  friend class civector;
1059  friend class civector_slice;
1060 
1061 #include "vector_friend_declarations.inl"
1062 };
1063 
1065  l = v.lb;
1066  u = v.ub;
1067  size = v.n;
1068  dat = new real[v.n];
1069  for(int i=0 ; i<v.n ; i++)
1070  dat[i] = 0.0;
1071  for(int i=v.start ; i<=v.end ; i++)
1072  dat[v.p[i]] = v.x[i];
1073 }
1074 
1076  *this = rvector(v);
1077  return *this;
1078 }
1079 
1081  *this = rvector(v);
1082  return *this;
1083 }
1084 
1085 inline srvector::srvector(const srvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
1086  p.reserve(s.nnz);
1087  x.reserve(s.nnz);
1088 
1089  for(int i=s.start ; i<=s.end ; i++) {
1090  p.push_back(s.p[i]-s.offset);
1091  x.push_back(s.x[i]);
1092  }
1093 
1094 }
1095 
1097  return spsl_vv_assign<srvector,srvector_slice,real>(*this,v);
1098 }
1099 
1100 inline srvector_slice srvector::operator()(const int i, const int j) {
1101 #if(CXSC_INDEX_CHECK)
1102  if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector::operator()(const int,const int)"));
1103 #endif
1104  return srvector_slice(*this,i,j);
1105 }
1106 
1108 inline srvector operator-(const srvector_slice& v) {
1109  return sl_v_negative<srvector_slice,srvector>(v);
1110 }
1111 
1113 inline int Lb(const srvector_slice& v) {
1114  return v.lb;
1115 }
1116 
1118 inline int Ub(const srvector_slice& v) {
1119  return v.ub;
1120 }
1121 
1123 inline int VecLen(const srvector_slice& v) {
1124  return v.n;
1125 }
1126 
1128 inline srvector abs(const srvector& v) {
1129  srvector ret(v);
1130  std::vector<real>& x = ret.values();
1131  for(unsigned int i=0 ; i<x.size() ; i++)
1132  x[i] = abs(x[i]);
1133  return ret;
1134 }
1135 
1137 
1143 inline real operator*(const srvector_slice& v1, const rvector& v2) {
1144  return slf_vv_mult<srvector_slice,rvector,real,sparse_dot>(v1,v2);
1145 }
1146 
1148 inline real operator*(const rvector& v1, const srvector_slice& v2) {
1154  return fsl_vv_mult<rvector,srvector_slice,real,sparse_dot>(v1,v2);
1155 }
1156 
1158 inline real operator*(const srvector_slice& v1, const rvector_slice& v2) {
1164  return slf_vv_mult<srvector_slice,rvector_slice,real,sparse_dot>(v1,v2);
1165 }
1166 
1168 inline real operator*(const rvector_slice& v1, const srvector_slice& v2) {
1174  return fsl_vv_mult<rvector_slice,srvector_slice,real,sparse_dot>(v1,v2);
1175 }
1176 
1178 inline real operator*(const srvector& v1, const srvector_slice& v2) {
1184  return spsl_vv_mult<srvector,srvector_slice,real,sparse_dot>(v1,v2);
1185 }
1186 
1188 inline real operator*(const srvector_slice& v1, const srvector& v2) {
1194  return slsp_vv_mult<srvector_slice,srvector,real,sparse_dot>(v1,v2);
1195 }
1196 
1198 inline real operator*(const srvector_slice& v1, const srvector_slice& v2) {
1204  return slsl_vv_mult<srvector_slice,srvector_slice,real,sparse_dot>(v1,v2);
1205 }
1206 
1208 inline srvector operator*(const srvector_slice& v, const real& s) {
1209  return sp_vs_mult<srvector_slice,real,srvector>(v,s);
1210 }
1211 
1213 inline srvector operator/(const srvector_slice& v, const real& s) {
1214  return sp_vs_div<srvector_slice,real,srvector>(v,s);
1215 }
1216 
1218 inline srvector operator*(const real& s, const srvector_slice& v) {
1219  return sp_sv_mult<real,srvector_slice,srvector>(s,v);
1220 }
1221 
1223 inline rvector operator+(const rvector& v1, const srvector_slice& v2) {
1224  return fsl_vv_add<rvector,srvector_slice,rvector>(v1,v2);
1225 }
1226 
1228 inline rvector operator+(const srvector_slice& v1, const rvector& v2) {
1229  return slf_vv_add<srvector_slice,rvector,rvector>(v1,v2);
1230 }
1231 
1233 inline rvector operator+(const rvector_slice& v1, const srvector_slice& v2) {
1234  return fsl_vv_add<rvector_slice,srvector_slice,rvector>(v1,v2);
1235 }
1236 
1238 inline rvector operator+(const srvector_slice& v1, const rvector_slice& v2) {
1239  return slf_vv_add<srvector_slice,rvector_slice,rvector>(v1,v2);
1240 }
1241 
1243 inline srvector operator+(const srvector_slice& v1, const srvector_slice& v2) {
1244  return slsl_vv_add<srvector_slice,srvector_slice,srvector,real>(v1,v2);
1245 }
1246 
1248 inline srvector operator+(const srvector& v1, const srvector_slice& v2) {
1249  return spsl_vv_add<srvector,srvector_slice,srvector,real>(v1,v2);
1250 }
1251 
1253 inline srvector operator+(const srvector_slice& v1, const srvector& v2) {
1254  return slsp_vv_add<srvector_slice,srvector,srvector,real>(v1,v2);
1255 }
1256 
1258 inline rvector operator-(const rvector& v1, const srvector_slice& v2) {
1259  return fsl_vv_sub<rvector,srvector_slice,rvector>(v1,v2);
1260 }
1261 
1263 inline rvector operator-(const srvector_slice& v1, const rvector& v2) {
1264  return slf_vv_sub<srvector_slice,rvector,rvector>(v1,v2);
1265 }
1266 
1268 inline rvector operator-(const rvector_slice& v1, const srvector_slice& v2) {
1269  return fsl_vv_sub<rvector_slice,srvector_slice,rvector>(v1,v2);
1270 }
1271 
1273 inline rvector operator-(const srvector_slice& v1, const rvector_slice& v2) {
1274  return slf_vv_sub<srvector_slice,rvector_slice,rvector>(v1,v2);
1275 }
1276 
1278 inline srvector operator-(const srvector_slice& v1, const srvector_slice& v2) {
1279  return slsl_vv_sub<srvector_slice,srvector_slice,srvector,real>(v1,v2);
1280 }
1281 
1283 inline srvector operator-(const srvector& v1, const srvector_slice& v2) {
1284  return spsl_vv_sub<srvector,srvector_slice,srvector,real>(v1,v2);
1285 }
1286 
1288 inline srvector operator-(const srvector_slice& v1, const srvector& v2) {
1289  return slsp_vv_sub<srvector_slice,srvector,srvector,real>(v1,v2);
1290 }
1291 
1293  return fsl_vv_addassign(*this,v2);
1294 }
1295 
1297  return fsl_vv_addassign(*this,v2);
1298 }
1299 
1301  return spsl_vv_addassign(*this,v2);
1302 }
1303 
1305  return fsl_vv_subassign(*this,v2);
1306 }
1307 
1309  return fsl_vv_subassign(*this,v2);
1310 }
1311 
1313  return spsl_vv_subassign(*this,v2);
1314 }
1315 
1317 
1320 inline bool operator==(const srvector_slice& v1, const srvector_slice& v2) {
1321  return slsl_vv_comp(v1,v2);
1322 }
1323 
1325 
1328 inline bool operator==(const srvector_slice& v1, const srvector& v2) {
1329  return slsp_vv_comp(v1,v2);
1330 }
1331 
1333 
1336 inline bool operator==(const srvector& v1, const srvector_slice& v2) {
1337  return spsl_vv_comp(v1,v2);
1338 }
1339 
1341 
1344 inline bool operator==(const srvector_slice& v1, const rvector& v2) {
1345  return slf_vv_comp(v1,v2);
1346 }
1347 
1349 
1352 inline bool operator==(const rvector& v1, const srvector_slice& v2) {
1353  return fsl_vv_comp(v1,v2);
1354 }
1355 
1357 
1360 inline bool operator==(const srvector_slice& v1, const rvector_slice& v2) {
1361  return slf_vv_comp(v1,v2);
1362 }
1363 
1365 
1368 inline bool operator==(const rvector_slice& v1, const srvector_slice& v2) {
1369  return fsl_vv_comp(v1,v2);
1370 }
1371 
1373 
1376 inline bool operator!=(const srvector_slice& v1, const srvector_slice& v2) {
1377  return !slsl_vv_comp(v1,v2);
1378 }
1379 
1381 
1384 inline bool operator!=(const srvector_slice& v1, const rvector& v2) {
1385  return !slf_vv_comp(v1,v2);
1386 }
1387 
1389 
1392 inline bool operator!=(const rvector& v1, const srvector_slice& v2) {
1393  return !fsl_vv_comp(v1,v2);
1394 }
1395 
1397 
1400 inline bool operator!=(const srvector_slice& v1, const srvector& v2) {
1401  return !slsp_vv_comp(v1,v2);
1402 }
1403 
1405 
1408 inline bool operator!=(const srvector& v1, const srvector_slice& v2) {
1409  return !spsl_vv_comp(v1,v2);
1410 }
1411 
1413 
1416 inline bool operator!=(const srvector_slice& v1, const rvector_slice& v2) {
1417  return !slf_vv_comp(v1,v2);
1418 }
1419 
1421 
1424 inline bool operator!=(const rvector_slice& v1, const srvector_slice& v2) {
1425  return !fsl_vv_comp(v1,v2);
1426 }
1427 
1429 
1432 inline bool operator<(const srvector_slice& v1, const srvector_slice& v2) {
1433  return slsl_vv_less<srvector_slice,srvector_slice,real>(v1,v2);
1434 }
1435 
1437 
1440 inline bool operator<(const srvector_slice& v1, const srvector& v2) {
1441  return slsp_vv_less<srvector_slice,srvector,real>(v1,v2);
1442 }
1443 
1445 
1448 inline bool operator<(const srvector& v1, const srvector_slice& v2) {
1449  return spsl_vv_less<srvector,srvector_slice,real>(v1,v2);
1450 }
1451 
1453 
1456 inline bool operator<(const srvector_slice& v1, const rvector& v2) {
1457  return slf_vv_less<srvector_slice,rvector,real>(v1,v2);
1458 }
1459 
1461 
1464 inline bool operator<(const rvector& v1, const srvector_slice& v2) {
1465  return fsl_vv_less<rvector,srvector_slice,real>(v1,v2);
1466 }
1467 
1469 
1472 inline bool operator<(const srvector_slice& v1, const rvector_slice& v2) {
1473  return slf_vv_less<srvector_slice,rvector_slice,real>(v1,v2);
1474 }
1475 
1477 
1480 inline bool operator<(const rvector_slice& v1, const srvector_slice& v2) {
1481  return fsl_vv_less<rvector_slice,srvector_slice,real>(v1,v2);
1482 }
1483 
1485 
1488 inline bool operator<=(const srvector_slice& v1, const srvector_slice& v2) {
1489  return slsl_vv_leq<srvector_slice,srvector_slice,real>(v1,v2);
1490 }
1491 
1493 
1496 inline bool operator<=(const srvector_slice& v1, const srvector& v2) {
1497  return slsp_vv_leq<srvector_slice,srvector,real>(v1,v2);
1498 }
1499 
1501 
1504 inline bool operator<=(const srvector& v1, const srvector_slice& v2) {
1505  return spsl_vv_leq<srvector,srvector_slice,real>(v1,v2);
1506 }
1507 
1509 
1512 inline bool operator<=(const srvector_slice& v1, const rvector& v2) {
1513  return slf_vv_leq<srvector_slice,rvector,real>(v1,v2);
1514 }
1515 
1517 
1520 inline bool operator<=(const rvector& v1, const srvector_slice& v2) {
1521  return fsl_vv_leq<rvector,srvector_slice,real>(v1,v2);
1522 }
1523 
1525 
1528 inline bool operator<=(const srvector_slice& v1, const rvector_slice& v2) {
1529  return slf_vv_leq<srvector_slice,rvector_slice,real>(v1,v2);
1530 }
1531 
1533 
1536 inline bool operator<=(const rvector_slice& v1, const srvector_slice& v2) {
1537  return fsl_vv_leq<rvector_slice,srvector_slice,real>(v1,v2);
1538 }
1539 
1541 
1544 inline bool operator>(const srvector_slice& v1, const srvector_slice& v2) {
1545  return slsl_vv_greater<srvector_slice,srvector_slice,real>(v1,v2);
1546 }
1547 
1549 
1552 inline bool operator>(const srvector_slice& v1, const srvector& v2) {
1553  return slsp_vv_greater<srvector_slice,srvector,real>(v1,v2);
1554 }
1555 
1557 
1560 inline bool operator>(const srvector& v1, const srvector_slice& v2) {
1561  return spsl_vv_greater<srvector,srvector_slice,real>(v1,v2);
1562 }
1563 
1565 
1568 inline bool operator>(const srvector_slice& v1, const rvector& v2) {
1569  return slf_vv_greater<srvector_slice,rvector,real>(v1,v2);
1570 }
1571 
1573 
1576 inline bool operator>(const rvector& v1, const srvector_slice& v2) {
1577  return fsl_vv_greater<rvector,srvector_slice,real>(v1,v2);
1578 }
1579 
1581 
1584 inline bool operator>(const srvector_slice& v1, const rvector_slice& v2) {
1585  return slf_vv_greater<srvector_slice,rvector_slice,real>(v1,v2);
1586 }
1587 
1589 
1592 inline bool operator>(const rvector_slice& v1, const srvector_slice& v2) {
1593  return fsl_vv_greater<rvector_slice,srvector_slice,real>(v1,v2);
1594 }
1595 
1597 
1600 inline bool operator>=(const srvector_slice& v1, const srvector_slice& v2) {
1601  return slsl_vv_geq<srvector_slice,srvector_slice,real>(v1,v2);
1602 }
1603 
1605 
1608 inline bool operator>=(const srvector_slice& v1, const srvector& v2) {
1609  return slsp_vv_geq<srvector_slice,srvector,real>(v1,v2);
1610 }
1611 
1613 
1616 inline bool operator>=(const srvector& v1, const srvector_slice& v2) {
1617  return spsl_vv_geq<srvector,srvector_slice,real>(v1,v2);
1618 }
1619 
1621 
1624 inline bool operator>=(const srvector_slice& v1, const rvector& v2) {
1625  return slf_vv_geq<srvector_slice,rvector,real>(v1,v2);
1626 }
1627 
1629 
1632 inline bool operator>=(const rvector& v1, const srvector_slice& v2) {
1633  return fsl_vv_geq<rvector,srvector_slice,real>(v1,v2);
1634 }
1635 
1637 
1640 inline bool operator>=(const srvector_slice& v1, const rvector_slice& v2) {
1641  return slf_vv_geq<srvector_slice,rvector_slice,real>(v1,v2);
1642 }
1643 
1645 
1648 inline bool operator>=(const rvector_slice& v1, const srvector_slice& v2) {
1649  return fsl_vv_geq<rvector_slice,srvector_slice,real>(v1,v2);
1650 }
1651 
1653 
1656 inline bool operator!(const srvector_slice& x) {
1657  return sl_v_not(x);
1658 }
1659 
1661 
1666 inline std::ostream& operator<<(std::ostream& os, const srvector_slice& v) {
1667  return sl_v_output<srvector_slice, real>(os,v);
1668 }
1669 
1671 
1676 inline std::istream& operator>>(std::istream& is, srvector_slice& v) {
1677  return sl_v_input<srvector_slice, real>(is,v);
1678 }
1679 
1681 
1684 inline void accumulate(dotprecision& dot, const srvector& x, const srvector& y) {
1685  spsp_vv_accu<dotprecision,srvector,srvector,sparse_dot>(dot,x,y);
1686 }
1687 
1689 
1692 inline void accumulate(dotprecision& dot, const srvector& x, const rvector& y) {
1693  spf_vv_accu<dotprecision,srvector,rvector,sparse_dot>(dot,x,y);
1694 }
1695 
1697 
1700 inline void accumulate(dotprecision& dot, const srvector& x, const rvector_slice& y) {
1701  spf_vv_accu<dotprecision,srvector,rvector_slice,sparse_dot>(dot,x,y);
1702 }
1703 
1705 
1708 inline void accumulate(dotprecision& dot, const rvector& x, const srvector& y) {
1709  fsp_vv_accu<dotprecision,rvector,srvector,sparse_dot>(dot,x,y);
1710 }
1711 
1713 
1716 inline void accumulate(dotprecision& dot, const rvector_slice& x, const srvector& y) {
1717  fsp_vv_accu<dotprecision,rvector_slice,srvector,sparse_dot>(dot,x,y);
1718 }
1719 
1721 
1724 inline void accumulate(dotprecision& dot, const srvector_slice& x, const rvector& y) {
1725  slf_vv_accu<dotprecision,srvector_slice,rvector,sparse_dot>(dot,x,y);
1726 }
1727 
1729 
1732 inline void accumulate(dotprecision& dot, const srvector_slice& x, const rvector_slice& y) {
1733  slf_vv_accu<dotprecision,srvector_slice,rvector_slice,sparse_dot>(dot,x,y);
1734 }
1735 
1737 
1740 inline void accumulate(dotprecision& dot, const rvector& x, const srvector_slice& y) {
1741  fsl_vv_accu<dotprecision,rvector,srvector_slice,sparse_dot>(dot,x,y);
1742 }
1743 
1745 
1748 inline void accumulate(dotprecision& dot, const rvector_slice& x, const srvector_slice& y) {
1749  fsl_vv_accu<dotprecision,rvector_slice,srvector_slice,sparse_dot>(dot,x,y);
1750 }
1751 
1753 
1756 inline void accumulate(dotprecision& dot, const srvector_slice& x, const srvector_slice& y) {
1757  slsl_vv_accu<dotprecision,srvector_slice,srvector_slice,sparse_dot>(dot,x,y);
1758 }
1759 
1761 
1764 inline void accumulate(dotprecision& dot, const srvector& x, const srvector_slice& y) {
1765  spsl_vv_accu<dotprecision,srvector,srvector_slice,sparse_dot>(dot,x,y);
1766 }
1767 
1769 
1772 inline void accumulate(dotprecision& dot, const srvector_slice& x, const srvector& y) {
1773  slsp_vv_accu<dotprecision,srvector_slice,srvector,sparse_dot>(dot,x,y);
1774 }
1775 
1777 
1781 inline void accumulate_approx(dotprecision& dot, const srvector& x, const srvector& y) {
1782  spsp_vv_accuapprox<dotprecision,srvector,srvector,sparse_dot>(dot,x,y);
1783 }
1784 
1786 
1790 inline void accumulate_approx(dotprecision& dot, const srvector& x, const rvector& y) {
1791  spf_vv_accuapprox<dotprecision,srvector,rvector,sparse_dot>(dot,x,y);
1792 }
1793 
1795 
1799 inline void accumulate_approx(dotprecision& dot, const srvector& x, const rvector_slice& y) {
1800  spf_vv_accuapprox<dotprecision,srvector,rvector_slice,sparse_dot>(dot,x,y);
1801 }
1802 
1804 
1808 inline void accumulate_approx(dotprecision& dot, const rvector& x, const srvector& y) {
1809  fsp_vv_accuapprox<dotprecision,rvector,srvector,sparse_dot>(dot,x,y);
1810 }
1811 
1813 
1817 inline void accumulate_approx(dotprecision& dot, const rvector_slice& x, const srvector& y) {
1818  fsp_vv_accuapprox<dotprecision,rvector_slice,srvector,sparse_dot>(dot,x,y);
1819 }
1820 
1822 
1826 inline void accumulate_approx(dotprecision& dot, const srvector_slice& x, const rvector& y) {
1827  slf_vv_accuapprox<dotprecision,srvector_slice,rvector,sparse_dot>(dot,x,y);
1828 }
1829 
1831 
1835 inline void accumulate_approx(dotprecision& dot, const srvector_slice& x, const rvector_slice& y) {
1836  slf_vv_accuapprox<dotprecision,srvector_slice,rvector_slice,sparse_dot>(dot,x,y);
1837 }
1838 
1840 
1844 inline void accumulate_approx(dotprecision& dot, const rvector& x, const srvector_slice& y) {
1845  fsl_vv_accuapprox<dotprecision,rvector,srvector_slice,sparse_dot>(dot,x,y);
1846 }
1847 
1849 
1853 inline void accumulate_approx(dotprecision& dot, const rvector_slice& x, const srvector_slice& y) {
1854  fsl_vv_accuapprox<dotprecision,rvector_slice,srvector_slice,sparse_dot>(dot,x,y);
1855 }
1856 
1858 
1862 inline void accumulate_approx(dotprecision& dot, const srvector_slice& x, const srvector_slice& y) {
1863  slsl_vv_accuapprox<dotprecision,srvector_slice,srvector_slice,sparse_dot>(dot,x,y);
1864 }
1865 
1867 
1871 inline void accumulate_approx(dotprecision& dot, const srvector& x, const srvector_slice& y) {
1872  spsl_vv_accuapprox<dotprecision,srvector,srvector_slice,sparse_dot>(dot,x,y);
1873 }
1874 
1876 
1880 inline void accumulate_approx(dotprecision& dot, const srvector_slice& x, const srvector& y) {
1881  slsp_vv_accuapprox<dotprecision,srvector_slice,srvector,sparse_dot>(dot,x,y);
1882 }
1883 
1885 
1888 inline void accumulate(idotprecision& dot, const srvector& x, const srvector& y) {
1889  dotprecision tmp(0.0);
1890  tmp.set_k(dot.get_k());
1891  accumulate(tmp,x,y);
1892  dot += tmp;
1893 }
1894 
1896 
1899 inline void accumulate(idotprecision& dot, const srvector& x, const rvector& y) {
1900  dotprecision tmp(0.0);
1901  tmp.set_k(dot.get_k());
1902  accumulate(tmp,x,y);
1903  dot += tmp;
1904 }
1905 
1907 
1910 inline void accumulate(idotprecision& dot, const srvector& x, const rvector_slice& y) {
1911  dotprecision tmp(0.0);
1912  tmp.set_k(dot.get_k());
1913  accumulate(tmp,x,y);
1914  dot += tmp;
1915 }
1916 
1918 
1921 inline void accumulate(idotprecision& dot, const rvector& x, const srvector& y) {
1922  dotprecision tmp(0.0);
1923  tmp.set_k(dot.get_k());
1924  accumulate(tmp,x,y);
1925  dot += tmp;
1926 }
1927 
1929 
1932 inline void accumulate(idotprecision& dot, const rvector_slice& x, const srvector& y) {
1933  dotprecision tmp(0.0);
1934  tmp.set_k(dot.get_k());
1935  accumulate(tmp,x,y);
1936  dot += tmp;
1937 }
1938 
1940 
1943 inline void accumulate(idotprecision& dot, const srvector_slice& x, const rvector& y) {
1944  dotprecision tmp(0.0);
1945  tmp.set_k(dot.get_k());
1946  accumulate(tmp,x,y);
1947  dot += tmp;
1948 }
1949 
1951 
1954 inline void accumulate(idotprecision& dot, const srvector_slice& x, const rvector_slice& y) {
1955  dotprecision tmp(0.0);
1956  tmp.set_k(dot.get_k());
1957  accumulate(tmp,x,y);
1958  dot += tmp;
1959 }
1960 
1962 
1965 inline void accumulate(idotprecision& dot, const rvector& x, const srvector_slice& y) {
1966  dotprecision tmp(0.0);
1967  tmp.set_k(dot.get_k());
1968  accumulate(tmp,x,y);
1969  dot += tmp;
1970 }
1971 
1973 
1976 inline void accumulate(idotprecision& dot, const rvector_slice& x, const srvector_slice& y) {
1977  dotprecision tmp(0.0);
1978  tmp.set_k(dot.get_k());
1979  accumulate(tmp,x,y);
1980  dot += tmp;
1981 }
1982 
1984 
1987 inline void accumulate(idotprecision& dot, const srvector_slice& x, const srvector_slice& y) {
1988  dotprecision tmp(0.0);
1989  tmp.set_k(dot.get_k());
1990  accumulate(tmp,x,y);
1991  dot += tmp;
1992 }
1993 
1995 
1998 inline void accumulate(idotprecision& dot, const srvector& x, const srvector_slice& y) {
1999  dotprecision tmp(0.0);
2000  tmp.set_k(dot.get_k());
2001  accumulate(tmp,x,y);
2002  dot += tmp;
2003 }
2004 
2006 
2009 inline void accumulate(idotprecision& dot, const srvector_slice& x, const srvector& y) {
2010  dotprecision tmp(0.0);
2011  tmp.set_k(dot.get_k());
2012  accumulate(tmp,x,y);
2013  dot += tmp;
2014 }
2015 
2017 
2020 inline void accumulate(cdotprecision& dot, const srvector& x, const srvector& y) {
2021  dotprecision tmp(0.0);
2022  tmp.set_k(dot.get_k());
2023  accumulate(tmp,x,y);
2024  dot += tmp;
2025 }
2026 
2028 
2031 inline void accumulate(cdotprecision& dot, const srvector& x, const rvector& y) {
2032  dotprecision tmp(0.0);
2033  tmp.set_k(dot.get_k());
2034  accumulate(tmp,x,y);
2035  dot += tmp;
2036 }
2037 
2039 
2042 inline void accumulate(cdotprecision& dot, const srvector& x, const rvector_slice& y) {
2043  dotprecision tmp(0.0);
2044  tmp.set_k(dot.get_k());
2045  accumulate(tmp,x,y);
2046  dot += tmp;
2047 }
2048 
2050 
2053 inline void accumulate(cdotprecision& dot, const rvector& x, const srvector& y) {
2054  dotprecision tmp(0.0);
2055  tmp.set_k(dot.get_k());
2056  accumulate(tmp,x,y);
2057  dot += tmp;
2058 }
2059 
2061 
2064 inline void accumulate(cdotprecision& dot, const rvector_slice& x, const srvector& y) {
2065  dotprecision tmp(0.0);
2066  tmp.set_k(dot.get_k());
2067  accumulate(tmp,x,y);
2068  dot += tmp;
2069 }
2070 
2072 
2075 inline void accumulate(cdotprecision& dot, const srvector_slice& x, const rvector& y) {
2076  dotprecision tmp(0.0);
2077  tmp.set_k(dot.get_k());
2078  accumulate(tmp,x,y);
2079  dot += tmp;
2080 }
2081 
2083 
2086 inline void accumulate(cdotprecision& dot, const srvector_slice& x, const rvector_slice& y) {
2087  dotprecision tmp(0.0);
2088  tmp.set_k(dot.get_k());
2089  accumulate(tmp,x,y);
2090  dot += tmp;
2091 }
2092 
2094 
2097 inline void accumulate(cdotprecision& dot, const rvector& x, const srvector_slice& y) {
2098  dotprecision tmp(0.0);
2099  tmp.set_k(dot.get_k());
2100  accumulate(tmp,x,y);
2101  dot += tmp;
2102 }
2103 
2105 
2108 inline void accumulate(cdotprecision& dot, const rvector_slice& x, const srvector_slice& y) {
2109  dotprecision tmp(0.0);
2110  tmp.set_k(dot.get_k());
2111  accumulate(tmp,x,y);
2112  dot += tmp;
2113 }
2114 
2116 
2119 inline void accumulate(cdotprecision& dot, const srvector_slice& x, const srvector_slice& y) {
2120  dotprecision tmp(0.0);
2121  tmp.set_k(dot.get_k());
2122  accumulate(tmp,x,y);
2123  dot += tmp;
2124 }
2125 
2127 
2130 inline void accumulate(cdotprecision& dot, const srvector& x, const srvector_slice& y) {
2131  dotprecision tmp(0.0);
2132  tmp.set_k(dot.get_k());
2133  accumulate(tmp,x,y);
2134  dot += tmp;
2135 }
2136 
2138 
2141 inline void accumulate(cdotprecision& dot, const srvector_slice& x, const srvector& y) {
2142  dotprecision tmp(0.0);
2143  tmp.set_k(dot.get_k());
2144  accumulate(tmp,x,y);
2145  dot += tmp;
2146 }
2147 
2149 
2153 inline void accumulate_approx(cdotprecision& dot, const srvector& x, const srvector& y) {
2154  dotprecision tmp(0.0);
2155  tmp.set_k(dot.get_k());
2156  accumulate_approx(tmp,x,y);
2157  dot += tmp;
2158 }
2159 
2161 
2165 inline void accumulate_approx(cdotprecision& dot, const srvector& x, const rvector& y) {
2166  dotprecision tmp(0.0);
2167  tmp.set_k(dot.get_k());
2168  accumulate_approx(tmp,x,y);
2169  dot += tmp;
2170 }
2171 
2173 
2177 inline void accumulate_approx(cdotprecision& dot, const srvector& x, const rvector_slice& y) {
2178  dotprecision tmp(0.0);
2179  tmp.set_k(dot.get_k());
2180  accumulate_approx(tmp,x,y);
2181  dot += tmp;
2182 }
2183 
2185 
2189 inline void accumulate_approx(cdotprecision& dot, const rvector& x, const srvector& y) {
2190  dotprecision tmp(0.0);
2191  tmp.set_k(dot.get_k());
2192  accumulate_approx(tmp,x,y);
2193  dot += tmp;
2194 }
2195 
2197 
2201 inline void accumulate_approx(cdotprecision& dot, const rvector_slice& x, const srvector& y) {
2202  dotprecision tmp(0.0);
2203  tmp.set_k(dot.get_k());
2204  accumulate_approx(tmp,x,y);
2205  dot += tmp;
2206 }
2207 
2209 
2213 inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const rvector& y) {
2214  dotprecision tmp(0.0);
2215  tmp.set_k(dot.get_k());
2216  accumulate_approx(tmp,x,y);
2217  dot += tmp;
2218 }
2219 
2221 
2225 inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const rvector_slice& y) {
2226  dotprecision tmp(0.0);
2227  tmp.set_k(dot.get_k());
2228  accumulate_approx(tmp,x,y);
2229  dot += tmp;
2230 }
2231 
2233 
2237 inline void accumulate_approx(cdotprecision& dot, const rvector& x, const srvector_slice& y) {
2238  dotprecision tmp(0.0);
2239  tmp.set_k(dot.get_k());
2240  accumulate_approx(tmp,x,y);
2241  dot += tmp;
2242 }
2243 
2245 
2249 inline void accumulate_approx(cdotprecision& dot, const rvector_slice& x, const srvector_slice& y) {
2250  dotprecision tmp(0.0);
2251  tmp.set_k(dot.get_k());
2252  accumulate_approx(tmp,x,y);
2253  dot += tmp;
2254 }
2255 
2257 
2261 inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const srvector_slice& y) {
2262  dotprecision tmp(0.0);
2263  tmp.set_k(dot.get_k());
2264  accumulate_approx(tmp,x,y);
2265  dot += tmp;
2266 }
2267 
2269 
2273 inline void accumulate_approx(cdotprecision& dot, const srvector& x, const srvector_slice& y) {
2274  dotprecision tmp(0.0);
2275  tmp.set_k(dot.get_k());
2276  accumulate_approx(tmp,x,y);
2277  dot += tmp;
2278 }
2279 
2281 
2285 inline void accumulate_approx(cdotprecision& dot, const srvector_slice& x, const srvector& y) {
2286  dotprecision tmp(0.0);
2287  tmp.set_k(dot.get_k());
2288  accumulate_approx(tmp,x,y);
2289  dot += tmp;
2290 }
2291 
2293 
2296 inline void accumulate(cidotprecision& dot, const srvector& x, const srvector& y) {
2297  dotprecision tmp(0.0);
2298  tmp.set_k(dot.get_k());
2299  accumulate(tmp,x,y);
2300  dot += tmp;
2301 }
2302 
2304 
2307 inline void accumulate(cidotprecision& dot, const srvector& x, const rvector& y) {
2308  dotprecision tmp(0.0);
2309  tmp.set_k(dot.get_k());
2310  accumulate(tmp,x,y);
2311  dot += tmp;
2312 }
2313 
2315 
2318 inline void accumulate(cidotprecision& dot, const srvector& x, const rvector_slice& y) {
2319  dotprecision tmp(0.0);
2320  tmp.set_k(dot.get_k());
2321  accumulate(tmp,x,y);
2322  dot += tmp;
2323 }
2324 
2326 
2329 inline void accumulate(cidotprecision& dot, const rvector& x, const srvector& y) {
2330  dotprecision tmp(0.0);
2331  tmp.set_k(dot.get_k());
2332  accumulate(tmp,x,y);
2333  dot += tmp;
2334 }
2335 
2337 
2340 inline void accumulate(cidotprecision& dot, const rvector_slice& x, const srvector& y) {
2341  dotprecision tmp(0.0);
2342  tmp.set_k(dot.get_k());
2343  accumulate(tmp,x,y);
2344  dot += tmp;
2345 }
2346 
2348 
2351 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const rvector& y) {
2352  dotprecision tmp(0.0);
2353  tmp.set_k(dot.get_k());
2354  accumulate(tmp,x,y);
2355  dot += tmp;
2356 }
2357 
2359 
2362 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const rvector_slice& y) {
2363  dotprecision tmp(0.0);
2364  tmp.set_k(dot.get_k());
2365  accumulate(tmp,x,y);
2366  dot += tmp;
2367 }
2368 
2370 
2373 inline void accumulate(cidotprecision& dot, const rvector& x, const srvector_slice& y) {
2374  dotprecision tmp(0.0);
2375  tmp.set_k(dot.get_k());
2376  accumulate(tmp,x,y);
2377  dot += tmp;
2378 }
2379 
2381 
2384 inline void accumulate(cidotprecision& dot, const rvector_slice& x, const srvector_slice& y) {
2385  dotprecision tmp(0.0);
2386  tmp.set_k(dot.get_k());
2387  accumulate(tmp,x,y);
2388  dot += tmp;
2389 }
2390 
2392 
2395 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const srvector_slice& y) {
2396  dotprecision tmp(0.0);
2397  tmp.set_k(dot.get_k());
2398  accumulate(tmp,x,y);
2399  dot += tmp;
2400 }
2401 
2403 
2406 inline void accumulate(cidotprecision& dot, const srvector& x, const srvector_slice& y) {
2407  dotprecision tmp(0.0);
2408  tmp.set_k(dot.get_k());
2409  accumulate(tmp,x,y);
2410  dot += tmp;
2411 }
2412 
2414 
2417 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const srvector& y) {
2418  dotprecision tmp(0.0);
2419  tmp.set_k(dot.get_k());
2420  accumulate(tmp,x,y);
2421  dot += tmp;
2422 }
2423 
2424 
2425 } //namespace cxsc
2426 
2427 #include "sparsevector.inl"
2428 
2429 #endif
The Data Type cdotprecision.
Definition: cdot.hpp:61
int get_k() const
Get currently set precision for computation of dot products.
Definition: cdot.hpp:91
The Data Type cidotprecision.
Definition: cidot.hpp:58
int get_k() const
Get currently set precision for computation of dot products.
Definition: cidot.hpp:89
The Data Type civector_slice.
Definition: civector.hpp:1015
The Data Type civector.
Definition: civector.hpp:57
The Data Type cvector_slice.
Definition: cvector.hpp:845
The Data Type cvector.
Definition: cvector.hpp:58
The Data Type dotprecision.
Definition: dot.hpp:112
void set_k(unsigned int i)
Set precision for computation of dot products.
Definition: dot.hpp:131
The Data Type idotprecision.
Definition: idot.hpp:48
int get_k() const
Get currently set precision for computation of dot products.
Definition: idot.hpp:86
The Data Type intmatrix.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector_slice.
Definition: ivector.hpp:963
The Data Type ivector.
Definition: ivector.hpp:55
The Scalar Type real.
Definition: real.hpp:114
The Data Type rvector_slice.
Definition: rvector.hpp:1064
rvector_slice & operator+=(const rvector &rv) noexcept
Implementation of addition and allocation operation.
Definition: rvector.inl:397
rvector_slice & operator-=(const rvector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: rvector.inl:456
rvector_slice & operator=(const rvector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: rvector.inl:258
The Data Type rvector.
Definition: rvector.hpp:58
rvector & operator-=(const srvector &rv)
Implementation of addition and allocation operation.
Definition: srvector.hpp:586
rvector & operator+=(const srvector &rv)
Implementation of addition and allocation operation.
Definition: srvector.hpp:578
rvector & operator=(const rvector &rv) noexcept
Implementation of standard assigning operator.
Definition: rvector.inl:254
rvector() noexcept
Constructor of class rvector.
Definition: rvector.inl:37
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
A sparse complex interval vector.
Definition: scivector.hpp:62
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
A sparse interval vector.
Definition: sivector.hpp:59
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
A sparse real matrix.
Definition: srmatrix.hpp:77
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
friend int Ub(const srvector_slice &)
Returns the upper index bound of the vector slice v.
Definition: srvector.hpp:1118
friend int VecLen(const srvector_slice &)
Returns the length of the vector slice.
Definition: srvector.hpp:1123
srvector_slice & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1020
srvector_slice & operator=(const real &v)
Assigns v to all elements of the vector slice.
Definition: srvector.hpp:965
real & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector slic...
Definition: srvector.hpp:915
srvector_slice & operator=(const rvector &v)
Overwrite the vector slice with the elements of v.
Definition: srvector.hpp:980
const real operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: srvector.hpp:950
friend srvector operator*(const srmatrix &, const srvector_slice &)
Returns the product of the matrix A and the vector v.
Definition: srmatrix.hpp:1038
srvector_slice & operator=(const srvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: srvector.hpp:970
srvector_slice & operator-=(const srvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1035
srvector_slice & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1010
srvector_slice & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector slice.
Definition: srvector.hpp:990
srvector_slice & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1000
srvector_slice & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1025
srvector_slice & operator=(const rvector_slice &v)
Overwrite the vector slice with the elements of v.
Definition: srvector.hpp:985
srvector_slice & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1030
srvector_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: srvector.hpp:995
real density() const
Returns the density of the vector slice (the number of non zero elements divided by the number of ele...
Definition: srvector.hpp:906
srvector_slice & operator+=(const srvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1015
int get_nnz() const
Returns the number of non zero elements of this vector slice (note that this includes explicitly stor...
Definition: srvector.hpp:902
friend int Lb(const srvector_slice &)
Returns the lower index bound of the vector slice v.
Definition: srvector.hpp:1113
srvector_slice & operator=(const srvector &v)
Overwrite the vector slice with the elements of v.
Definition: srvector.hpp:975
real operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector slice.
Definition: srvector.hpp:938
srvector_slice & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector slice.
Definition: srvector.hpp:1005
A sparse real vector.
Definition: srvector.hpp:58
srvector(const rvector &v)
Constructor for creating a sparse vector our of a dense vector v. Only the non-zero elements of v are...
Definition: srvector.hpp:84
srvector & operator/=(const real &s)
Operator for division of each element of the vector with a scalar, result is assigned to the vector.
Definition: srvector.hpp:293
srvector & operator=(const real &v)
Assigns v to all elements of the vector (resulting in a dense vector!)
Definition: srvector.hpp:180
srvector & operator=(const rvector &v)
Assign the dense vector v to a sparse vector. Only the non zero elements of v are used.
Definition: srvector.hpp:185
srvector & operator-=(const rvector_slice &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: srvector.hpp:322
const std::vector< int > & row_indices() const
Returns a reference to the STL-vector storing the row indices of the non zero elements.
Definition: srvector.hpp:146
friend srvector InfRe(const scivector &)
Returns the infimum of the real part of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:952
srvector & operator-=(const rvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: srvector.hpp:317
real density() const
Returns the density of the vector (the number of non zero elements divided by the number of elements)
Definition: srvector.hpp:165
friend srvector mid(const sivector &)
Compute the midpoint vector of v.
Definition: sivector.hpp:650
srvector & operator+=(const rvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: srvector.hpp:298
srvector & operator+=(const srvector &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: srvector.hpp:309
friend int VecLen(const srvector &)
Returns the length of the vector (the dimension)
Definition: srvector.hpp:427
friend srvector SupRe(const scivector &)
Returns the supremum of the real part of the complex interval vector as a new sparse point vector.
Definition: scivector.hpp:974
void dropzeros()
Erases explicitly stored zeros from the data structure.
Definition: srvector.hpp:170
friend srvector SupIm(const scivector &)
Returns the supremum of the imaginary part of the complex interval vector as a new sparse point vecto...
Definition: scivector.hpp:985
friend srvector abs(const srvector &)
Returns the vector whose elements are the respective absolute values of the elements of v.
Definition: srvector.hpp:1128
friend srvector diam(const sivector &)
Computes the diameter of v.
Definition: sivector.hpp:662
srvector(const int s, const int b)
Constructor for creating an empty vector of size s and reserving memory for b elements.
Definition: srvector.hpp:78
srvector & 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: srvector.hpp:190
srvector(const int n, const int nnz, const intvector &index, const rvector &values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition: srvector.hpp:94
std::vector< real > & values()
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: srvector.hpp:136
friend void SetUb(srvector &, const int)
Sets the upper index bound of the vector v to i.
Definition: srvector.hpp:411
srvector operator()(const intvector &per)
Returns a vector whose elemnts are rearranged according to a given permutation vector.
Definition: srvector.hpp:259
const std::vector< real > & values() const
Returns a reference to the STL-vector storing the values of the non zero elements.
Definition: srvector.hpp:155
friend srvector Sup(const sivector &)
Returns the supremum of the interval vector as a new sparse point vector.
Definition: sivector.hpp:604
friend srvector InfIm(const scivector &)
Returns the infimum of the imaginary part of the complex interval vector as a new sparse point vector...
Definition: scivector.hpp:963
srvector & operator*=(const real &s)
Operator for multiplication with a scalar, result is assigned to the vector.
Definition: srvector.hpp:288
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
srvector operator()(const intmatrix &P)
Returns a vector whose elemnts are rearranged according to a given permutation matrix.
Definition: srvector.hpp:282
const real operator()(const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: srvector.hpp:236
srvector(const int n, const int nnz, const int *index, const real *values)
Creates a sparse vector of dimension n with nnz non zeros, who are defined by the elements of index a...
Definition: srvector.hpp:106
friend srvector absmin(const sivector &)
Computes the component-wise minimum absolute values for a vector v.
Definition: sivector.hpp:626
srvector(const int s)
Constructor for creating an empty vector of size s.
Definition: srvector.hpp:72
friend srvector Inf(const sivector &)
Returns the infimum of the interval vector as a new sparse point vector.
Definition: sivector.hpp:593
real & operator[](const int i)
Returns a reference to the i-th (according to the currently used indexing) element of the vector.
Definition: srvector.hpp:202
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
friend srvector Im(const scvector &)
Returns the imaginary part of the complex vector v.
Definition: scvector.hpp:528
friend srvector Re(const scvector &)
Returns the real part of the complex vector v.
Definition: scvector.hpp:517
srvector()
Default constructor, creates an empty vector of size 0.
Definition: srvector.hpp:68
friend int Lb(const srvector &)
Returns the lower index bound of the vector v.
Definition: srvector.hpp:417
real operator[](const int i) const
Returns a copy of the i-th (according to the currently used indexing) element of the vector.
Definition: srvector.hpp:224
friend void SetLb(srvector &, const int)
Sets the lower index bound of the vector v to i.
Definition: srvector.hpp:402
friend srvector absmax(const sivector &)
Computes the component-wise maximum absolute values for a vector v.
Definition: sivector.hpp:638
srvector & operator+=(const rvector_slice &v)
Operator for element-wise addition with a vector, result is assigned to the vector.
Definition: srvector.hpp:304
srvector & operator-=(const srvector &v)
Operator for element-wise subtraction with a vector, result is assigned to the vector.
Definition: srvector.hpp:327
friend int Ub(const srvector &)
Returns the upper index bound of the vector v.
Definition: srvector.hpp:422
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
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.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
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.
Definition: cimatrix.inl:1211
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156