C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
sivector.hpp
00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: sivector.hpp,v 1.15 2014/01/30 17:23:48 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_SIVECTOR_HPP_INCLUDED
00027 #define _CXSC_SIVECTOR_HPP_INCLUDED
00028 
00029 #include <interval.hpp>
00030 #include <ivector.hpp>
00031 #include <vector>
00032 #include <iostream>
00033 #include <cidot.hpp>
00034 #include <srvector.hpp>
00035 #include <sparseidot.hpp>
00036 #include <sparsevector.hpp>
00037 
00038 namespace cxsc {
00039 
00040 class srvector_slice;
00041 class srmatrix;
00042 class srmatrix_slice;
00043 class srmatrix_subv;
00044 class sivector_slice;
00045 class simatrix;
00046 class simatrix_slice;
00047 class simatrix_subv;
00048 class scivector;
00049 class scivector_slice;
00050 class scimatrix;
00051 class scimatrix_slice;
00052 class scimatrix_subv;
00053 
00055 
00059 class sivector {
00060   private:
00061     std::vector<int> p;
00062     std::vector<interval> x;
00063     int lb;
00064     int ub;
00065     int n; 
00066 
00067   public:
00069     sivector() : lb(0), ub(-1) , n(0) {
00070     }
00071 
00073     explicit sivector(const int s) : lb(1), ub(s), n(s) {
00074         p.reserve((int)(s*0.1));
00075         x.reserve((int)(s*0.1));
00076     }
00077 
00079     sivector(const int s, const int b) : lb(1), ub(s), n(s) {
00080         p.reserve(b);
00081         x.reserve(b);
00082     }
00083 
00085     sivector(const ivector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
00086         for(int i=lb ; i<=ub ; i++) {
00087           if(v[i] != 0.0) {
00088             p.push_back(i-lb);
00089             x.push_back(v[i]);
00090           }
00091         }
00092     }
00093 
00095     sivector(const rvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
00096         for(int i=lb ; i<=ub ; i++) {
00097           if(v[i] != 0.0) {
00098             p.push_back(i-lb);
00099             x.push_back(interval(v[i]));
00100           }
00101         }
00102     }
00103 
00105     sivector(const int n, const int nnz, const intvector& index, const ivector& values) : lb(1), ub(n) {
00106       this->n = n;
00107       for(int i=0 ; i<nnz ; i++) {
00108         if(values[Lb(values)+i] != 0.0) {
00109           p.push_back(index[Lb(index)+i]);
00110           x.push_back(values[Lb(values)+i]);
00111         }
00112       }
00113     }
00114 
00116     sivector(const int n, const int nnz, const int* index, const interval* values) : lb(1), ub(n) {
00117       this->n = n;
00118       for(int i=0 ; i<nnz ; i++) {
00119         if(values[i] != 0.0) {
00120           p.push_back(index[i]);
00121           x.push_back(values[i]);
00122         }
00123       }
00124     }
00125 
00127     sivector(const srvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
00128       x.reserve(v.get_nnz());
00129       for(int i=0 ; i<v.get_nnz() ; i++) 
00130         x.push_back(interval(v.x[i]));
00131     }
00132 
00134     sivector(const srvector_slice&);
00136     sivector(const sivector_slice&);
00138     sivector(const srmatrix_subv& A);
00140     sivector(const simatrix_subv& A);
00141 
00143 
00148     std::vector<int>& row_indices() {
00149       return p;
00150     }
00151 
00153 
00157     std::vector<interval>& values() {
00158       return x;
00159     }
00160 
00162 
00167     const std::vector<int>& row_indices() const {
00168       return p;
00169     }
00170 
00172 
00176     const std::vector<interval>& values() const {
00177       return x;
00178     }
00179 
00181     int get_nnz() const {
00182       return x.size();
00183     }
00184 
00186     real density() const {
00187       return (double)x.size()/n;
00188     }
00189 
00191     void dropzeros() {
00192       for(int i=0 ; i<get_nnz() ; i++) {
00193         if(x[i] == 0.0) {
00194            x.erase(x.begin()+i);
00195            p.erase(p.begin()+i);
00196         }
00197       }
00198     }
00199 
00200 
00201     /* sivector& operator=(const sivector& v) {
00202       p = v.p;
00203       x = v.x;
00204       return *this;
00205     } */
00206 
00208     sivector& operator=(const srvector& v) {
00209       n = v.n;
00210       p = v.p;
00211       x.clear();
00212       x.reserve(v.get_nnz());
00213       for(unsigned int i=0 ; i<v.x.size() ; i++)
00214         x[i] = interval(v.x[i]);
00215       return *this;
00216     } 
00217 
00219     sivector& operator=(const real& v) {
00220       return sp_vs_assign<sivector,real,interval>(*this,v);
00221     }
00222 
00224     sivector& operator=(const interval& v) {
00225       return sp_vs_assign<sivector,interval,interval>(*this,v);
00226     }
00227 
00229     sivector& operator=(const rvector& v) {
00230       return spf_vv_assign<sivector,rvector,interval>(*this,v);
00231     }
00232 
00234     sivector& operator=(const ivector& v) {
00235       return spf_vv_assign<sivector,ivector,interval>(*this,v);
00236     }
00237 
00239     sivector& operator=(const rvector_slice& v) {
00240       return spf_vv_assign<sivector,rvector_slice,interval>(*this,v);
00241     }
00242 
00244     sivector& operator=(const ivector_slice& v) {
00245       return spf_vv_assign<sivector,ivector_slice,interval>(*this,v);
00246     }
00247 
00249     sivector& operator=(const sivector_slice&);
00251     sivector& operator=(const srvector_slice&);
00252 
00254 
00258     interval& operator[](const int i) {
00259 #if(CXSC_INDEX_CHECK)
00260       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator[](const int)"));
00261 #endif
00262       int k;
00263 
00264       for(k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
00265         if(p[k] == i-lb) 
00266           return x[k];
00267       }
00268 
00269       p.insert(p.begin() + k, i-lb);
00270       x.insert(x.begin() + k, interval(0.0));
00271 
00272       return x[k];
00273     }
00274 
00276 
00280     interval operator[](const int i) const {
00281 #if(CXSC_INDEX_CHECK)
00282       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator[](const int)"));
00283 #endif
00284       return (*this)(i);
00285     }
00286 
00288 
00292     const interval operator()(const int i) const {
00293 #if(CXSC_INDEX_CHECK)
00294       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator()(const int)"));
00295 #endif
00296       interval r(0.0);
00297 
00298       for(int k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
00299         if(p[k] == i-lb) 
00300           r = x[k];
00301       }
00302 
00303       return r; 
00304     }
00305 
00307 
00310     sivector operator()(const intvector& per) {
00311       sivector v(n,get_nnz());
00312       intvector pinv = perminv(per);
00313 
00314       std::map<int,interval> work;
00315       for(int i=0 ; i<get_nnz() ; i++) {
00316          work.insert(std::make_pair(pinv[Lb(pinv)+p[i]], x[i]));
00317       }
00318  
00319       for(std::map<int,interval>::iterator it=work.begin() ; it!=work.end() ; it++) {
00320          v.p.push_back(it->first);
00321          v.x.push_back(it->second);
00322       }
00323 
00324       return v;
00325     }
00326 
00328 
00334     sivector operator()(const intmatrix& P) {
00335       intvector p = permvec(P);
00336       return (*this)(p);
00337     }
00338 
00340 
00342     sivector_slice operator()(const int, const int);
00343 
00345     sivector& operator*=(const real& s) {
00346       return sp_vs_multassign(*this,s);
00347     }
00348 
00350     sivector& operator*=(const interval& s) {
00351       return sp_vs_multassign(*this,s);
00352     }
00353 
00355     sivector& operator/=(const real& s) {
00356       return sp_vs_divassign(*this,s);
00357     }
00358 
00360     sivector& operator/=(const interval& s) {
00361       return sp_vs_divassign(*this,s);
00362     }
00363 
00365     sivector& operator+=(const rvector& v) {
00366       return spf_vv_addassign(*this,v);
00367     }
00368 
00370     sivector& operator+=(const ivector& v) {
00371       return spf_vv_addassign(*this,v);
00372     }
00373 
00375     sivector& operator+=(const rvector_slice& v) {
00376       return spf_vv_addassign(*this,v);
00377     }
00378 
00380     sivector& operator+=(const ivector_slice& v) {
00381       return spf_vv_addassign(*this,v);
00382     }
00383 
00385     sivector& operator+=(const srvector& v) {
00386       return spsp_vv_addassign(*this,v);
00387     }
00388 
00390     sivector& operator+=(const sivector& v) {
00391       return spsp_vv_addassign(*this,v);
00392     }
00393 
00395     sivector& operator-=(const rvector& v) {
00396       return spf_vv_subassign(*this,v);
00397     }
00398 
00400     sivector& operator-=(const ivector& v) {
00401       return spf_vv_subassign(*this,v);
00402     }
00403 
00405     sivector& operator-=(const rvector_slice& v) {
00406       return spf_vv_subassign(*this,v);
00407     }
00408 
00410     sivector& operator-=(const ivector_slice& v) {
00411       return spf_vv_subassign(*this,v);
00412     }
00413 
00415     sivector& operator-=(const srvector& v) {
00416       return spsp_vv_subassign(*this,v);
00417     }
00418 
00420     sivector& operator-=(const sivector& v) {
00421       return spsp_vv_subassign(*this,v);
00422     }
00423 
00425     sivector& operator|=(const rvector& v) {
00426       return spf_vv_hullassign(*this,v);
00427     }
00428 
00430     sivector& operator|=(const ivector& v) {
00431       return spf_vv_hullassign(*this,v);
00432     }
00433 
00435     sivector& operator|=(const rvector_slice& v) {
00436       return spf_vv_hullassign(*this,v);
00437     }
00438 
00440     sivector& operator|=(const ivector_slice& v) {
00441       return spf_vv_hullassign(*this,v);
00442     }
00443 
00445     sivector& operator|=(const srvector& v) {
00446       return spsp_vv_hullassign(*this,v);
00447     }
00448 
00450     sivector& operator|=(const sivector& v) {
00451       return spsp_vv_hullassign(*this,v);
00452     }
00453 
00455     sivector& operator&=(const ivector_slice& v) {
00456       return spf_vv_intersectassign(*this,v);
00457     }
00458 
00460     sivector& operator&=(const sivector& v) {
00461       return spsp_vv_intersectassign(*this,v);
00462     }
00463 
00465     sivector& operator+=(const srvector_slice&);
00467     sivector& operator+=(const sivector_slice&);
00469     sivector& operator-=(const srvector_slice&);
00471     sivector& operator-=(const sivector_slice&);
00472 
00473     friend void SetLb(sivector&, const int);
00474     friend void SetUb(sivector&, const int);
00475     friend int Lb(const sivector&);
00476     friend int Ub(const sivector&);
00477     friend srvector Inf(const sivector&);
00478     friend srvector Sup(const sivector&);
00479     friend sivector Re(const scivector&);
00480     friend sivector Im(const scivector&);
00481     friend sivector abs(const sivector&);
00482     friend sivector abs(const sivector_slice&);
00483     friend srvector mid(const sivector&);
00484     friend srvector diam(const sivector&);
00485     friend sivector abs(const scivector&);
00486     friend sivector abs(const scivector_slice&);
00487     friend srvector absmin(const sivector&);
00488     friend srvector absmax(const sivector&);
00489     friend int VecLen(const sivector&);
00490     friend sivector Blow(const sivector&, const real&);
00491 
00492     friend class srvector_slice;
00493     friend class sivector_slice;
00494     friend class scivector_slice;
00495     friend class scivector;
00496     friend class ivector;
00497     friend class ivector_slice;
00498     friend class civector;
00499     friend class civector_slice;
00500 
00501 #include "vector_friend_declarations.inl"
00502 };
00503 
00504 inline ivector::ivector(const sivector& v) {
00505   l = v.lb;
00506   u = v.ub;
00507   size = v.n;
00508   dat = new interval[v.n];
00509   for(int i=0 ; i<v.n ; i++)
00510     dat[i] = 0.0;
00511   for(int i=0 ; i<v.get_nnz() ; i++)
00512     dat[v.p[i]] = v.x[i];
00513 }
00514 
00515 inline ivector::ivector(const srvector& v) {
00516   l = v.lb;
00517   u = v.ub;
00518   size = v.n;
00519   dat = new interval[v.n];
00520   for(int i=0 ; i<v.n ; i++)
00521     dat[i] = 0.0;
00522   for(int i=0 ; i<v.get_nnz() ; i++)
00523     dat[v.p[i]] = v.x[i];
00524 }
00525 
00526 inline ivector& ivector::operator=(const sivector& v) {
00527   return fsp_vv_assign<ivector,sivector,interval>(*this,v);
00528 }
00529 
00530 inline ivector& ivector::operator=(const sivector_slice& v) {
00531   return fsl_vv_assign<ivector,sivector_slice,interval>(*this,v);
00532 }
00533 
00534 inline ivector& ivector::operator=(const srvector& v) {
00535   return fsp_vv_assign<ivector,srvector,interval>(*this,v);
00536 }
00537 
00538 inline ivector& ivector::operator=(const srvector_slice& v) {
00539   return fsl_vv_assign<ivector,srvector_slice,interval>(*this,v);
00540 }
00541 
00543 
00546 inline void SetLb(sivector& v, const int i) {
00547   v.lb = i;
00548   v.ub = v.lb + v.n - 1;
00549 }
00550 
00552 
00555 inline void SetUb(sivector& v, const int j) {
00556   v.ub = j;
00557   v.lb = v.ub - v.n + 1;
00558 }
00559 
00561 inline int Lb(const sivector& v) {
00562   return v.lb;
00563 }
00564 
00566 inline int Ub(const sivector& v) {
00567   return v.ub;
00568 }
00569 
00571 inline void Resize(sivector& v) {
00572   sp_v_resize(v);
00573 }
00574 
00576 
00579 inline void Resize(sivector& v, const int n) {
00580   sp_v_resize(v,n);
00581 }
00582 
00584 
00588 inline void Resize(sivector& v, const int l, const int u) {
00589   sp_v_resize(v,l,u);
00590 }
00591 
00593 inline srvector Inf(const sivector& v) {
00594   srvector res(v.n, v.get_nnz());
00595   res.lb = v.lb;
00596   res.ub = v.ub;
00597   res.p  = v.p;
00598   for(int i=0 ; i<v.get_nnz() ; i++)
00599     res.x[i] = Inf(v.x[i]);
00600   return res;
00601 }
00602 
00604 inline srvector Sup(const sivector& v) {
00605   srvector res(v.n, v.get_nnz());
00606   res.lb = v.lb;
00607   res.ub = v.ub;
00608   res.p  = v.p;
00609   for(int i=0 ; i<v.get_nnz() ; i++)
00610     res.x[i] = Sup(v.x[i]);
00611   return res;
00612 }
00613 
00615 inline sivector abs(const sivector& v) {
00616   sivector res(v.n, v.get_nnz());
00617   res.lb = v.lb;
00618   res.ub = v.ub;
00619   res.p = v.p;
00620   for(int i=0 ; i<v.get_nnz() ; i++)
00621     res.x.push_back(abs(v.x[i]));
00622   return res;
00623 }
00624 
00626 inline srvector absmin(const sivector& v) {
00627   srvector res(v.n, v.get_nnz());
00628   res.lb = v.lb;
00629   res.ub = v.ub;
00630   res.p = v.p;
00631   for(int i=0 ; i<v.get_nnz() ; i++)
00632     res.x.push_back(AbsMin(v.x[i]));
00633   res.dropzeros();
00634   return res;
00635 }
00636 
00638 inline srvector absmax(const sivector& v) {
00639   srvector res(v.n, v.get_nnz());
00640   res.lb = v.lb;
00641   res.ub = v.ub;
00642   res.p = v.p;
00643   for(int i=0 ; i<v.get_nnz() ; i++)
00644     res.x.push_back(AbsMax(v.x[i]));
00645   res.dropzeros();
00646   return res;
00647 }
00648 
00650 inline srvector mid(const sivector& v) {
00651   srvector res(v.n, v.get_nnz());
00652   res.lb = v.lb;
00653   res.ub = v.ub;
00654   res.p = v.p;
00655   for(int i=0 ; i<v.get_nnz() ; i++) {
00656     res.x.push_back(mid(v.x[i]));
00657   }
00658   return res;
00659 }
00660 
00662 inline srvector diam(const sivector& v) {
00663   srvector res(v.n, v.get_nnz());
00664   res.lb = v.lb;
00665   res.ub = v.ub;
00666   res.p = v.p;
00667   for(int i=0 ; i<v.get_nnz() ; i++)
00668     res.x.push_back(diam(v.x[i]));
00669   return res;
00670 }
00671 
00673 inline int VecLen(const sivector& v) {
00674   return v.n;
00675 }
00676 
00678 inline sivector Blow(const sivector& v, const real& eps) {
00679   sivector res(v);
00680   for(unsigned int i=0 ; i<v.x.size() ; i++)
00681     res.x[i] = Blow(v.x[i],eps);
00682   return res;
00683 }
00684 
00686 inline bool in (const sivector& v1, const sivector& v2) {
00687   for(int i=0 ; i<VecLen(v1) ; i++)
00688     if(!in(v1(i+Lb(v1)), v2(i+Lb(v2)))) return false;
00689   return true;
00690 }
00691 
00693 inline bool Zero(const sivector& v1) {
00694   for(int i=0 ; i<VecLen(v1) ; i++)
00695     if(v1(i+Lb(v1)) != 0.0) return false;
00696   return true;
00697 }
00698 
00700 inline sivector operator-(const sivector& v) {
00701   return sp_v_negative(v);
00702 }
00703 
00705 
00711 inline interval operator*(const sivector& v1, const ivector& v2) {
00712   return spf_vv_mult<sivector,ivector,interval,sparse_idot>(v1,v2);
00713 }
00714 
00716 
00722 inline interval operator*(const sivector& v1, const rvector& v2) {
00723   return spf_vv_mult<sivector,rvector,interval,sparse_idot>(v1,v2);
00724 }
00725 
00727 
00733 inline interval operator*(const srvector& v1, const ivector& v2) {
00734   return spf_vv_mult<srvector,ivector,interval,sparse_idot>(v1,v2);
00735 }
00736 
00738 
00744 inline interval operator*(const rvector& v1, const sivector& v2) {
00745   return fsp_vv_mult<rvector,sivector,interval,sparse_idot>(v1,v2);
00746 }
00747 
00749 
00755 inline interval operator*(const ivector& v1, const srvector& v2) {
00756   return fsp_vv_mult<ivector,srvector,interval,sparse_idot>(v1,v2);
00757 }
00758 
00760 
00766 inline interval operator*(const ivector& v1, const sivector& v2) {
00767   return fsp_vv_mult<ivector,sivector,interval,sparse_idot>(v1,v2);
00768 }
00769 
00771 
00777 inline interval operator*(const sivector& v1, const rvector_slice& v2) {
00778   return spf_vv_mult<sivector,rvector_slice,interval,sparse_idot>(v1,v2);
00779 }
00780 
00782 
00788 inline interval operator*(const sivector& v1, const ivector_slice& v2) {
00789   return spf_vv_mult<sivector,ivector_slice,interval,sparse_idot>(v1,v2);
00790 }
00791 
00793 
00799 inline interval operator*(const srvector& v1, const ivector_slice& v2) {
00800   return spf_vv_mult<srvector,ivector_slice,interval,sparse_idot>(v1,v2);
00801 }
00802 
00804 
00810 inline interval operator*(const ivector_slice& v1, const srvector& v2) {
00811   return fsp_vv_mult<ivector_slice,srvector,interval,sparse_idot>(v1,v2);
00812 }
00813 
00815 
00821 inline interval operator*(const ivector_slice& v1, const sivector& v2) {
00822   return fsp_vv_mult<ivector_slice,sivector,interval,sparse_idot>(v1,v2);
00823 }
00824 
00826 
00832 inline interval operator*(const rvector_slice& v1, const sivector& v2) {
00833   return fsp_vv_mult<rvector_slice,sivector,interval,sparse_idot>(v1,v2);
00834 }
00835 
00837 
00843 inline interval operator*(const sivector& v1, const srvector& v2) {
00844   return spsp_vv_mult<sivector,srvector,interval,sparse_idot>(v1,v2);
00845 }
00846 
00848 
00854 inline interval operator*(const srvector& v1, const sivector& v2) {
00855   return spsp_vv_mult<srvector,sivector,interval,sparse_idot>(v1,v2);
00856 }
00857 
00859 
00865 inline interval operator*(const sivector& v1, const sivector& v2) {
00866   return spsp_vv_mult<sivector,sivector,interval,sparse_idot>(v1,v2);
00867 }
00868 
00870 inline sivector operator*(const sivector& v, const real& s) {
00871   return sp_vs_mult<sivector,real,sivector>(v,s);
00872 }
00873 
00875 inline sivector operator*(const sivector& v, const interval& s) {
00876   return sp_vs_mult<sivector,interval,sivector>(v,s);
00877 }
00878 
00880 inline sivector operator*(const srvector& v, const interval& s) {
00881   return sp_vs_mult<srvector,interval,sivector>(v,s);
00882 }
00883 
00885 inline sivector operator/(const sivector& v, const real& s) {
00886   return sp_vs_div<sivector,real,sivector>(v,s);
00887 }
00888 
00890 inline sivector operator/(const sivector& v, const interval& s) {
00891   return sp_vs_div<sivector,interval,sivector>(v,s);
00892 }
00893 
00895 inline sivector operator/(const srvector& v, const interval& s) {
00896   return sp_vs_div<srvector,interval,sivector>(v,s);
00897 }
00898 
00900 inline sivector operator*(const real& s, const sivector& v) {
00901   return sp_sv_mult<real,sivector,sivector>(s,v);
00902 }
00903 
00905 inline sivector operator*(const interval& s, const sivector& v) {
00906   return sp_sv_mult<interval,sivector,sivector>(s,v);
00907 }
00908 
00910 inline sivector operator*(const interval& s, const srvector& v) {
00911   return sp_sv_mult<interval,srvector,sivector>(s,v);
00912 }
00913 
00915 inline ivector operator+(const ivector& v1, const srvector& v2) {
00916   return fsp_vv_add<ivector,srvector,ivector>(v1,v2);
00917 }
00918 
00920 inline ivector operator+(const rvector& v1, const sivector& v2) {
00921   return fsp_vv_add<rvector,sivector,ivector>(v1,v2);
00922 }
00923 
00925 inline ivector operator+(const ivector& v1, const sivector& v2) {
00926   return fsp_vv_add<ivector,sivector,ivector>(v1,v2);
00927 }
00928 
00930 inline ivector operator+(const sivector& v1, const rvector& v2) {
00931   return spf_vv_add<sivector,rvector,ivector>(v1,v2);
00932 }
00933 
00935 inline ivector operator+(const srvector& v1, const ivector& v2) {
00936   return spf_vv_add<srvector,ivector,ivector>(v1,v2);
00937 }
00938 
00940 inline ivector operator+(const sivector& v1, const ivector& v2) {
00941   return spf_vv_add<sivector,ivector,ivector>(v1,v2);
00942 }
00943 
00945 inline ivector operator+(const ivector_slice& v1, const srvector& v2) {
00946   return fsp_vv_add<ivector_slice,srvector,ivector>(v1,v2);
00947 }
00948 
00950 inline ivector operator+(const rvector_slice& v1, const sivector& v2) {
00951   return fsp_vv_add<rvector_slice,sivector,ivector>(v1,v2);
00952 }
00953 
00955 inline ivector operator+(const ivector_slice& v1, const sivector& v2) {
00956   return fsp_vv_add<ivector_slice,sivector,ivector>(v1,v2);
00957 }
00958 
00960 inline ivector operator+(const sivector& v1, const rvector_slice& v2) {
00961   return spf_vv_add<sivector,rvector_slice,ivector>(v1,v2);
00962 }
00963 
00965 inline ivector operator+(const srvector& v1, const ivector_slice& v2) {
00966   return spf_vv_add<srvector,ivector_slice,ivector>(v1,v2);
00967 }
00968 
00970 inline ivector operator+(const sivector& v1, const ivector_slice& v2) {
00971   return spf_vv_add<sivector,ivector_slice,ivector>(v1,v2);
00972 }
00973 
00975 inline sivector operator+(const sivector& v1, const srvector& v2) {
00976   return spsp_vv_add<sivector,srvector,sivector,interval>(v1,v2);
00977 }
00978 
00980 inline sivector operator+(const srvector& v1, const sivector& v2) {
00981   return spsp_vv_add<srvector,sivector,sivector,interval>(v1,v2);
00982 }
00983 
00985 inline sivector operator+(const sivector& v1, const sivector& v2) {
00986   return spsp_vv_add<sivector,sivector,sivector,interval>(v1,v2);
00987 }
00988 
00990 inline ivector operator-(const ivector& v1, const srvector& v2) {
00991   return fsp_vv_sub<ivector,srvector,ivector>(v1,v2);
00992 }
00993 
00995 inline ivector operator-(const rvector& v1, const sivector& v2) {
00996   return fsp_vv_sub<rvector,sivector,ivector>(v1,v2);
00997 }
00998 
01000 inline ivector operator-(const ivector& v1, const sivector& v2) {
01001   return fsp_vv_sub<ivector,sivector,ivector>(v1,v2);
01002 }
01003 
01005 inline ivector operator-(const sivector& v1, const rvector& v2) {
01006   return spf_vv_sub<sivector,rvector,ivector>(v1,v2);
01007 }
01008 
01010 inline ivector operator-(const srvector& v1, const ivector& v2) {
01011   return spf_vv_sub<srvector,ivector,ivector>(v1,v2);
01012 }
01013 
01015 inline ivector operator-(const sivector& v1, const ivector& v2) {
01016   return spf_vv_sub<sivector,ivector,ivector>(v1,v2);
01017 }
01018 
01020 inline ivector operator-(const ivector_slice& v1, const srvector& v2) {
01021   return fsp_vv_sub<ivector_slice,srvector,ivector>(v1,v2);
01022 }
01023 
01025 inline ivector operator-(const rvector_slice& v1, const sivector& v2) {
01026   return fsp_vv_sub<rvector_slice,sivector,ivector>(v1,v2);
01027 }
01028 
01030 inline ivector operator-(const ivector_slice& v1, const sivector& v2) {
01031   return fsp_vv_sub<ivector_slice,sivector,ivector>(v1,v2);
01032 }
01033 
01035 inline ivector operator-(const sivector& v1, const rvector_slice& v2) {
01036   return spf_vv_sub<sivector,rvector_slice,ivector>(v1,v2);
01037 }
01038 
01040 inline ivector operator-(const srvector& v1, const ivector_slice& v2) {
01041   return spf_vv_sub<srvector,ivector_slice,ivector>(v1,v2);
01042 }
01043 
01045 inline ivector operator-(const sivector& v1, const ivector_slice& v2) {
01046   return spf_vv_sub<sivector,ivector_slice,ivector>(v1,v2);
01047 }
01048 
01050 inline sivector operator-(const sivector& v1, const srvector& v2) {
01051   return spsp_vv_sub<sivector,srvector,sivector,interval>(v1,v2);
01052 }
01053 
01055 inline sivector operator-(const srvector& v1, const sivector& v2) {
01056   return spsp_vv_sub<srvector,sivector,sivector,interval>(v1,v2);
01057 }
01058 
01060 inline sivector operator-(const sivector& v1, const sivector& v2) {
01061   return spsp_vv_sub<sivector,sivector,sivector,interval>(v1,v2);
01062 }
01063 
01065 inline ivector operator|(const rvector& v1, const srvector& v2) {
01066   return fsp_vv_hull<rvector,srvector,ivector>(v1,v2);
01067 }
01068 
01070 inline ivector operator|(const srvector& v1, const rvector& v2) {
01071   return spf_vv_hull<srvector,rvector,ivector>(v1,v2);
01072 }
01073 
01075 inline ivector operator|(const rvector_slice& v1, const srvector& v2) {
01076   return fsp_vv_hull<rvector_slice,srvector,ivector>(v1,v2);
01077 }
01078 
01080 inline ivector operator|(const srvector& v1, const rvector_slice& v2) {
01081   return spf_vv_hull<srvector,rvector_slice,ivector>(v1,v2);
01082 }
01083 
01085 inline sivector operator|(const srvector& v1, const srvector& v2) {
01086   return spsp_vv_hull<srvector,srvector,sivector,interval>(v1,v2);
01087 }
01088 
01090 inline ivector operator|(const ivector& v1, const srvector& v2) {
01091   return fsp_vv_hull<ivector,srvector,ivector>(v1,v2);
01092 }
01093 
01095 inline ivector operator|(const rvector& v1, const sivector& v2) {
01096   return fsp_vv_hull<rvector,sivector,ivector>(v1,v2);
01097 }
01098 
01100 inline ivector operator|(const ivector& v1, const sivector& v2) {
01101   return fsp_vv_hull<ivector,sivector,ivector>(v1,v2);
01102 }
01103 
01105 inline ivector operator|(const sivector& v1, const rvector& v2) {
01106   return spf_vv_hull<sivector,rvector,ivector>(v1,v2);
01107 }
01108 
01110 inline ivector operator|(const srvector& v1, const ivector& v2) {
01111   return spf_vv_hull<srvector,ivector,ivector>(v1,v2);
01112 }
01113 
01115 inline ivector operator|(const sivector& v1, const ivector& v2) {
01116   return spf_vv_hull<sivector,ivector,ivector>(v1,v2);
01117 }
01118 
01120 inline ivector operator|(const ivector_slice& v1, const srvector& v2) {
01121   return fsp_vv_hull<ivector_slice,srvector,ivector>(v1,v2);
01122 }
01123 
01125 inline ivector operator|(const rvector_slice& v1, const sivector& v2) {
01126   return fsp_vv_hull<rvector_slice,sivector,ivector>(v1,v2);
01127 }
01128 
01130 inline ivector operator|(const ivector_slice& v1, const sivector& v2) {
01131   return fsp_vv_hull<ivector_slice,sivector,ivector>(v1,v2);
01132 }
01133 
01135 inline ivector operator|(const sivector& v1, const rvector_slice& v2) {
01136   return spf_vv_hull<sivector,rvector_slice,ivector>(v1,v2);
01137 }
01138 
01140 inline ivector operator|(const srvector& v1, const ivector_slice& v2) {
01141   return spf_vv_hull<srvector,ivector_slice,ivector>(v1,v2);
01142 }
01143 
01145 inline ivector operator|(const sivector& v1, const ivector_slice& v2) {
01146   return spf_vv_hull<sivector,ivector_slice,ivector>(v1,v2);
01147 }
01148 
01150 inline sivector operator|(const sivector& v1, const srvector& v2) {
01151   return spsp_vv_hull<sivector,srvector,sivector,interval>(v1,v2);
01152 }
01153 
01155 inline sivector operator|(const srvector& v1, const sivector& v2) {
01156   return spsp_vv_hull<srvector,sivector,sivector,interval>(v1,v2);
01157 }
01158 
01160 inline sivector operator|(const sivector& v1, const sivector& v2) {
01161   return spsp_vv_hull<sivector,sivector,sivector,interval>(v1,v2);
01162 }
01163 
01165 inline sivector operator&(const ivector& v1, const sivector& v2) {
01166   return fsp_vv_intersect<ivector,sivector,ivector>(v1,v2);
01167 }
01168 
01170 inline sivector operator&(const sivector& v1, const ivector& v2) {
01171   return spf_vv_intersect<sivector,ivector,ivector>(v1,v2);
01172 }
01173 
01175 inline sivector operator&(const ivector_slice& v1, const sivector& v2) {
01176   return fsp_vv_intersect<ivector_slice,sivector,ivector>(v1,v2);
01177 }
01178 
01180 inline sivector operator&(const sivector& v1, const ivector_slice& v2) {
01181   return spf_vv_intersect<sivector,ivector_slice,ivector>(v1,v2);
01182 }
01183 
01185 inline sivector operator&(const sivector& v1, const sivector& v2) {
01186   return spsp_vv_intersect<sivector,sivector,sivector,interval>(v1,v2);
01187 }
01188 
01189 inline ivector& ivector::operator+=(const srvector& v2) {
01190   return fsp_vv_addassign(*this,v2);
01191 }
01192 
01193 inline ivector& ivector::operator+=(const sivector& v2) {
01194   return fsp_vv_addassign(*this,v2);
01195 }
01196 
01197 inline ivector_slice& ivector_slice::operator+=(const srvector& v2) {
01198   return fsp_vv_addassign(*this,v2);
01199 }
01200 
01201 inline ivector_slice& ivector_slice::operator+=(const sivector& v2) {
01202   return fsp_vv_addassign(*this,v2);
01203 }
01204  
01205 inline ivector& ivector::operator-=(const srvector& v2) {
01206   return fsp_vv_subassign(*this,v2);
01207 }
01208 
01209 inline ivector& ivector::operator-=(const sivector& v2) {
01210   return fsp_vv_subassign(*this,v2);
01211 }
01212 
01213 inline ivector_slice& ivector_slice::operator-=(const srvector& v2) {
01214   return fsp_vv_subassign(*this,v2);
01215 }
01216 
01217 inline ivector_slice& ivector_slice::operator-=(const sivector& v2) {
01218   return fsp_vv_subassign(*this,v2);
01219 }
01220 
01221 inline ivector& ivector::operator|=(const srvector& v2) {
01222   return fsp_vv_hullassign(*this,v2);
01223 }
01224 
01225 inline ivector& ivector::operator|=(const sivector& v2) {
01226   return fsp_vv_hullassign(*this,v2);
01227 }
01228 
01229 inline ivector_slice& ivector_slice::operator|=(const srvector& v2) {
01230   return fsp_vv_hullassign(*this,v2);
01231 }
01232 
01233 inline ivector_slice& ivector_slice::operator|=(const sivector& v2) {
01234   return fsp_vv_hullassign(*this,v2);
01235 }
01236 
01237 inline ivector& ivector::operator&=(const sivector& v2) {
01238   return fsp_vv_intersectassign(*this,v2);
01239 }
01240 
01241 inline ivector_slice& ivector_slice::operator&=(const sivector& v2) {
01242   return fsp_vv_intersectassign(*this,v2);
01243 }
01244 
01246 
01249 inline bool operator==(const sivector& v1, const sivector& v2) {
01250   return spsp_vv_comp(v1,v2);
01251 }
01252 
01254 
01257 inline bool operator==(const sivector& v1, const srvector& v2) {
01258   return spsp_vv_comp(v1,v2);
01259 }
01260 
01262 
01265 inline bool operator==(const srvector& v1, const sivector& v2) {
01266   return spsp_vv_comp(v1,v2);
01267 }
01268 
01270 
01273 inline bool operator==(const sivector& v1, const rvector& v2) {
01274   return spf_vv_comp(v1,v2);
01275 }
01276 
01278 
01281 inline bool operator==(const srvector& v1, const ivector& v2) {
01282   return spf_vv_comp(v1,v2);
01283 }
01284 
01286 
01289 inline bool operator==(const sivector& v1, const ivector& v2) {
01290   return spf_vv_comp(v1,v2);
01291 }
01292 
01294 
01297 inline bool operator==(const ivector& v1, const srvector& v2) {
01298   return fsp_vv_comp(v1,v2);
01299 }
01300 
01302 
01305 inline bool operator==(const rvector& v1, const sivector& v2) {
01306   return fsp_vv_comp(v1,v2);
01307 }
01308 
01310 
01313 inline bool operator==(const ivector& v1, const sivector& v2) {
01314   return fsp_vv_comp(v1,v2);
01315 }
01316 
01318 
01321 inline bool operator==(const sivector& v1, const rvector_slice& v2) {
01322   return spf_vv_comp(v1,v2);
01323 }
01324 
01326 
01329 inline bool operator==(const srvector& v1, const ivector_slice& v2) {
01330   return spf_vv_comp(v1,v2);
01331 }
01332 
01334 
01337 inline bool operator==(const sivector& v1, const ivector_slice& v2) {
01338   return spf_vv_comp(v1,v2);
01339 }
01340 
01342 
01345 inline bool operator==(const ivector_slice& v1, const srvector& v2) {
01346   return fsp_vv_comp(v1,v2);
01347 }
01348 
01350 
01353 inline bool operator==(const rvector_slice& v1, const sivector& v2) {
01354   return fsp_vv_comp(v1,v2);
01355 }
01356 
01358 
01361 inline bool operator==(const ivector_slice& v1, const sivector& v2) {
01362   return fsp_vv_comp(v1,v2);
01363 }
01364 
01366 
01369 inline bool operator!=(const sivector& v1, const srvector& v2) {
01370   return !spsp_vv_comp(v1,v2);
01371 }
01372 
01374 
01377 inline bool operator!=(const srvector& v1, const sivector& v2) {
01378   return !spsp_vv_comp(v1,v2);
01379 }
01380 
01382 
01385 inline bool operator!=(const sivector& v1, const sivector& v2) {
01386   return !spsp_vv_comp(v1,v2);
01387 }
01388 
01390 
01393 inline bool operator!=(const sivector& v1, const rvector& v2) {
01394   return !spf_vv_comp(v1,v2);
01395 }
01396 
01398 
01401 inline bool operator!=(const srvector& v1, const ivector& v2) {
01402   return !spf_vv_comp(v1,v2);
01403 }
01404 
01406 
01409 inline bool operator!=(const sivector& v1, const ivector& v2) {
01410   return !spf_vv_comp(v1,v2);
01411 }
01412 
01414 
01417 inline bool operator!=(const ivector& v1, const srvector& v2) {
01418   return !fsp_vv_comp(v1,v2);
01419 }
01420 
01422 
01425 inline bool operator!=(const rvector& v1, const sivector& v2) {
01426   return !fsp_vv_comp(v1,v2);
01427 }
01428 
01430 
01433 inline bool operator!=(const ivector& v1, const sivector& v2) {
01434   return !fsp_vv_comp(v1,v2);
01435 }
01436 
01438 
01441 inline bool operator!=(const sivector& v1, const rvector_slice& v2) {
01442   return !spf_vv_comp(v1,v2);
01443 }
01444 
01446 
01449 inline bool operator!=(const srvector& v1, const ivector_slice& v2) {
01450   return !spf_vv_comp(v1,v2);
01451 }
01452 
01454 
01457 inline bool operator!=(const sivector& v1, const ivector_slice& v2) {
01458   return !spf_vv_comp(v1,v2);
01459 }
01460 
01462 
01465 inline bool operator!=(const ivector_slice& v1, const srvector& v2) {
01466   return !fsp_vv_comp(v1,v2);
01467 }
01468 
01470 
01473 inline bool operator!=(const rvector_slice& v1, const sivector& v2) {
01474   return !fsp_vv_comp(v1,v2);
01475 }
01476 
01478 
01481 inline bool operator!=(const ivector_slice& v1, const sivector& v2) {
01482   return !fsp_vv_comp(v1,v2);
01483 }
01484 
01486 
01489 inline bool operator<(const sivector& v1, const sivector& v2) {
01490   return spsp_vv_less<sivector,sivector,interval>(v1,v2);
01491 }
01492 
01494 
01497 inline bool operator<(const srvector& v1, const sivector& v2) {
01498   return spsp_vv_less<srvector,sivector,interval>(v1,v2);
01499 }
01500 
01502 
01505 inline bool operator<(const srvector& v1, const ivector& v2) {
01506   return spf_vv_less<srvector,ivector,interval>(v1,v2);
01507 }
01508 
01510 
01513 inline bool operator<(const sivector& v1, const ivector& v2) {
01514   return spf_vv_less<sivector,ivector,interval>(v1,v2);
01515 }
01516 
01518 
01521 inline bool operator<(const rvector& v1, const sivector& v2) {
01522   return fsp_vv_less<rvector,sivector,interval>(v1,v2);
01523 }
01524 
01526 
01529 inline bool operator<(const ivector& v1, const sivector& v2) {
01530   return fsp_vv_less<ivector,sivector,interval>(v1,v2);
01531 }
01532 
01534 
01537 inline bool operator<(const srvector& v1, const ivector_slice& v2) {
01538   return spf_vv_less<srvector,ivector_slice,interval>(v1,v2);
01539 }
01540 
01542 
01545 inline bool operator<(const sivector& v1, const ivector_slice& v2) {
01546   return spf_vv_less<sivector,ivector_slice,interval>(v1,v2);
01547 }
01548 
01550 
01553 inline bool operator<(const rvector_slice& v1, const sivector& v2) {
01554   return fsp_vv_less<rvector_slice,sivector,interval>(v1,v2);
01555 }
01556 
01558 
01561 inline bool operator<(const ivector_slice& v1, const sivector& v2) {
01562   return fsp_vv_less<ivector_slice,sivector,interval>(v1,v2);
01563 }
01564 
01566 
01569 inline bool operator<=(const sivector& v1, const sivector& v2) {
01570   return spsp_vv_leq<sivector,sivector,interval>(v1,v2);
01571 }
01572 
01574 
01577 inline bool operator<=(const srvector& v1, const sivector& v2) {
01578   return spsp_vv_leq<srvector,sivector,interval>(v1,v2);
01579 }
01580 
01582 
01585 inline bool operator<=(const srvector& v1, const ivector& v2) {
01586   return spf_vv_leq<srvector,ivector,interval>(v1,v2);
01587 }
01588 
01590 
01593 inline bool operator<=(const sivector& v1, const ivector& v2) {
01594   return spf_vv_leq<sivector,ivector,interval>(v1,v2);
01595 }
01596 
01598 
01601 inline bool operator<=(const rvector& v1, const sivector& v2) {
01602   return fsp_vv_leq<rvector,sivector,interval>(v1,v2);
01603 }
01604 
01606 
01609 inline bool operator<=(const ivector& v1, const sivector& v2) {
01610   return fsp_vv_leq<ivector,sivector,interval>(v1,v2);
01611 }
01612 
01614 
01617 inline bool operator<=(const srvector& v1, const ivector_slice& v2) {
01618   return spf_vv_leq<srvector,ivector_slice,interval>(v1,v2);
01619 }
01620 
01622 
01625 inline bool operator<=(const sivector& v1, const ivector_slice& v2) {
01626   return spf_vv_leq<sivector,ivector_slice,interval>(v1,v2);
01627 }
01628 
01630 
01633 inline bool operator<=(const rvector_slice& v1, const sivector& v2) {
01634   return fsp_vv_leq<rvector_slice,sivector,interval>(v1,v2);
01635 }
01636 
01638 
01641 inline bool operator<=(const ivector_slice& v1, const sivector& v2) {
01642   return fsp_vv_leq<ivector_slice,sivector,interval>(v1,v2);
01643 }
01644 
01646 
01649 inline bool operator>(const sivector& v1, const sivector& v2) {
01650   return spsp_vv_greater<sivector,sivector,interval>(v1,v2);
01651 }
01652 
01654 
01657 inline bool operator>(const sivector& v1, const srvector& v2) {
01658   return spsp_vv_greater<sivector,srvector,interval>(v1,v2);
01659 }
01660 
01662 
01665 inline bool operator>(const sivector& v1, const rvector& v2) {
01666   return spf_vv_greater<sivector,rvector,interval>(v1,v2);
01667 }
01668 
01670 
01673 inline bool operator>(const sivector& v1, const ivector& v2) {
01674   return spf_vv_greater<sivector,ivector,interval>(v1,v2);
01675 }
01676 
01678 
01681 inline bool operator>(const ivector& v1, const srvector& v2) {
01682   return fsp_vv_greater<ivector,srvector,interval>(v1,v2);
01683 }
01684 
01686 
01689 inline bool operator>(const ivector& v1, const sivector& v2) {
01690   return fsp_vv_greater<ivector,sivector,interval>(v1,v2);
01691 }
01692 
01694 
01697 inline bool operator>(const sivector& v1, const rvector_slice& v2) {
01698   return spf_vv_greater<sivector,rvector_slice,interval>(v1,v2);
01699 }
01700 
01702 
01705 inline bool operator>(const sivector& v1, const ivector_slice& v2) {
01706   return spf_vv_greater<sivector,ivector_slice,interval>(v1,v2);
01707 }
01708 
01710 
01713 inline bool operator>(const ivector_slice& v1, const srvector& v2) {
01714   return fsp_vv_greater<ivector_slice,srvector,interval>(v1,v2);
01715 }
01716 
01718 
01721 inline bool operator>(const ivector_slice& v1, const sivector& v2) {
01722   return fsp_vv_greater<ivector_slice,sivector,interval>(v1,v2);
01723 }
01724 
01726 
01729 inline bool operator>=(const sivector& v1, const sivector& v2) {
01730   return spsp_vv_geq<sivector,sivector,interval>(v1,v2);
01731 }
01732 
01734 
01737 inline bool operator>=(const sivector& v1, const srvector& v2) {
01738   return spsp_vv_geq<sivector,srvector,interval>(v1,v2);
01739 }
01740 
01742 
01745 inline bool operator>=(const sivector& v1, const rvector& v2) {
01746   return spf_vv_geq<sivector,rvector,interval>(v1,v2);
01747 }
01748 
01750 
01753 inline bool operator>=(const sivector& v1, const ivector& v2) {
01754   return spf_vv_geq<sivector,ivector,interval>(v1,v2);
01755 }
01756 
01758 
01761 inline bool operator>=(const ivector& v1, const srvector& v2) {
01762   return fsp_vv_geq<ivector,srvector,interval>(v1,v2);
01763 }
01764 
01766 
01769 inline bool operator>=(const ivector& v1, const sivector& v2) {
01770   return fsp_vv_geq<ivector,sivector,interval>(v1,v2);
01771 }
01772 
01774 
01777 inline bool operator>=(const sivector& v1, const rvector_slice& v2) {
01778   return spf_vv_geq<sivector,rvector_slice,interval>(v1,v2);
01779 }
01780 
01782 
01785 inline bool operator>=(const sivector& v1, const ivector_slice& v2) {
01786   return spf_vv_geq<sivector,ivector_slice,interval>(v1,v2);
01787 }
01788 
01790 
01793 inline bool operator>=(const ivector_slice& v1, const srvector& v2) {
01794   return fsp_vv_geq<ivector_slice,srvector,interval>(v1,v2);
01795 }
01796 
01798 
01801 inline bool operator>=(const ivector_slice& v1, const sivector& v2) {
01802   return fsp_vv_geq<ivector_slice,sivector,interval>(v1,v2);
01803 }
01804 
01806 
01811 inline std::ostream& operator<<(std::ostream& os, const sivector& v) {
01812   return sp_v_output<sivector,interval>(os,v);
01813 }
01814 
01816 
01821 inline std::istream& operator>>(std::istream& is, sivector& v) {
01822   return sp_v_input<sivector,interval>(is,v);
01823 }
01824 
01826 
01831 class sivector_slice {
01832   private:
01833     std::vector<int>& p;
01834     std::vector<interval>& x;
01835     sivector& orig;
01836     int start,end;
01837     int lb;
01838     int ub;
01839     int n;
01840     int nnz;
01841     int offset;
01842 
01844 
01848     sivector_slice(sivector& v, int l, int u) : p(v.p), x(v.x), orig(v), lb(l), ub(u), n(u-l+1) {
01849       int i;
01850 
01851       for(i=0 ; i<v.get_nnz() && p[i]<lb-v.lb ; i++);
01852 
01853       start = i;
01854 
01855       for(i=start ; i<v.get_nnz() && p[i]<=ub-v.lb ; i++);
01856 
01857       end = i-1;
01858 
01859       nnz = end-start+1;
01860       offset = lb-v.lb;
01861     }
01862 
01863   public:
01864 
01866     int get_nnz() const {
01867       return nnz;
01868     }
01869 
01871     real density() const {
01872       return (double)nnz/n;
01873     }
01874 
01876 
01880     interval& operator[](const int i) {
01881 #if(CXSC_INDEX_CHECK)
01882       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector_slice::operator[](const int)"));
01883 #endif
01884       int k;
01885 
01886       for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
01887         if(p[k]-offset == i-lb) 
01888           return x[k];
01889       }
01890 
01891       p.insert(p.begin() + k, i-lb);
01892       x.insert(x.begin() + k, interval(0.0));
01893       end++;
01894 
01895       return x[k];
01896     }
01897 
01899 
01903     interval operator[](const int i) const {
01904 #if(CXSC_INDEX_CHECK)
01905       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector_slice::operator[](const int)"));
01906 #endif
01907       return (*this)(i);
01908     }
01909 
01911 
01915     const interval operator()(const int i) const {
01916 #if(CXSC_INDEX_CHECK)
01917       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("srvector_slice::operator()(const int)"));
01918 #endif
01919       interval r(0.0);
01920 
01921       for(int k=start ; k<end && p[k]-start<=i-lb ; k++) {
01922         if(p[k]-start == i-lb) 
01923           r = x[k];
01924       }
01925 
01926       return r; 
01927     }
01928 
01930     sivector_slice& operator=(const real& v) {
01931       return sl_vs_assign<sivector_slice,real,interval,std::vector<interval>::iterator>(*this,v);
01932     }
01933 
01935     sivector_slice& operator=(const interval& v) {
01936       return sl_vs_assign<sivector_slice,interval,interval,std::vector<interval>::iterator>(*this,v);
01937     }
01938 
01940     sivector_slice& operator=(const srvector_slice& v) {
01941       return slsl_vv_assign<sivector_slice,srvector_slice,interval,std::vector<interval>::iterator>(*this,v);
01942     }
01943 
01945     sivector_slice& operator=(const sivector_slice& v) {
01946       return slsl_vv_assign<sivector_slice,sivector_slice,interval,std::vector<interval>::iterator>(*this,v);
01947     }
01948 
01950     sivector_slice& operator=(const srvector& v) {
01951       return slsp_vv_assign<sivector_slice,srvector,interval,std::vector<interval>::iterator>(*this,v);
01952     }
01953 
01955     sivector_slice& operator=(const sivector& v) {
01956       return slsp_vv_assign<sivector_slice,sivector,interval,std::vector<interval>::iterator>(*this,v);
01957     }
01958 
01960     sivector_slice& operator=(const rvector& v) {
01961       return slf_vv_assign<sivector_slice,rvector,interval,std::vector<interval>::iterator>(*this,v);
01962     }
01963 
01965     sivector_slice& operator=(const ivector& v) {
01966       return slf_vv_assign<sivector_slice,ivector,interval,std::vector<interval>::iterator>(*this,v);
01967     }
01968 
01970     sivector_slice& operator=(const rvector_slice& v) {
01971       return slf_vv_assign<sivector_slice,rvector_slice,interval,std::vector<interval>::iterator>(*this,v);
01972     }
01973 
01975     sivector_slice& operator=(const ivector_slice& v) {
01976       return slf_vv_assign<sivector_slice,ivector_slice,interval,std::vector<interval>::iterator>(*this,v);
01977     }
01978 
01980     sivector_slice& operator*=(const real& s) {
01981       return sl_vs_multassign(*this,s);
01982     }
01983 
01985     sivector_slice& operator*=(const interval& s) {
01986       return sl_vs_multassign(*this,s);
01987     }
01988 
01990     sivector_slice& operator/=(const real& s) {
01991       return sl_vs_divassign(*this,s);
01992     }
01993 
01995     sivector_slice& operator/=(const interval& s) {
01996       return sl_vs_divassign(*this,s);
01997     }
01998 
02000     sivector_slice& operator+=(const rvector& v) {
02001       return slf_vv_addassign<sivector_slice,rvector,interval>(*this,v);
02002     }
02003 
02005     sivector_slice& operator+=(const ivector& v) {
02006       return slf_vv_addassign<sivector_slice,ivector,interval>(*this,v);
02007     }
02008 
02010     sivector_slice& operator+=(const rvector_slice& v) {
02011       return slf_vv_addassign<sivector_slice,rvector_slice,interval>(*this,v);
02012     }
02013 
02015     sivector_slice& operator+=(const ivector_slice& v) {
02016       return slf_vv_addassign<sivector_slice,ivector_slice,interval>(*this,v);
02017     }
02018 
02020     sivector_slice& operator+=(const srvector& v) {
02021       return slsp_vv_addassign(*this,v);
02022     }
02023 
02025     sivector_slice& operator+=(const sivector& v) {
02026       return slsp_vv_addassign(*this,v);
02027     }
02028 
02030     sivector_slice& operator+=(const srvector_slice& v) {
02031       return slsl_vv_addassign(*this,v);
02032     }
02033 
02035     sivector_slice& operator+=(const sivector_slice& v) {
02036       return slsl_vv_addassign(*this,v);
02037     }
02038 
02040     sivector_slice& operator-=(const rvector& v) {
02041       return slf_vv_subassign<sivector_slice,rvector,interval>(*this,v);
02042     }
02043 
02045     sivector_slice& operator-=(const ivector& v) {
02046       return slf_vv_subassign<sivector_slice,ivector,interval>(*this,v);
02047     }
02048 
02050     sivector_slice& operator-=(const rvector_slice& v) {
02051       return slf_vv_subassign<sivector_slice,rvector_slice,interval>(*this,v);
02052     }
02053 
02055     sivector_slice& operator-=(const ivector_slice& v) {
02056       return slf_vv_subassign<sivector_slice,ivector_slice,interval>(*this,v);
02057     }
02058 
02060     sivector_slice& operator-=(const srvector& v) {
02061       return slsp_vv_subassign(*this,v);
02062     }
02063 
02065     sivector_slice& operator-=(const sivector& v) {
02066       return slsp_vv_subassign(*this,v);
02067     }
02068 
02070     sivector_slice& operator-=(const srvector_slice& v) {
02071       return slsl_vv_subassign(*this,v);
02072     }
02073 
02075     sivector_slice& operator-=(const sivector_slice& v) {
02076       return slsl_vv_subassign(*this,v);
02077     }
02078 
02080     sivector_slice& operator|=(const rvector& v) {
02081       return slf_vv_hullassign<sivector_slice,rvector,interval>(*this,v);
02082     }
02083 
02085     sivector_slice& operator|=(const ivector& v) {
02086       return slf_vv_hullassign<sivector_slice,ivector,interval>(*this,v);
02087     }
02088 
02090     sivector_slice& operator|=(const rvector_slice& v) {
02091       return slf_vv_hullassign<sivector_slice,rvector_slice,interval>(*this,v);
02092     }
02093 
02095     sivector_slice& operator|=(const ivector_slice& v) {
02096       return slf_vv_hullassign<sivector_slice,ivector_slice,interval>(*this,v);
02097     }
02098 
02100     sivector_slice& operator|=(const srvector& v) {
02101       return slsp_vv_hullassign(*this,v);
02102     }
02103 
02105     sivector_slice& operator|=(const sivector& v) {
02106       return slsp_vv_hullassign(*this,v);
02107     }
02108 
02110     sivector_slice& operator|=(const srvector_slice& v) {
02111       return slsl_vv_hullassign(*this,v);
02112     }
02113 
02115     sivector_slice& operator|=(const sivector_slice& v) {
02116       return slsl_vv_hullassign(*this,v);
02117     }
02118 
02120     sivector_slice& operator&=(const ivector& v) {
02121       return slf_vv_intersectassign<sivector_slice,ivector,interval>(*this,v);
02122     }
02123 
02125     sivector_slice& operator&=(const ivector_slice& v) {
02126       return slf_vv_intersectassign<sivector_slice,ivector_slice,interval>(*this,v);
02127     }
02128 
02130     sivector_slice& operator&=(const sivector& v) {
02131       return slsp_vv_intersectassign(*this,v);
02132     }
02133 
02135     sivector_slice& operator&=(const sivector_slice& v) {
02136       return slsl_vv_intersectassign(*this,v);
02137     }
02138 
02139     friend int Lb(const sivector_slice&);
02140     friend int Ub(const sivector_slice&);
02141     friend srvector Inf(const sivector_slice&);
02142     friend srvector Sup(const sivector_slice&);
02143     friend sivector abs(const sivector_slice&);
02144     friend srvector mid(const sivector_slice&);
02145     friend srvector diam(const sivector_slice&);
02146     friend int VecLen(const sivector_slice&);
02147 
02148 //     friend srvector operator*(const srmatrix&, const srvector_slice&); //ok
02149 //     friend srvector operator*(const srmatrix_slice&, const srvector_slice&); //ok
02150 
02151     friend class srvector;
02152     friend class sivector;
02153     friend class scivector;
02154     friend class ivector;
02155     friend class ivector_slice;
02156     friend class civector;
02157     friend class civector_slice;
02158 
02159 #include "vector_friend_declarations.inl"
02160 };
02161 
02162 inline ivector::ivector(const srvector_slice& v) {
02163   l = v.lb;
02164   u = v.ub;
02165   size = v.n;
02166   dat = new interval[v.n];
02167   for(int i=0 ; i<v.n ; i++)
02168     dat[i] = 0.0;
02169   for(int i=v.start ; i<=v.end ; i++)
02170     dat[v.p[i]] = v.x[i];
02171 }
02172 
02173 inline ivector::ivector(const sivector_slice& v) {
02174   l = v.lb;
02175   u = v.ub;
02176   size = v.n;
02177   dat = new interval[v.n];
02178   for(int i=0 ; i<v.n ; i++)
02179     dat[i] = 0.0;
02180   for(int i=v.start ; i<=v.end ; i++)
02181     dat[v.p[i]] = v.x[i];
02182 }
02183 
02184 inline ivector_slice& ivector_slice::operator=(const srvector& v) {
02185   *this = rvector(v);
02186   return *this;
02187 }
02188 
02189 inline ivector_slice& ivector_slice::operator=(const srvector_slice& v) {
02190   *this = rvector(v);
02191   return *this;
02192 }
02193 
02194 inline ivector_slice& ivector_slice::operator=(const sivector& v) {
02195   *this = ivector(v);
02196   return *this;
02197 }
02198 
02199 inline ivector_slice& ivector_slice::operator=(const sivector_slice& v) {
02200   *this = ivector(v);
02201   return *this;
02202 }
02203 
02204 inline sivector::sivector(const srvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n)  {
02205   p.reserve(s.nnz);
02206   x.reserve(s.nnz);
02207 
02208   for(int i=s.start ; i<=s.end ; i++) {
02209     p.push_back(s.p[i]-s.offset);
02210     x.push_back(interval(s.x[i]));
02211   }
02212 
02213 }
02214 
02215 inline sivector::sivector(const sivector_slice& s) : lb(s.lb), ub(s.ub), n(s.n) {
02216   p.reserve(s.nnz);
02217   x.reserve(s.nnz);
02218 
02219   for(int i=s.start ; i<=s.end ; i++) {
02220     p.push_back(s.p[i]-s.offset);
02221     x.push_back(s.x[i]);
02222   }
02223 
02224 }
02225 
02226 inline sivector& sivector::operator=(const srvector_slice& v) {
02227   return spsl_vv_assign<sivector,srvector_slice,interval>(*this,v);
02228 }
02229 
02230 inline sivector& sivector::operator=(const sivector_slice& v) {
02231   return spsl_vv_assign<sivector,sivector_slice,interval>(*this,v);
02232 }
02233 
02234 inline sivector_slice sivector::operator()(const int i, const int j) {
02235 #if(CXSC_INDEX_CHECK)
02236   if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC("sivector::operator()(const int,const int)"));
02237 #endif
02238   return sivector_slice(*this,i,j);
02239 }
02240 
02242 inline sivector operator-(const sivector_slice& v) {
02243   return sl_v_negative<sivector_slice,sivector>(v);
02244 }
02245 
02247 inline int Lb(const sivector_slice& v) {
02248   return v.lb;
02249 }
02250 
02252 inline int Ub(const sivector_slice& v) {
02253   return v.ub;
02254 }
02255 
02257 inline srvector Inf(const sivector_slice& v) {
02258   return Inf(sivector(v));
02259 }
02260 
02262 inline srvector Sup(const sivector_slice& v) {
02263   return Sup(sivector(v));
02264 }
02265 
02267 inline sivector abs(const sivector_slice& v) {
02268   sivector res(v.n, v.nnz);
02269   res.lb = v.lb;
02270   res.ub = v.ub;
02271   res.p = v.p;
02272   for(int i=v.start ; i<=v.end ; i++)
02273     res.x.push_back(abs(v.x[i]));
02274   return res;
02275 }
02276 
02278 inline srvector mid(const sivector_slice& v) {
02279   srvector res(v.n, v.nnz);
02280   res.lb = v.lb;
02281   res.ub = v.ub;
02282   res.p = v.p;
02283   for(int i=v.start ; i<=v.end ; i++)
02284     res.x.push_back(mid(v.x[i]));
02285   return res;
02286 }
02287 
02289 inline srvector diam(const sivector_slice& v) {
02290   srvector res(v.n, v.nnz);
02291   res.lb = v.lb;
02292   res.ub = v.ub;
02293   res.p = v.p;
02294   for(int i=v.start ; i<v.end ; i++)
02295     res.x.push_back(diam(v.x[i]));
02296   return res;
02297 }
02298 
02300 inline int VecLen(const sivector_slice& v) {
02301   return v.n;
02302 }
02303 
02305 
02311 inline interval operator*(const sivector_slice& v1, const rvector& v2) {
02312   return slf_vv_mult<sivector_slice,rvector,interval,sparse_idot>(v1,v2);
02313 }
02314 
02316 
02322 inline interval operator*(const srvector_slice& v1, const ivector& v2) {
02323   return slf_vv_mult<srvector_slice,ivector,interval,sparse_idot>(v1,v2);
02324 }
02325 
02327 
02333 inline interval operator*(const sivector_slice& v1, const ivector& v2) {
02334   return slf_vv_mult<sivector_slice,ivector,interval,sparse_idot>(v1,v2);
02335 }
02336 
02338 
02344 inline interval operator*(const ivector& v1, const srvector_slice& v2) {
02345   return fsl_vv_mult<ivector,srvector_slice,interval,sparse_idot>(v1,v2);
02346 }
02347 
02349 
02355 inline interval operator*(const rvector& v1, const sivector_slice& v2) {
02356   return fsl_vv_mult<rvector,sivector_slice,interval,sparse_idot>(v1,v2);
02357 }
02358 
02360 
02366 inline interval operator*(const ivector& v1, const sivector_slice& v2) {
02367   return fsl_vv_mult<ivector,sivector_slice,interval,sparse_idot>(v1,v2);
02368 }
02369 
02371 
02377 inline interval operator*(const sivector_slice& v1, const rvector_slice& v2) {
02378   return slf_vv_mult<sivector_slice,rvector_slice,interval,sparse_idot>(v1,v2);
02379 }
02380 
02382 
02388 inline interval operator*(const srvector_slice& v1, const ivector_slice& v2) {
02389   return slf_vv_mult<srvector_slice,ivector_slice,interval,sparse_idot>(v1,v2);
02390 }
02391 
02393 
02399 inline interval operator*(const sivector_slice& v1, const ivector_slice& v2) {
02400   return slf_vv_mult<sivector_slice,ivector_slice,interval,sparse_idot>(v1,v2);
02401 }
02402 
02404 
02410 inline interval operator*(const ivector_slice& v1, const srvector_slice& v2) {
02411   return fsl_vv_mult<ivector_slice,srvector_slice,interval,sparse_idot>(v1,v2);
02412 }
02413 
02415 
02421 inline interval operator*(const rvector_slice& v1, const sivector_slice& v2) {
02422   return fsl_vv_mult<rvector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
02423 }
02424 
02426 
02432 inline interval operator*(const ivector_slice& v1, const sivector_slice& v2) {
02433   return fsl_vv_mult<ivector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
02434 }
02435 
02437 
02443 inline interval operator*(const sivector& v1, const srvector_slice& v2) {
02444   return spsl_vv_mult<sivector,srvector_slice,interval,sparse_idot>(v1,v2);
02445 }
02446 
02448 
02454 inline interval operator*(const srvector& v1, const sivector_slice& v2) {
02455   return spsl_vv_mult<srvector,sivector_slice,interval,sparse_idot>(v1,v2);
02456 }
02457 
02459 
02465 inline interval operator*(const sivector& v1, const sivector_slice& v2) {
02466   return spsl_vv_mult<sivector,sivector_slice,interval,sparse_idot>(v1,v2);
02467 }
02468 
02470 
02476 inline interval operator*(const sivector_slice& v1, const srvector& v2) {
02477   return slsp_vv_mult<sivector_slice,srvector,interval,sparse_idot>(v1,v2);
02478 }
02479 
02481 
02487 inline interval operator*(const srvector_slice& v1, const sivector& v2) {
02488   return slsp_vv_mult<srvector_slice,sivector,interval,sparse_idot>(v1,v2);
02489 }
02490 
02492 
02498 inline interval operator*(const sivector_slice& v1, const sivector& v2) {
02499   return slsp_vv_mult<sivector_slice,sivector,interval,sparse_idot>(v1,v2);
02500 }
02501 
02503 
02509 inline interval operator*(const sivector_slice& v1, const srvector_slice& v2) {
02510   return slsl_vv_mult<sivector_slice,srvector_slice,interval,sparse_idot>(v1,v2);
02511 }
02512 
02514 
02520 inline interval operator*(const srvector_slice& v1, const sivector_slice& v2) {
02521   return slsl_vv_mult<srvector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
02522 }
02523 
02525 
02531 inline interval operator*(const sivector_slice& v1, const sivector_slice& v2) {
02532   return slsl_vv_mult<sivector_slice,sivector_slice,interval,sparse_idot>(v1,v2);
02533 }
02534 
02536 inline sivector operator*(const sivector_slice& v, const real& s) {
02537   return sp_vs_mult<sivector_slice,real,sivector>(v,s);
02538 }
02539 
02541 inline sivector operator*(const sivector_slice& v, const interval& s) {
02542   return sp_vs_mult<sivector_slice,interval,sivector>(v,s);
02543 }
02544 
02546 inline sivector operator*(const srvector_slice& v, const interval& s) {
02547   return sp_vs_mult<srvector_slice,interval,sivector>(v,s);
02548 }
02549 
02551 inline sivector operator/(const sivector_slice& v, const real& s) {
02552   return sp_vs_div<sivector_slice,real,sivector>(v,s);
02553 }
02554 
02556 inline sivector operator/(const sivector_slice& v, const interval& s) {
02557   return sp_vs_div<sivector_slice,interval,sivector>(v,s);
02558 }
02559 
02561 inline sivector operator/(const srvector_slice& v, const interval& s) {
02562   return sp_vs_div<srvector_slice,interval,sivector>(v,s);
02563 }
02564 
02566 inline sivector operator*(const real& s, const sivector_slice& v) {
02567   return sp_sv_mult<real,sivector_slice,sivector>(s,v);
02568 }
02569 
02571 inline sivector operator*(const interval& s, const sivector_slice& v) {
02572   return sp_sv_mult<interval,sivector_slice,sivector>(s,v);
02573 }
02574 
02576 inline sivector operator*(const interval& s, const srvector_slice& v) {
02577   return sp_sv_mult<interval,srvector_slice,sivector>(s,v);
02578 }
02579 
02581 inline ivector operator+(const ivector& v1, const srvector_slice& v2) {
02582   return fsl_vv_add<ivector,srvector_slice,ivector>(v1,v2);
02583 }
02584 
02586 inline ivector operator+(const rvector& v1, const sivector_slice& v2) {
02587   return fsl_vv_add<rvector,sivector_slice,ivector>(v1,v2);
02588 }
02589 
02591 inline ivector operator+(const ivector& v1, const sivector_slice& v2) {
02592   return fsl_vv_add<ivector,sivector_slice,ivector>(v1,v2);
02593 }
02594 
02596 inline ivector operator+(const sivector_slice& v1, const rvector& v2) {
02597   return slf_vv_add<sivector_slice,rvector,ivector>(v1,v2);
02598 }
02599 
02601 inline ivector operator+(const srvector_slice& v1, const ivector& v2) {
02602   return slf_vv_add<srvector_slice,ivector,ivector>(v1,v2);
02603 }
02604 
02606 inline ivector operator+(const sivector_slice& v1, const ivector& v2) {
02607   return slf_vv_add<sivector_slice,ivector,ivector>(v1,v2);
02608 }
02609 
02611 inline ivector operator+(const ivector_slice& v1, const srvector_slice& v2) {
02612   return fsl_vv_add<ivector_slice,srvector_slice,ivector>(v1,v2);
02613 }
02614 
02616 inline ivector operator+(const rvector_slice& v1, const sivector_slice& v2) {
02617   return fsl_vv_add<rvector_slice,sivector_slice,ivector>(v1,v2);
02618 }
02619 
02621 inline ivector operator+(const ivector_slice& v1, const sivector_slice& v2) {
02622   return fsl_vv_add<ivector_slice,sivector_slice,ivector>(v1,v2);
02623 }
02624 
02626 inline ivector operator+(const sivector_slice& v1, const rvector_slice& v2) {
02627   return slf_vv_add<sivector_slice,rvector_slice,ivector>(v1,v2);
02628 }
02629 
02631 inline ivector operator+(const srvector_slice& v1, const ivector_slice& v2) {
02632   return slf_vv_add<srvector_slice,ivector_slice,ivector>(v1,v2);
02633 }
02634 
02636 inline ivector operator+(const sivector_slice& v1, const ivector_slice& v2) {
02637   return slf_vv_add<sivector_slice,ivector_slice,ivector>(v1,v2);
02638 }
02639 
02641 inline sivector operator+(const sivector_slice& v1, const srvector_slice& v2) {
02642   return slsl_vv_add<sivector_slice,srvector_slice,sivector,interval>(v1,v2);
02643 }
02644 
02646 inline sivector operator+(const srvector_slice& v1, const sivector_slice& v2) {
02647   return slsl_vv_add<srvector_slice,sivector_slice,sivector,interval>(v1,v2);
02648 }
02649 
02651 inline sivector operator+(const sivector_slice& v1, const sivector_slice& v2) {
02652   return slsl_vv_add<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
02653 }
02654 
02656 inline sivector operator+(const sivector& v1, const srvector_slice& v2) {
02657   return spsl_vv_add<sivector,srvector_slice,sivector,interval>(v1,v2);
02658 }
02659 
02661 inline sivector operator+(const srvector& v1, const sivector_slice& v2) {
02662   return spsl_vv_add<srvector,sivector_slice,sivector,interval>(v1,v2);
02663 }
02664 
02666 inline sivector operator+(const sivector& v1, const sivector_slice& v2) {
02667   return spsl_vv_add<sivector,sivector_slice,sivector,interval>(v1,v2);
02668 }
02669 
02671 inline sivector operator+(const sivector_slice& v1, const srvector& v2) {
02672   return slsp_vv_add<sivector_slice,srvector,sivector,interval>(v1,v2);
02673 }
02674 
02676 inline sivector operator+(const srvector_slice& v1, const sivector& v2) {
02677   return slsp_vv_add<srvector_slice,sivector,sivector,interval>(v1,v2);
02678 }
02679 
02681 inline sivector operator+(const sivector_slice& v1, const sivector& v2) {
02682   return slsp_vv_add<sivector_slice,sivector,sivector,interval>(v1,v2);
02683 }
02684 
02686 inline ivector operator-(const ivector& v1, const srvector_slice& v2) {
02687   return fsl_vv_sub<ivector,srvector_slice,ivector>(v1,v2);
02688 }
02689 
02691 inline ivector operator-(const rvector& v1, const sivector_slice& v2) {
02692   return fsl_vv_sub<rvector,sivector_slice,ivector>(v1,v2);
02693 }
02694 
02696 inline ivector operator-(const ivector& v1, const sivector_slice& v2) {
02697   return fsl_vv_sub<ivector,sivector_slice,ivector>(v1,v2);
02698 }
02699 
02701 inline ivector operator-(const sivector_slice& v1, const rvector& v2) {
02702   return slf_vv_sub<sivector_slice,rvector,ivector>(v1,v2);
02703 }
02704 
02706 inline ivector operator-(const srvector_slice& v1, const ivector& v2) {
02707   return slf_vv_sub<srvector_slice,ivector,ivector>(v1,v2);
02708 }
02709 
02711 inline ivector operator-(const sivector_slice& v1, const ivector& v2) {
02712   return slf_vv_sub<sivector_slice,ivector,ivector>(v1,v2);
02713 }
02714 
02716 inline ivector operator-(const ivector_slice& v1, const srvector_slice& v2) {
02717   return fsl_vv_sub<ivector_slice,srvector_slice,ivector>(v1,v2);
02718 }
02719 
02721 inline ivector operator-(const rvector_slice& v1, const sivector_slice& v2) {
02722   return fsl_vv_sub<rvector_slice,sivector_slice,ivector>(v1,v2);
02723 }
02724 
02726 inline ivector operator-(const ivector_slice& v1, const sivector_slice& v2) {
02727   return fsl_vv_sub<ivector_slice,sivector_slice,ivector>(v1,v2);
02728 }
02729 
02731 inline ivector operator-(const sivector_slice& v1, const rvector_slice& v2) {
02732   return slf_vv_sub<sivector_slice,rvector_slice,ivector>(v1,v2);
02733 }
02734 
02736 inline ivector operator-(const srvector_slice& v1, const ivector_slice& v2) {
02737   return slf_vv_sub<srvector_slice,ivector_slice,ivector>(v1,v2);
02738 }
02739 
02741 inline ivector operator-(const sivector_slice& v1, const ivector_slice& v2) {
02742   return slf_vv_sub<sivector_slice,ivector_slice,ivector>(v1,v2);
02743 }
02744 
02746 inline sivector operator-(const sivector_slice& v1, const srvector_slice& v2) {
02747   return slsl_vv_sub<sivector_slice,srvector_slice,sivector,interval>(v1,v2);
02748 }
02749 
02751 inline sivector operator-(const srvector_slice& v1, const sivector_slice& v2) {
02752   return slsl_vv_sub<srvector_slice,sivector_slice,sivector,interval>(v1,v2);
02753 }
02754 
02756 inline sivector operator-(const sivector_slice& v1, const sivector_slice& v2) {
02757   return slsl_vv_sub<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
02758 }
02759 
02761 inline sivector operator-(const sivector& v1, const srvector_slice& v2) {
02762   return spsl_vv_sub<sivector,srvector_slice,sivector,interval>(v1,v2);
02763 }
02764 
02766 inline sivector operator-(const srvector& v1, const sivector_slice& v2) {
02767   return spsl_vv_sub<srvector,sivector_slice,sivector,interval>(v1,v2);
02768 }
02769 
02771 inline sivector operator-(const sivector& v1, const sivector_slice& v2) {
02772   return spsl_vv_sub<sivector,sivector_slice,sivector,interval>(v1,v2);
02773 }
02774 
02776 inline sivector operator-(const sivector_slice& v1, const srvector& v2) {
02777   return slsp_vv_sub<sivector_slice,srvector,sivector,interval>(v1,v2);
02778 }
02779 
02781 inline sivector operator-(const srvector_slice& v1, const sivector& v2) {
02782   return slsp_vv_sub<srvector_slice,sivector,sivector,interval>(v1,v2);
02783 }
02784 
02786 inline sivector operator-(const sivector_slice& v1, const sivector& v2) {
02787   return slsp_vv_sub<sivector_slice,sivector,sivector,interval>(v1,v2);
02788 }
02789 
02791 inline ivector operator|(const rvector& v1, const srvector_slice& v2) {
02792   return fsl_vv_hull<rvector,srvector_slice,ivector>(v1,v2);
02793 }
02794 
02796 inline ivector operator|(const srvector_slice& v1, const rvector& v2) {
02797   return slf_vv_hull<srvector_slice,rvector,ivector>(v1,v2);
02798 }
02799 
02801 inline ivector operator|(const rvector_slice& v1, const srvector_slice& v2) {
02802   return fsl_vv_hull<rvector_slice,srvector_slice,ivector>(v1,v2);
02803 }
02804 
02806 inline ivector operator|(const srvector_slice& v1, const rvector_slice& v2) {
02807   return slf_vv_hull<srvector_slice,rvector_slice,ivector>(v1,v2);
02808 }
02809 
02811 inline sivector operator|(const srvector_slice& v1, const srvector_slice& v2) {
02812   return slsl_vv_hull<srvector_slice,srvector_slice,sivector,interval>(v1,v2);
02813 }
02814 
02816 inline sivector operator|(const srvector& v1, const srvector_slice& v2) {
02817   return spsl_vv_hull<srvector,srvector_slice,sivector,interval>(v1,v2);
02818 }
02819 
02821 inline sivector operator|(const srvector_slice& v1, const srvector& v2) {
02822   return slsp_vv_hull<srvector_slice,srvector,sivector,interval>(v1,v2);
02823 }
02824 
02826 inline ivector operator|(const ivector& v1, const srvector_slice& v2) {
02827   return fsl_vv_hull<ivector,srvector_slice,ivector>(v1,v2);
02828 }
02829 
02831 inline ivector operator|(const rvector& v1, const sivector_slice& v2) {
02832   return fsl_vv_hull<rvector,sivector_slice,ivector>(v1,v2);
02833 }
02834 
02836 inline ivector operator|(const ivector& v1, const sivector_slice& v2) {
02837   return fsl_vv_hull<ivector,sivector_slice,ivector>(v1,v2);
02838 }
02839 
02841 inline ivector operator|(const sivector_slice& v1, const rvector& v2) {
02842   return slf_vv_hull<sivector_slice,rvector,ivector>(v1,v2);
02843 }
02844 
02846 inline ivector operator|(const srvector_slice& v1, const ivector& v2) {
02847   return slf_vv_hull<srvector_slice,ivector,ivector>(v1,v2);
02848 }
02849 
02851 inline ivector operator|(const sivector_slice& v1, const ivector& v2) {
02852   return slf_vv_hull<sivector_slice,ivector,ivector>(v1,v2);
02853 }
02854 
02856 inline ivector operator|(const ivector_slice& v1, const srvector_slice& v2) {
02857   return fsl_vv_hull<ivector_slice,srvector_slice,ivector>(v1,v2);
02858 }
02859 
02861 inline ivector operator|(const rvector_slice& v1, const sivector_slice& v2) {
02862   return fsl_vv_hull<rvector_slice,sivector_slice,ivector>(v1,v2);
02863 }
02864 
02866 inline ivector operator|(const ivector_slice& v1, const sivector_slice& v2) {
02867   return fsl_vv_hull<ivector_slice,sivector_slice,ivector>(v1,v2);
02868 }
02869 
02871 inline ivector operator|(const sivector_slice& v1, const rvector_slice& v2) {
02872   return slf_vv_hull<sivector_slice,rvector_slice,ivector>(v1,v2);
02873 }
02874 
02876 inline ivector operator|(const srvector_slice& v1, const ivector_slice& v2) {
02877   return slf_vv_hull<srvector_slice,ivector_slice,ivector>(v1,v2);
02878 }
02879 
02881 inline ivector operator|(const sivector_slice& v1, const ivector_slice& v2) {
02882   return slf_vv_hull<sivector_slice,ivector_slice,ivector>(v1,v2);
02883 }
02884 
02886 inline sivector operator|(const sivector_slice& v1, const srvector_slice& v2) {
02887   return slsl_vv_hull<sivector_slice,srvector_slice,sivector,interval>(v1,v2);
02888 }
02889 
02891 inline sivector operator|(const srvector_slice& v1, const sivector_slice& v2) {
02892   return slsl_vv_hull<srvector_slice,sivector_slice,sivector,interval>(v1,v2);
02893 }
02894 
02896 inline sivector operator|(const sivector_slice& v1, const sivector_slice& v2) {
02897   return slsl_vv_hull<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
02898 }
02899 
02901 inline sivector operator|(const sivector& v1, const srvector_slice& v2) {
02902   return spsl_vv_hull<sivector,srvector_slice,sivector,interval>(v1,v2);
02903 }
02904 
02906 inline sivector operator|(const srvector& v1, const sivector_slice& v2) {
02907   return spsl_vv_hull<srvector,sivector_slice,sivector,interval>(v1,v2);
02908 }
02909 
02911 inline sivector operator|(const sivector& v1, const sivector_slice& v2) {
02912   return spsl_vv_hull<sivector,sivector_slice,sivector,interval>(v1,v2);
02913 }
02914 
02916 inline sivector operator|(const sivector_slice& v1, const srvector& v2) {
02917   return slsp_vv_hull<sivector_slice,srvector,sivector,interval>(v1,v2);
02918 }
02919 
02921 inline sivector operator|(const srvector_slice& v1, const sivector& v2) {
02922   return slsp_vv_hull<srvector_slice,sivector,sivector,interval>(v1,v2);
02923 }
02924 
02926 inline sivector operator|(const sivector_slice& v1, const sivector& v2) {
02927   return slsp_vv_hull<sivector_slice,sivector,sivector,interval>(v1,v2);
02928 }
02929 
02931 inline ivector operator&(const ivector& v1, const sivector_slice& v2) {
02932   return fsl_vv_intersect<ivector,sivector_slice,ivector>(v1,v2);
02933 }
02934 
02936 inline ivector operator&(const sivector_slice& v1, const ivector& v2) {
02937   return slf_vv_intersect<sivector_slice,ivector,ivector>(v1,v2);
02938 }
02939 
02941 inline ivector operator&(const ivector_slice& v1, const sivector_slice& v2) {
02942   return fsl_vv_intersect<ivector_slice,sivector_slice,ivector>(v1,v2);
02943 }
02944 
02946 inline ivector operator&(const sivector_slice& v1, const ivector_slice& v2) {
02947   return slf_vv_intersect<sivector_slice,ivector_slice,ivector>(v1,v2);
02948 }
02949 
02951 inline sivector operator&(const sivector_slice& v1, const sivector_slice& v2) {
02952   return slsl_vv_intersect<sivector_slice,sivector_slice,sivector,interval>(v1,v2);
02953 }
02954 
02956 inline sivector operator&(const sivector& v1, const sivector_slice& v2) {
02957   return spsl_vv_intersect<sivector,sivector_slice,sivector,interval>(v1,v2);
02958 }
02959 
02961 inline sivector operator&(const sivector_slice& v1, const sivector& v2) {
02962   return slsp_vv_intersect<sivector_slice,sivector,sivector,interval>(v1,v2);
02963 }
02964 
02965 inline ivector& ivector::operator+=(const srvector_slice& v2) {
02966   return fsl_vv_addassign(*this,v2);
02967 }
02968 
02969 inline ivector& ivector::operator+=(const sivector_slice& v2) {
02970   return fsl_vv_addassign(*this,v2);
02971 }
02972 
02973 inline ivector_slice& ivector_slice::operator+=(const srvector_slice& v2) {
02974   return fsl_vv_addassign(*this,v2);
02975 }
02976 
02977 inline ivector_slice& ivector_slice::operator+=(const sivector_slice& v2) {
02978   return fsl_vv_addassign(*this,v2);
02979 }
02980 
02981 inline sivector& sivector::operator+=(const srvector_slice& v2) {
02982   return spsl_vv_addassign(*this,v2);
02983 }
02984 
02985 inline sivector& sivector::operator+=(const sivector_slice& v2) {
02986   return spsl_vv_addassign(*this,v2);
02987 }
02988 
02989 inline ivector& ivector::operator-=(const srvector_slice& v2) {
02990   return fsl_vv_subassign(*this,v2);
02991 }
02992 
02993 inline ivector& ivector::operator-=(const sivector_slice& v2) {
02994   return fsl_vv_subassign(*this,v2);
02995 }
02996 
02997 inline ivector_slice& ivector_slice::operator-=(const srvector_slice& v2) {
02998   return fsl_vv_subassign(*this,v2);
02999 }
03000 
03001 inline ivector_slice& ivector_slice::operator-=(const sivector_slice& v2) {
03002   return fsl_vv_subassign(*this,v2);
03003 }
03004 
03005 inline sivector& sivector::operator-=(const srvector_slice& v2) {
03006   return spsl_vv_subassign(*this,v2);
03007 }
03008 
03009 inline sivector& sivector::operator-=(const sivector_slice& v2) {
03010   return spsl_vv_subassign(*this,v2);
03011 }
03012 
03013 inline ivector& ivector::operator|=(const srvector_slice& v2) {
03014   return fsl_vv_hullassign(*this,v2);
03015 }
03016 
03017 inline ivector& ivector::operator|=(const sivector_slice& v2) {
03018   return fsl_vv_hullassign(*this,v2);
03019 }
03020 
03021 inline ivector_slice& ivector_slice::operator|=(const srvector_slice& v2) {
03022   return fsl_vv_hullassign(*this,v2);
03023 }
03024 
03025 inline ivector_slice& ivector_slice::operator|=(const sivector_slice& v2) {
03026   return fsl_vv_hullassign(*this,v2);
03027 }
03028 
03029 inline ivector& ivector::operator&=(const sivector_slice& v2) {
03030   return fsl_vv_intersectassign(*this,v2);
03031 }
03032 
03033 inline ivector_slice& ivector_slice::operator&=(const sivector_slice& v2) {
03034   return fsl_vv_intersectassign(*this,v2);
03035 }
03036 
03038 
03041 inline bool operator==(const sivector_slice& v1, const srvector_slice& v2) {
03042   return slsl_vv_comp(v1,v2);
03043 }
03044 
03046 
03049 inline bool operator==(const srvector_slice& v1, const sivector_slice& v2) {
03050   return slsl_vv_comp(v1,v2);
03051 }
03052 
03054 
03057 inline bool operator==(const sivector_slice& v1, const sivector_slice& v2) {
03058   return slsl_vv_comp(v1,v2);
03059 }
03060 
03062 
03065 inline bool operator==(const sivector_slice& v1, const srvector& v2) {
03066   return slsp_vv_comp(v1,v2);
03067 }
03068 
03070 
03073 inline bool operator==(const srvector_slice& v1, const sivector& v2) {
03074   return slsp_vv_comp(v1,v2);
03075 }
03076 
03078 
03081 inline bool operator==(const sivector_slice& v1, const sivector& v2) {
03082   return slsp_vv_comp(v1,v2);
03083 }
03084 
03086 
03089 inline bool operator==(const sivector& v1, const srvector_slice& v2) {
03090   return spsl_vv_comp(v1,v2);
03091 }
03092 
03094 
03097 inline bool operator==(const srvector& v1, const sivector_slice& v2) {
03098   return spsl_vv_comp(v1,v2);
03099 }
03100 
03102 
03105 inline bool operator==(const sivector& v1, const sivector_slice& v2) {
03106   return spsl_vv_comp(v1,v2);
03107 }
03108 
03110 
03113 inline bool operator==(const sivector_slice& v1, const rvector& v2) {
03114   return slf_vv_comp(v1,v2);
03115 }
03116 
03118 
03121 inline bool operator==(const srvector_slice& v1, const ivector& v2) {
03122   return slf_vv_comp(v1,v2);
03123 }
03124 
03126 
03129 inline bool operator==(const sivector_slice& v1, const ivector& v2) {
03130   return slf_vv_comp(v1,v2);
03131 }
03132 
03134 
03137 inline bool operator==(const ivector& v1, const srvector_slice& v2) {
03138   return fsl_vv_comp(v1,v2);
03139 }
03140 
03142 
03145 inline bool operator==(const rvector& v1, const sivector_slice& v2) {
03146   return fsl_vv_comp(v1,v2);
03147 }
03148 
03150 
03153 inline bool operator==(const ivector& v1, const sivector_slice& v2) {
03154   return fsl_vv_comp(v1,v2);
03155 }
03156 
03158 
03161 inline bool operator==(const sivector_slice& v1, const rvector_slice& v2) {
03162   return slf_vv_comp(v1,v2);
03163 }
03164 
03166 
03169 inline bool operator==(const srvector_slice& v1, const ivector_slice& v2) {
03170   return slf_vv_comp(v1,v2);
03171 }
03172 
03174 
03177 inline bool operator==(const sivector_slice& v1, const ivector_slice& v2) {
03178   return slf_vv_comp(v1,v2);
03179 }
03180 
03182 
03185 inline bool operator==(const ivector_slice& v1, const srvector_slice& v2) {
03186   return fsl_vv_comp(v1,v2);
03187 }
03188 
03190 
03193 inline bool operator==(const rvector_slice& v1, const sivector_slice& v2) {
03194   return fsl_vv_comp(v1,v2);
03195 }
03196 
03198 
03201 inline bool operator==(const ivector_slice& v1, const sivector_slice& v2) {
03202   return fsl_vv_comp(v1,v2);
03203 }
03204 
03206 
03209 inline bool operator!=(const sivector_slice& v1, const srvector_slice& v2) {
03210   return !slsl_vv_comp(v1,v2);
03211 }
03212 
03214 
03217 inline bool operator!=(const srvector_slice& v1, const sivector_slice& v2) {
03218   return !slsl_vv_comp(v1,v2);
03219 }
03220 
03222 
03225 inline bool operator!=(const sivector_slice& v1, const sivector_slice& v2) {
03226   return !slsl_vv_comp(v1,v2);
03227 }
03228 
03230 
03233 inline bool operator!=(const sivector_slice& v1, const rvector& v2) {
03234   return !slf_vv_comp(v1,v2);
03235 }
03236 
03238 
03241 inline bool operator!=(const srvector_slice& v1, const ivector& v2) {
03242   return !slf_vv_comp(v1,v2);
03243 }
03244 
03246 
03249 inline bool operator!=(const sivector_slice& v1, const ivector& v2) {
03250   return !slf_vv_comp(v1,v2);
03251 }
03252 
03254 
03257 inline bool operator!=(const ivector& v1, const srvector_slice& v2) {
03258   return !fsl_vv_comp(v1,v2);
03259 }
03260 
03262 
03265 inline bool operator!=(const rvector& v1, const sivector_slice& v2) {
03266   return !fsl_vv_comp(v1,v2);
03267 }
03268 
03270 
03273 inline bool operator!=(const ivector& v1, const sivector_slice& v2) {
03274   return !fsl_vv_comp(v1,v2);
03275 }
03276 
03278 
03281 inline bool operator!=(const sivector_slice& v1, const srvector& v2) {
03282   return !slsp_vv_comp(v1,v2);
03283 }
03284 
03286 
03289 inline bool operator!=(const srvector_slice& v1, const sivector& v2) {
03290   return !slsp_vv_comp(v1,v2);
03291 }
03292 
03294 
03297 inline bool operator!=(const sivector_slice& v1, const sivector& v2) {
03298   return !slsp_vv_comp(v1,v2);
03299 }
03300 
03302 
03305 inline bool operator!=(const sivector& v1, const srvector_slice& v2) {
03306   return !spsl_vv_comp(v1,v2);
03307 }
03308 
03310 
03313 inline bool operator!=(const srvector& v1, const sivector_slice& v2) {
03314   return !spsl_vv_comp(v1,v2);
03315 }
03316 
03318 
03321 inline bool operator!=(const sivector& v1, const sivector_slice& v2) {
03322   return !spsl_vv_comp(v1,v2);
03323 }
03324 
03326 
03329 inline bool operator!=(const sivector_slice& v1, const rvector_slice& v2) {
03330   return !slf_vv_comp(v1,v2);
03331 }
03332 
03334 
03337 inline bool operator!=(const srvector_slice& v1, const ivector_slice& v2) {
03338   return !slf_vv_comp(v1,v2);
03339 }
03340 
03342 
03345 inline bool operator!=(const sivector_slice& v1, const ivector_slice& v2) {
03346   return !slf_vv_comp(v1,v2);
03347 }
03348 
03350 
03353 inline bool operator!=(const ivector_slice& v1, const srvector_slice& v2) {
03354   return !fsl_vv_comp(v1,v2);
03355 }
03356 
03358 
03361 inline bool operator!=(const rvector_slice& v1, const sivector_slice& v2) {
03362   return !fsl_vv_comp(v1,v2);
03363 }
03364 
03366 
03369 inline bool operator!=(const ivector_slice& v1, const sivector_slice& v2) {
03370   return !fsl_vv_comp(v1,v2);
03371 }
03372 
03374 
03377 inline bool operator<(const srvector_slice& v1, const sivector_slice& v2) {
03378   return slsl_vv_less<srvector_slice,sivector_slice,interval>(v1,v2);
03379 }
03380 
03382 
03385 inline bool operator<(const sivector_slice& v1, const sivector_slice& v2) {
03386   return slsl_vv_less<sivector_slice,sivector_slice,interval>(v1,v2);
03387 }
03388 
03390 
03393 inline bool operator<(const srvector_slice& v1, const sivector& v2) {
03394   return slsp_vv_less<srvector_slice,sivector,interval>(v1,v2);
03395 }
03396 
03398 
03401 inline bool operator<(const sivector_slice& v1, const sivector& v2) {
03402   return slsp_vv_less<sivector_slice,sivector,interval>(v1,v2);
03403 }
03404 
03406 
03409 inline bool operator<(const srvector& v1, const sivector_slice& v2) {
03410   return spsl_vv_less<srvector,sivector_slice,interval>(v1,v2);
03411 }
03412 
03414 
03417 inline bool operator<(const sivector& v1, const sivector_slice& v2) {
03418   return spsl_vv_less<sivector,sivector_slice,interval>(v1,v2);
03419 }
03420 
03422 
03425 inline bool operator<(const srvector_slice& v1, const ivector& v2) {
03426   return slf_vv_less<srvector_slice,ivector,interval>(v1,v2);
03427 }
03428 
03430 
03433 inline bool operator<(const sivector_slice& v1, const ivector& v2) {
03434   return slf_vv_less<sivector_slice,ivector,interval>(v1,v2);
03435 }
03436 
03438 
03441 inline bool operator<(const rvector& v1, const sivector_slice& v2) {
03442   return fsl_vv_less<rvector,sivector_slice,interval>(v1,v2);
03443 }
03444 
03446 
03449 inline bool operator<(const ivector& v1, const sivector_slice& v2) {
03450   return fsl_vv_less<ivector,sivector_slice,interval>(v1,v2);
03451 }
03452 
03454 
03457 inline bool operator<(const srvector_slice& v1, const ivector_slice& v2) {
03458   return slf_vv_less<srvector_slice,ivector_slice,interval>(v1,v2);
03459 }
03460 
03462 
03465 inline bool operator<(const sivector_slice& v1, const ivector_slice& v2) {
03466   return slf_vv_less<sivector_slice,ivector_slice,interval>(v1,v2);
03467 }
03468 
03470 
03473 inline bool operator<(const rvector_slice& v1, const sivector_slice& v2) {
03474   return fsl_vv_less<rvector_slice,sivector_slice,interval>(v1,v2);
03475 }
03476 
03478 
03481 inline bool operator<(const ivector_slice& v1, const sivector_slice& v2) {
03482   return fsl_vv_less<ivector_slice,sivector_slice,interval>(v1,v2);
03483 }
03484 
03486 
03489 inline bool operator<=(const sivector_slice& v1, const sivector_slice& v2) {
03490   return slsl_vv_leq<sivector_slice,sivector_slice,interval>(v1,v2);
03491 }
03492 
03494 
03497 inline bool operator<=(const srvector_slice& v1, const sivector& v2) {
03498   return slsp_vv_leq<srvector_slice,sivector,interval>(v1,v2);
03499 }
03500 
03502 
03505 inline bool operator<=(const sivector_slice& v1, const sivector& v2) {
03506   return slsp_vv_leq<sivector_slice,sivector,interval>(v1,v2);
03507 }
03508 
03510 
03513 inline bool operator<=(const srvector& v1, const sivector_slice& v2) {
03514   return spsl_vv_leq<srvector,sivector_slice,interval>(v1,v2);
03515 }
03516 
03518 
03521 inline bool operator<=(const sivector& v1, const sivector_slice& v2) {
03522   return spsl_vv_leq<sivector,sivector_slice,interval>(v1,v2);
03523 }
03524 
03526 
03529 inline bool operator<=(const srvector_slice& v1, const ivector& v2) {
03530   return slf_vv_leq<srvector_slice,ivector,interval>(v1,v2);
03531 }
03532 
03534 
03537 inline bool operator<=(const sivector_slice& v1, const ivector& v2) {
03538   return slf_vv_leq<sivector_slice,ivector,interval>(v1,v2);
03539 }
03540 
03542 
03545 inline bool operator<=(const rvector& v1, const sivector_slice& v2) {
03546   return fsl_vv_leq<rvector,sivector_slice,interval>(v1,v2);
03547 }
03548 
03550 
03553 inline bool operator<=(const ivector& v1, const sivector_slice& v2) {
03554   return fsl_vv_leq<ivector,sivector_slice,interval>(v1,v2);
03555 }
03556 
03558 
03561 inline bool operator<=(const srvector_slice& v1, const ivector_slice& v2) {
03562   return slf_vv_leq<srvector_slice,ivector_slice,interval>(v1,v2);
03563 }
03564 
03566 
03569 inline bool operator<=(const sivector_slice& v1, const ivector_slice& v2) {
03570   return slf_vv_leq<sivector_slice,ivector_slice,interval>(v1,v2);
03571 }
03572 
03574 
03577 inline bool operator<=(const rvector_slice& v1, const sivector_slice& v2) {
03578   return fsl_vv_leq<rvector_slice,sivector_slice,interval>(v1,v2);
03579 }
03580 
03582 
03585 inline bool operator<=(const ivector_slice& v1, const sivector_slice& v2) {
03586   return fsl_vv_leq<ivector_slice,sivector_slice,interval>(v1,v2);
03587 }
03588 
03590 
03593 inline bool operator>(const sivector_slice& v1, const srvector_slice& v2) {
03594   return slsl_vv_greater<sivector_slice,srvector_slice,interval>(v1,v2);
03595 }
03596 
03598 
03601 inline bool operator>(const sivector_slice& v1, const sivector_slice& v2) {
03602   return slsl_vv_greater<sivector_slice,sivector_slice,interval>(v1,v2);
03603 }
03604 
03606 
03609 inline bool operator>(const sivector_slice& v1, const srvector& v2) {
03610   return slsp_vv_greater<sivector_slice,srvector,interval>(v1,v2);
03611 }
03612 
03614 
03617 inline bool operator>(const sivector_slice& v1, const sivector& v2) {
03618   return slsp_vv_greater<sivector_slice,sivector,interval>(v1,v2);
03619 }
03620 
03622 
03625 inline bool operator>(const sivector& v1, const srvector_slice& v2) {
03626   return spsl_vv_greater<sivector,srvector_slice,interval>(v1,v2);
03627 }
03628 
03630 
03633 inline bool operator>(const sivector& v1, const sivector_slice& v2) {
03634   return spsl_vv_greater<sivector,sivector_slice,interval>(v1,v2);
03635 }
03636 
03638 
03641 inline bool operator>(const sivector_slice& v1, const rvector& v2) {
03642   return slf_vv_greater<sivector_slice,rvector,interval>(v1,v2);
03643 }
03644 
03646 
03649 inline bool operator>(const sivector_slice& v1, const ivector& v2) {
03650   return slf_vv_greater<sivector_slice,ivector,interval>(v1,v2);
03651 }
03652 
03654 
03657 inline bool operator>(const ivector& v1, const srvector_slice& v2) {
03658   return fsl_vv_greater<ivector,srvector_slice,interval>(v1,v2);
03659 }
03660 
03662 
03665 inline bool operator>(const ivector& v1, const sivector_slice& v2) {
03666   return fsl_vv_greater<ivector,sivector_slice,interval>(v1,v2);
03667 }
03668 
03670 
03673 inline bool operator>(const sivector_slice& v1, const rvector_slice& v2) {
03674   return slf_vv_greater<sivector_slice,rvector_slice,interval>(v1,v2);
03675 }
03676 
03678 
03681 inline bool operator>(const sivector_slice& v1, const ivector_slice& v2) {
03682   return slf_vv_greater<sivector_slice,ivector_slice,interval>(v1,v2);
03683 }
03684 
03686 
03689 inline bool operator>(const ivector_slice& v1, const srvector_slice& v2) {
03690   return fsl_vv_greater<ivector_slice,srvector_slice,interval>(v1,v2);
03691 }
03692 
03694 
03697 inline bool operator>(const ivector_slice& v1, const sivector_slice& v2) {
03698   return fsl_vv_greater<ivector_slice,sivector_slice,interval>(v1,v2);
03699 }
03700 
03702 
03705 inline bool operator>=(const sivector_slice& v1, const srvector_slice& v2) {
03706   return slsl_vv_geq<sivector_slice,srvector_slice,interval>(v1,v2);
03707 }
03708 
03710 
03713 inline bool operator>=(const sivector_slice& v1, const sivector_slice& v2) {
03714   return slsl_vv_geq<sivector_slice,sivector_slice,interval>(v1,v2);
03715 }
03716 
03718 
03721 inline bool operator>=(const sivector_slice& v1, const srvector& v2) {
03722   return slsp_vv_geq<sivector_slice,srvector,interval>(v1,v2);
03723 }
03724 
03726 
03729 inline bool operator>=(const sivector_slice& v1, const sivector& v2) {
03730   return slsp_vv_geq<sivector_slice,sivector,interval>(v1,v2);
03731 }
03732 
03734 
03737 inline bool operator>=(const sivector& v1, const srvector_slice& v2) {
03738   return spsl_vv_geq<sivector,srvector_slice,interval>(v1,v2);
03739 }
03740 
03742 
03745 inline bool operator>=(const sivector& v1, const sivector_slice& v2) {
03746   return spsl_vv_geq<sivector,sivector_slice,interval>(v1,v2);
03747 }
03748 
03750 
03753 inline bool operator>=(const sivector_slice& v1, const rvector& v2) {
03754   return slf_vv_geq<sivector_slice,rvector,interval>(v1,v2);
03755 }
03756 
03758 
03761 inline bool operator>=(const sivector_slice& v1, const ivector& v2) {
03762   return slf_vv_geq<sivector_slice,ivector,interval>(v1,v2);
03763 }
03764 
03766 
03769 inline bool operator>=(const ivector& v1, const srvector_slice& v2) {
03770   return fsl_vv_geq<ivector,srvector_slice,interval>(v1,v2);
03771 }
03772 
03774 
03777 inline bool operator>=(const ivector& v1, const sivector_slice& v2) {
03778   return fsl_vv_geq<ivector,sivector_slice,interval>(v1,v2);
03779 }
03780 
03782 
03785 inline bool operator>=(const sivector_slice& v1, const rvector_slice& v2) {
03786   return slf_vv_geq<sivector_slice,rvector_slice,interval>(v1,v2);
03787 }
03788 
03790 
03793 inline bool operator>=(const sivector_slice& v1, const ivector_slice& v2) {
03794   return slf_vv_geq<sivector_slice,ivector_slice,interval>(v1,v2);
03795 }
03796 
03798 
03801 inline bool operator>=(const ivector_slice& v1, const srvector_slice& v2) {
03802   return fsl_vv_geq<ivector_slice,srvector_slice,interval>(v1,v2);
03803 }
03804 
03806 
03809 inline bool operator>=(const ivector_slice& v1, const sivector_slice& v2) {
03810   return fsl_vv_geq<ivector_slice,sivector_slice,interval>(v1,v2);
03811 }
03812 
03814 
03819 inline std::ostream& operator<<(std::ostream& os, const sivector_slice& v) {
03820   return sl_v_output<sivector_slice,interval>(os,v);
03821 }
03822 
03824 
03829 inline std::istream& operator>>(std::istream& is, sivector_slice& v) {
03830   return sl_v_input<sivector_slice,interval>(is,v);
03831 }
03832 
03834 
03837 inline void accumulate(idotprecision& dot, const sivector& x, const sivector& y) {
03838   spsp_vv_accu<idotprecision,sivector,sivector,sparse_idot>(dot,x,y);
03839 }
03840 
03842 
03845 inline void accumulate(idotprecision& dot, const sivector& x, const srvector& y) {
03846   spsp_vv_accu<idotprecision,sivector,srvector,sparse_idot>(dot,x,y);
03847 }
03848 
03850 
03853 inline void accumulate(idotprecision& dot, const srvector& x, const sivector& y) {
03854   spsp_vv_accu<idotprecision,srvector,sivector,sparse_idot>(dot,x,y);
03855 }
03856 
03858 
03861 inline void accumulate(idotprecision& dot, const sivector& x, const ivector& y) {
03862   spf_vv_accu<idotprecision,sivector,ivector,sparse_idot>(dot,x,y);
03863 }
03864 
03866 
03869 inline void accumulate(idotprecision& dot, const sivector& x, const rvector& y) {
03870   spf_vv_accu<idotprecision,sivector,rvector,sparse_idot>(dot,x,y);
03871 }
03872 
03874 
03877 inline void accumulate(idotprecision& dot, const srvector& x, const ivector& y) {
03878   spf_vv_accu<idotprecision,srvector,ivector,sparse_idot>(dot,x,y);
03879 }
03880 
03882 
03885 inline void accumulate(idotprecision& dot, const sivector& x, const ivector_slice& y) {
03886   spf_vv_accu<idotprecision,sivector,ivector_slice,sparse_idot>(dot,x,y);
03887 }
03888 
03890 
03893 inline void accumulate(idotprecision& dot, const sivector& x, const rvector_slice& y) {
03894   spf_vv_accu<idotprecision,sivector,rvector_slice,sparse_idot>(dot,x,y);
03895 }
03896 
03898 
03901 inline void accumulate(idotprecision& dot, const srvector& x, const ivector_slice& y) {
03902   spf_vv_accu<idotprecision,srvector,ivector_slice,sparse_idot>(dot,x,y);
03903 }
03904 
03906 
03909 inline void accumulate(idotprecision& dot, const ivector& x, const sivector& y) {
03910   fsp_vv_accu<idotprecision,ivector,sivector,sparse_idot>(dot,x,y);
03911 }
03912 
03914 
03917 inline void accumulate(idotprecision& dot, const ivector& x, const srvector& y) {
03918   fsp_vv_accu<idotprecision,ivector,srvector,sparse_idot>(dot,x,y);
03919 }
03920 
03922 
03925 inline void accumulate(idotprecision& dot, const rvector& x, const sivector& y) {
03926   fsp_vv_accu<idotprecision,rvector,sivector,sparse_idot>(dot,x,y);
03927 }
03928 
03930 
03933 inline void accumulate(idotprecision& dot, const ivector_slice& x, const sivector& y) {
03934   fsp_vv_accu<idotprecision,ivector_slice,sivector,sparse_idot>(dot,x,y);
03935 }
03936 
03938 
03941 inline void accumulate(idotprecision& dot, const ivector_slice& x, const srvector& y) {
03942   fsp_vv_accu<idotprecision,ivector_slice,srvector,sparse_idot>(dot,x,y);
03943 }
03944 
03946 
03949 inline void accumulate(idotprecision& dot, const rvector_slice& x, const sivector& y) {
03950   fsp_vv_accu<idotprecision,rvector_slice,sivector,sparse_idot>(dot,x,y);
03951 }
03952 
03954 
03957 inline void accumulate(idotprecision& dot, const sivector_slice& x, const ivector& y) {
03958   slf_vv_accu<idotprecision,sivector_slice,ivector,sparse_idot>(dot,x,y);
03959 }
03960 
03962 
03965 inline void accumulate(idotprecision& dot, const sivector_slice& x, const rvector& y) {
03966   slf_vv_accu<idotprecision,sivector_slice,rvector,sparse_idot>(dot,x,y);
03967 }
03968 
03970 
03973 inline void accumulate(idotprecision& dot, const srvector_slice& x, const ivector& y) {
03974   slf_vv_accu<idotprecision,srvector_slice,ivector,sparse_idot>(dot,x,y);
03975 }
03976 
03978 
03981 inline void accumulate(idotprecision& dot, const sivector_slice& x, const ivector_slice& y) {
03982   slf_vv_accu<idotprecision,sivector_slice,ivector_slice,sparse_idot>(dot,x,y);
03983 }
03984 
03986 
03989 inline void accumulate(idotprecision& dot, const sivector_slice& x, const rvector_slice& y) {
03990   slf_vv_accu<idotprecision,sivector_slice,rvector_slice,sparse_idot>(dot,x,y);
03991 }
03992 
03994 
03997 inline void accumulate(idotprecision& dot, const srvector_slice& x, const ivector_slice& y) {
03998   slf_vv_accu<idotprecision,srvector_slice,ivector_slice,sparse_idot>(dot,x,y);
03999 }
04000 
04002 
04005 inline void accumulate(idotprecision& dot, const ivector& x, const sivector_slice& y) {
04006   fsl_vv_accu<idotprecision,ivector,sivector_slice,sparse_idot>(dot,x,y);
04007 }
04008 
04010 
04013 inline void accumulate(idotprecision& dot, const ivector& x, const srvector_slice& y) {
04014   fsl_vv_accu<idotprecision,ivector,srvector_slice,sparse_idot>(dot,x,y);
04015 }
04016 
04018 
04021 inline void accumulate(idotprecision& dot, const rvector& x, const sivector_slice& y) {
04022   fsl_vv_accu<idotprecision,rvector,sivector_slice,sparse_idot>(dot,x,y);
04023 }
04024 
04026 
04029 inline void accumulate(idotprecision& dot, const ivector_slice& x, const sivector_slice& y) {
04030   fsl_vv_accu<idotprecision,ivector_slice,sivector_slice,sparse_idot>(dot,x,y);
04031 }
04032 
04034 
04037 inline void accumulate(idotprecision& dot, const ivector_slice& x, const srvector_slice& y) {
04038   fsl_vv_accu<idotprecision,ivector_slice,srvector_slice,sparse_idot>(dot,x,y);
04039 }
04040 
04042 
04045 inline void accumulate(idotprecision& dot, const rvector_slice& x, const sivector_slice& y) {
04046   fsl_vv_accu<idotprecision,rvector_slice,sivector_slice,sparse_idot>(dot,x,y);
04047 }
04048 
04050 
04053 inline void accumulate(idotprecision& dot, const sivector_slice& x, const sivector_slice& y) {
04054   slsl_vv_accu<idotprecision,sivector_slice,sivector_slice,sparse_idot>(dot,x,y);
04055 }
04056 
04058 
04061 inline void accumulate(idotprecision& dot, const sivector_slice& x, const srvector_slice& y) {
04062   slsl_vv_accu<idotprecision,sivector_slice,srvector_slice,sparse_idot>(dot,x,y);
04063 }
04064 
04066 
04069 inline void accumulate(idotprecision& dot, const srvector_slice& x, const sivector_slice& y) {
04070   slsl_vv_accu<idotprecision,srvector_slice,sivector_slice,sparse_idot>(dot,x,y);
04071 }
04072 
04074 
04077 inline void accumulate(idotprecision& dot, const sivector& x, const sivector_slice& y) {
04078   spsl_vv_accu<idotprecision,sivector,sivector_slice,sparse_idot>(dot,x,y);
04079 }
04080 
04082 
04085 inline void accumulate(idotprecision& dot, const sivector& x, const srvector_slice& y) {
04086   spsl_vv_accu<idotprecision,sivector,srvector_slice,sparse_idot>(dot,x,y);
04087 }
04088 
04090 
04093 inline void accumulate(idotprecision& dot, const srvector& x, const sivector_slice& y) {
04094   spsl_vv_accu<idotprecision,srvector,sivector_slice,sparse_idot>(dot,x,y);
04095 }
04096 
04098 
04101 inline void accumulate(idotprecision& dot, const sivector_slice& x, const sivector& y) {
04102   slsp_vv_accu<idotprecision,sivector_slice,sivector,sparse_idot>(dot,x,y);
04103 }
04104 
04106 
04109 inline void accumulate(idotprecision& dot, const sivector_slice& x, const srvector& y) {
04110   slsp_vv_accu<idotprecision,sivector_slice,srvector,sparse_idot>(dot,x,y);
04111 }
04112 
04114 
04117 inline void accumulate(idotprecision& dot, const srvector_slice& x, const sivector& y) {
04118   slsp_vv_accu<idotprecision,srvector_slice,sivector,sparse_idot>(dot,x,y);
04119 }
04120 
04122 
04125 inline void accumulate(cidotprecision& dot, const sivector& x, const sivector& y) {
04126   idotprecision tmp(0.0);
04127   tmp.set_k(dot.get_k());
04128   accumulate(tmp,x,y);
04129   SetRe(dot, Re(dot) + tmp);
04130 }
04131 
04133 
04136 inline void accumulate(cidotprecision& dot, const sivector& x, const srvector& y) {
04137   idotprecision tmp(0.0);
04138   tmp.set_k(dot.get_k());
04139   accumulate(tmp,x,y);
04140   SetRe(dot, Re(dot) + tmp);
04141 }
04142 
04144 
04147 inline void accumulate(cidotprecision& dot, const srvector& x, const sivector& y) {
04148   idotprecision tmp(0.0);
04149   tmp.set_k(dot.get_k());
04150   accumulate(tmp,x,y);
04151   SetRe(dot, Re(dot) + tmp);
04152 }
04153 
04155 
04158 inline void accumulate(cidotprecision& dot, const sivector& x, const ivector& y) {
04159   idotprecision tmp(0.0);
04160   tmp.set_k(dot.get_k());
04161   accumulate(tmp,x,y);
04162   SetRe(dot, Re(dot) + tmp);
04163 }
04164 
04166 
04169 inline void accumulate(cidotprecision& dot, const sivector& x, const rvector& y) {
04170   idotprecision tmp(0.0);
04171   tmp.set_k(dot.get_k());
04172   accumulate(tmp,x,y);
04173   SetRe(dot, Re(dot) + tmp);
04174 }
04175 
04177 
04180 inline void accumulate(cidotprecision& dot, const srvector& x, const ivector& y) {
04181   idotprecision tmp(0.0);
04182   tmp.set_k(dot.get_k());
04183   accumulate(tmp,x,y);
04184   SetRe(dot, Re(dot) + tmp);
04185 }
04186 
04188 
04191 inline void accumulate(cidotprecision& dot, const sivector& x, const ivector_slice& y) {
04192   idotprecision tmp(0.0);
04193   tmp.set_k(dot.get_k());
04194   accumulate(tmp,x,y);
04195   SetRe(dot, Re(dot) + tmp);
04196 }
04197 
04199 
04202 inline void accumulate(cidotprecision& dot, const sivector& x, const rvector_slice& y) {
04203   idotprecision tmp(0.0);
04204   tmp.set_k(dot.get_k());
04205   accumulate(tmp,x,y);
04206   SetRe(dot, Re(dot) + tmp);
04207 }
04208 
04210 
04213 inline void accumulate(cidotprecision& dot, const srvector& x, const ivector_slice& y) {
04214   idotprecision tmp(0.0);
04215   tmp.set_k(dot.get_k());
04216   accumulate(tmp,x,y);
04217   SetRe(dot, Re(dot) + tmp);
04218 }
04219 
04221 
04224 inline void accumulate(cidotprecision& dot, const ivector& x, const sivector& y) {
04225   idotprecision tmp(0.0);
04226   tmp.set_k(dot.get_k());
04227   accumulate(tmp,x,y);
04228   SetRe(dot, Re(dot) + tmp);
04229 }
04230 
04232 
04235 inline void accumulate(cidotprecision& dot, const ivector& x, const srvector& y) {
04236   idotprecision tmp(0.0);
04237   tmp.set_k(dot.get_k());
04238   accumulate(tmp,x,y);
04239   SetRe(dot, Re(dot) + tmp);
04240 }
04241 
04243 
04246 inline void accumulate(cidotprecision& dot, const rvector& x, const sivector& y) {
04247   idotprecision tmp(0.0);
04248   tmp.set_k(dot.get_k());
04249   accumulate(tmp,x,y);
04250   SetRe(dot, Re(dot) + tmp);
04251 }
04252 
04254 
04257 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const sivector& y) {
04258   idotprecision tmp(0.0);
04259   tmp.set_k(dot.get_k());
04260   accumulate(tmp,x,y);
04261   SetRe(dot, Re(dot) + tmp);
04262 }
04263 
04265 
04268 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const srvector& y) {
04269   idotprecision tmp(0.0);
04270   tmp.set_k(dot.get_k());
04271   accumulate(tmp,x,y);
04272   SetRe(dot, Re(dot) + tmp);
04273 }
04274 
04276 
04279 inline void accumulate(cidotprecision& dot, const rvector_slice& x, const sivector& y) {
04280   idotprecision tmp(0.0);
04281   tmp.set_k(dot.get_k());
04282   accumulate(tmp,x,y);
04283   SetRe(dot, Re(dot) + tmp);
04284 }
04285 
04287 
04290 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const ivector& y) {
04291   idotprecision tmp(0.0);
04292   tmp.set_k(dot.get_k());
04293   accumulate(tmp,x,y);
04294   SetRe(dot, Re(dot) + tmp);
04295 }
04296 
04298 
04301 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const rvector& y) {
04302   idotprecision tmp(0.0);
04303   tmp.set_k(dot.get_k());
04304   accumulate(tmp,x,y);
04305   SetRe(dot, Re(dot) + tmp);
04306 }
04307 
04309 
04312 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const ivector& y) {
04313   idotprecision tmp(0.0);
04314   tmp.set_k(dot.get_k());
04315   accumulate(tmp,x,y);
04316   SetRe(dot, Re(dot) + tmp);
04317 }
04318 
04320 
04323 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const ivector_slice& y) {
04324   idotprecision tmp(0.0);
04325   tmp.set_k(dot.get_k());
04326   accumulate(tmp,x,y);
04327   SetRe(dot, Re(dot) + tmp);
04328 }
04329 
04331 
04334 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const rvector_slice& y) {
04335   idotprecision tmp(0.0);
04336   tmp.set_k(dot.get_k());
04337   accumulate(tmp,x,y);
04338   SetRe(dot, Re(dot) + tmp);
04339 }
04340 
04342 
04345 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const ivector_slice& y) {
04346   idotprecision tmp(0.0);
04347   tmp.set_k(dot.get_k());
04348   accumulate(tmp,x,y);
04349   SetRe(dot, Re(dot) + tmp);
04350 }
04351 
04353 
04356 inline void accumulate(cidotprecision& dot, const ivector& x, const sivector_slice& y) {
04357   idotprecision tmp(0.0);
04358   tmp.set_k(dot.get_k());
04359   accumulate(tmp,x,y);
04360   SetRe(dot, Re(dot) + tmp);
04361 }
04362 
04364 
04367 inline void accumulate(cidotprecision& dot, const ivector& x, const srvector_slice& y) {
04368   idotprecision tmp(0.0);
04369   tmp.set_k(dot.get_k());
04370   accumulate(tmp,x,y);
04371   SetRe(dot, Re(dot) + tmp);
04372 }
04373 
04375 
04378 inline void accumulate(cidotprecision& dot, const rvector& x, const sivector_slice& y) {
04379   idotprecision tmp(0.0);
04380   tmp.set_k(dot.get_k());
04381   accumulate(tmp,x,y);
04382   SetRe(dot, Re(dot) + tmp);
04383 }
04384 
04386 
04389 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const sivector_slice& y) {
04390   idotprecision tmp(0.0);
04391   tmp.set_k(dot.get_k());
04392   accumulate(tmp,x,y);
04393   SetRe(dot, Re(dot) + tmp);
04394 }
04395 
04397 
04400 inline void accumulate(cidotprecision& dot, const ivector_slice& x, const srvector_slice& y) {
04401   idotprecision tmp(0.0);
04402   tmp.set_k(dot.get_k());
04403   accumulate(tmp,x,y);
04404   SetRe(dot, Re(dot) + tmp);
04405 }
04406 
04408 
04411 inline void accumulate(cidotprecision& dot, const rvector_slice& x, const sivector_slice& y) {
04412   idotprecision tmp(0.0);
04413   tmp.set_k(dot.get_k());
04414   accumulate(tmp,x,y);
04415   SetRe(dot, Re(dot) + tmp);
04416 }
04417 
04419 
04422 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const sivector_slice& y) {
04423   idotprecision tmp(0.0);
04424   tmp.set_k(dot.get_k());
04425   accumulate(tmp,x,y);
04426   SetRe(dot, Re(dot) + tmp);
04427 }
04428 
04430 
04433 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const srvector_slice& y) {
04434   idotprecision tmp(0.0);
04435   tmp.set_k(dot.get_k());
04436   accumulate(tmp,x,y);
04437   SetRe(dot, Re(dot) + tmp);
04438 }
04439 
04441 
04444 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const sivector_slice& y) {
04445   idotprecision tmp(0.0);
04446   tmp.set_k(dot.get_k());
04447   accumulate(tmp,x,y);
04448   SetRe(dot, Re(dot) + tmp);
04449 }
04450 
04452 
04455 inline void accumulate(cidotprecision& dot, const sivector& x, const sivector_slice& y) {
04456   idotprecision tmp(0.0);
04457   tmp.set_k(dot.get_k());
04458   accumulate(tmp,x,y);
04459   SetRe(dot, Re(dot) + tmp);
04460 }
04461 
04463 
04466 inline void accumulate(cidotprecision& dot, const sivector& x, const srvector_slice& y) {
04467   idotprecision tmp(0.0);
04468   tmp.set_k(dot.get_k());
04469   accumulate(tmp,x,y);
04470   SetRe(dot, Re(dot) + tmp);
04471 }
04472 
04474 
04477 inline void accumulate(cidotprecision& dot, const srvector& x, const sivector_slice& y) {
04478   idotprecision tmp(0.0);
04479   tmp.set_k(dot.get_k());
04480   accumulate(tmp,x,y);
04481   SetRe(dot, Re(dot) + tmp);
04482 }
04483 
04485 
04488 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const sivector& y) {
04489   idotprecision tmp(0.0);
04490   tmp.set_k(dot.get_k());
04491   accumulate(tmp,x,y);
04492   SetRe(dot, Re(dot) + tmp);
04493 }
04494 
04496 
04499 inline void accumulate(cidotprecision& dot, const sivector_slice& x, const srvector& y) {
04500   idotprecision tmp(0.0);
04501   tmp.set_k(dot.get_k());
04502   accumulate(tmp,x,y);
04503   SetRe(dot, Re(dot) + tmp);
04504 }
04505 
04507 
04510 inline void accumulate(cidotprecision& dot, const srvector_slice& x, const sivector& y) {
04511   idotprecision tmp(0.0);
04512   tmp.set_k(dot.get_k());
04513   accumulate(tmp,x,y);
04514   SetRe(dot, Re(dot) + tmp);
04515 }
04516 
04517 } //namespace cxsc
04518 
04519 #include "sparsevector.inl"
04520 
04521 #endif