C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
scivector.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: scivector.hpp,v 1.15 2014/01/30 17:23:48 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_SCIVECTOR_HPP_INCLUDED
00027 #define _CXSC_SCIVECTOR_HPP_INCLUDED
00028 
00029 #include <cinterval.hpp>
00030 #include <civector.hpp>
00031 #include <vector>
00032 #include <iostream>
00033 #include <srvector.hpp>
00034 #include <scvector.hpp>
00035 #include <sivector.hpp>
00036 #include <sparsecidot.hpp>
00037 #include <sparsevector.hpp>
00038 
00039 namespace cxsc {
00040 
00041 class srvector_slice;
00042 class srmatrix;
00043 class srmatrix_slice;
00044 class srmatrix_subv;
00045 class scvector_slice;
00046 class scmatrix;
00047 class scmatrix_slice;
00048 class scmatrix_subv;
00049 class sivector_slice;
00050 class simatrix;
00051 class simatrix_slice;
00052 class simatrix_subv;
00053 class scivector_slice;
00054 class scimatrix_slice;
00055 class scimatrix_subv;
00056 
00058 
00062 class scivector {
00063   private:
00064     std::vector<int> p;
00065     std::vector<cinterval> x;
00066     int lb;
00067     int ub;
00068     int n; 
00069 
00070   public:
00072     scivector() : lb(0), ub(-1) , n(0) {
00073     }
00074 
00076     explicit scivector(const int s) : lb(1), ub(s), n(s) {
00077         p.reserve((int)(s*0.1));
00078         x.reserve((int)(s*0.1));
00079     }
00080 
00082     scivector(const int s, const int b) : lb(1), ub(s), n(s) {
00083         p.reserve(b);
00084         x.reserve(b);
00085     }
00086 
00088     scivector(const civector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
00089         for(int i=lb ; i<=ub ; i++) {
00090           if(v[i] != 0.0) {
00091             p.push_back(i-lb);
00092             x.push_back(v[i]);
00093           }
00094         }
00095     }
00096 
00098     scivector(const cvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
00099         for(int i=lb ; i<=ub ; i++) {
00100           if(v[i] != 0.0) {
00101             p.push_back(i-lb);
00102             x.push_back(cinterval(v[i]));
00103           }
00104         }
00105     }
00106 
00108     scivector(const rvector& v) : lb(Lb(v)), ub(Ub(v)), n(VecLen(v)) {
00109         for(int i=lb ; i<=ub ; i++) {
00110           if(v[i] != 0.0) {
00111             p.push_back(i-lb);
00112             x.push_back(cinterval(v[i]));
00113           }
00114         }
00115     }
00116 
00118     scivector(const int n, const int nnz, const intvector& index, const civector& values) : lb(1), ub(n) {
00119       this->n = n;
00120       for(int i=0 ; i<nnz ; i++) {
00121         if(values[i+Lb(values)] != 0.0) {
00122           p.push_back(index[i+Lb(index)]);
00123           x.push_back(values[i+Lb(values)]);
00124         }
00125       }
00126     }
00127 
00129     scivector(const int n, const int nnz, const int* index, const cinterval* values) : lb(1), ub(n) {
00130       this->n = n;
00131       for(int i=0 ; i<nnz ; i++) {
00132         if(values[i] != 0.0) {
00133           p.push_back(index[i]);
00134           x.push_back(values[i]);
00135         }
00136       }
00137     }
00138 
00140     scivector(const srvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
00141       x.reserve(v.get_nnz());
00142       for(int i=0 ; i<v.get_nnz() ; i++) 
00143         x.push_back(cinterval(v.x[i]));
00144     }
00145 
00147     scivector(const scvector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
00148       x.reserve(v.get_nnz()); 
00149       for(int i=0 ; i<v.get_nnz() ; i++) 
00150         x.push_back(cinterval(v.x[i]));
00151     }
00152 
00154     scivector(const sivector& v) : p(v.p), lb(v.lb), ub(v.ub), n(v.n) {
00155       x.reserve(v.get_nnz());
00156       for(int i=0 ; i<v.get_nnz() ; i++) 
00157         x.push_back(cinterval(v.x[i]));
00158     }
00159 
00161     scivector(const srvector_slice&);
00163     scivector(const scvector_slice&);
00165     scivector(const sivector_slice&);
00167     scivector(const scivector_slice&);
00169     scivector(const srmatrix_subv& A);
00171     scivector(const scmatrix_subv& A);
00173     scivector(const simatrix_subv& A);
00175     scivector(const scimatrix_subv& A);
00176 
00178 
00183     std::vector<int>& row_indices() {
00184       return p;
00185     }
00186 
00188 
00192     std::vector<cinterval>& values() {
00193       return x;
00194     }
00195 
00197 
00202     const std::vector<int>& row_indices() const {
00203       return p;
00204     }
00205 
00207 
00211     const std::vector<cinterval>& values() const {
00212       return x;
00213     }
00214 
00216     int get_nnz() const {
00217       return x.size();
00218     }
00219 
00221     real density() const {
00222       return (double)x.size()/n;
00223     }
00224 
00226     void dropzeros() {
00227       for(int i=0 ; i<get_nnz() ; i++) {
00228         if(x[i] == 0.0) {
00229            x.erase(x.begin()+i);
00230            p.erase(p.begin()+i);
00231         }
00232       }
00233     }
00234 
00236     scivector& operator=(const srvector& v) {
00237       n = v.n;
00238       p = v.p;
00239       x.clear();
00240       x.reserve(v.get_nnz());
00241       for(unsigned int i=0 ; i<v.x.size() ; i++)
00242         x[i] = cinterval(v.x[i]);
00243       return *this;
00244     } 
00245 
00247     scivector& operator=(const sivector& v) {
00248       n = v.n;
00249       p = v.p;
00250       x.clear();
00251       x.reserve(v.get_nnz());
00252       for(unsigned int i=0 ; i<v.x.size() ; i++)
00253         x[i] = cinterval(v.x[i]);
00254       return *this;
00255     } 
00256 
00258     scivector& operator=(const scvector& v) {
00259       n = v.n;
00260       p = v.p;
00261       x.clear();
00262       x.reserve(v.get_nnz());
00263       for(unsigned int i=0 ; i<v.x.size() ; i++)
00264         x[i] = cinterval(v.x[i]);
00265       return *this;
00266     } 
00267 
00269     scivector& operator=(const real& v) {
00270       return sp_vs_assign<scivector,real,cinterval>(*this,v);
00271     }
00272 
00274     scivector& operator=(const complex& v) {
00275       return sp_vs_assign<scivector,complex,cinterval>(*this,v);
00276     }
00277 
00279     scivector& operator=(const interval& v) {
00280       return sp_vs_assign<scivector,interval,cinterval>(*this,v);
00281     }
00282 
00284     scivector& operator=(const cinterval& v) {
00285       return sp_vs_assign<scivector,cinterval,cinterval>(*this,v);
00286     }
00287 
00289     scivector& operator=(const rvector& v) {
00290       return spf_vv_assign<scivector,rvector,cinterval>(*this,v);
00291     }
00292 
00294     scivector& operator=(const cvector& v) {
00295       return spf_vv_assign<scivector,cvector,cinterval>(*this,v);
00296     }
00297 
00299     scivector& operator=(const ivector& v) {
00300       return spf_vv_assign<scivector,ivector,cinterval>(*this,v);
00301     }
00302 
00304     scivector& operator=(const civector& v) {
00305       return spf_vv_assign<scivector,civector,cinterval>(*this,v);
00306     }
00307 
00309     scivector& operator=(const rvector_slice& v) {
00310       return spf_vv_assign<scivector,rvector_slice,cinterval>(*this,v);
00311     }
00312 
00314     scivector& operator=(const cvector_slice& v) {
00315       return spf_vv_assign<scivector,cvector_slice,cinterval>(*this,v);
00316     }
00317 
00319     scivector& operator=(const ivector_slice& v) {
00320       return spf_vv_assign<scivector,ivector_slice,cinterval>(*this,v);
00321     }
00322 
00324     scivector& operator=(const civector_slice& v) {
00325       return spf_vv_assign<scivector,civector_slice,cinterval>(*this,v);
00326     }
00327 
00329     scivector& operator=(const srvector_slice&);
00331     scivector& operator=(const scvector_slice&);
00333     scivector& operator=(const sivector_slice&);
00335     scivector& operator=(const scivector_slice&);
00336 
00338 
00342     cinterval& operator[](const int i) {
00343 #if(CXSC_INDEX_CHECK)
00344       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector::operator[](const int)"));
00345 #endif
00346       int k;
00347 
00348       for(k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
00349         if(p[k] == i-lb) 
00350           return x[k];
00351       }
00352 
00353       p.insert(p.begin() + k, i-lb);
00354       x.insert(x.begin() + k, cinterval(0.0));
00355 
00356       return x[k];
00357     }
00358 
00360 
00364     cinterval operator[](const int i) const {
00365 #if(CXSC_INDEX_CHECK)
00366       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector::operator[](const int)"));
00367 #endif
00368       return (*this)(i);
00369     }
00370 
00372 
00376     const cinterval operator()(const int i) const {
00377 #if(CXSC_INDEX_CHECK)
00378       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector::operator()(const int)"));
00379 #endif
00380       cinterval r(0.0);
00381 
00382       for(int k=0 ; k<get_nnz() && p[k]<=i-lb ; k++) {
00383         if(p[k] == i-lb) 
00384           r = x[k];
00385       }
00386 
00387       return r; 
00388     }
00389 
00391 
00394     scivector operator()(const intvector& per) {
00395       scivector v(n,get_nnz());
00396       intvector pinv = perminv(per);
00397 
00398       std::map<int,cinterval> work;
00399       for(int i=0 ; i<get_nnz() ; i++)
00400          work.insert(std::make_pair(pinv[Lb(pinv)+p[i]], x[i]));
00401  
00402       for(std::map<int,cinterval>::iterator it=work.begin() ; it!=work.end() ; it++) {
00403          v.p.push_back(it->first);
00404          v.x.push_back(it->second);
00405       }
00406 
00407       return v;
00408     }
00409 
00411 
00417     scivector operator()(const intmatrix& P) {
00418       intvector p = permvec(P);
00419       return (*this)(p);
00420     }
00421 
00423 
00425     scivector_slice operator()(const int, const int);
00426 
00428     scivector& operator*=(const real& s) {
00429       return sp_vs_multassign(*this,s);
00430     }
00431 
00433     scivector& operator*=(const complex& s) {
00434       return sp_vs_multassign(*this,s);
00435     }
00436 
00438     scivector& operator*=(const interval& s) {
00439       return sp_vs_multassign(*this,s);
00440     }
00441 
00443     scivector& operator*=(const cinterval& s) {
00444       return sp_vs_multassign(*this,s);
00445     }
00446 
00448     scivector& operator/=(const real& s) {
00449       return sp_vs_divassign(*this,s);
00450     }
00451 
00453     scivector& operator/=(const complex& s) {
00454       return sp_vs_divassign(*this,s);
00455     }
00456 
00458     scivector& operator/=(const interval& s) {
00459       return sp_vs_divassign(*this,s);
00460     }
00461 
00463     scivector& operator/=(const cinterval& s) {
00464       return sp_vs_divassign(*this,s);
00465     }
00466 
00468     scivector& operator+=(const rvector& v) {
00469       return spf_vv_addassign(*this,v);
00470     }
00471 
00473     scivector& operator+=(const cvector& v) {
00474       return spf_vv_addassign(*this,v);
00475     }
00476 
00478     scivector& operator+=(const ivector& v) {
00479       return spf_vv_addassign(*this,v);
00480     }
00481 
00483     scivector& operator+=(const civector& v) {
00484       return spf_vv_addassign(*this,v);
00485     }
00486 
00488     scivector& operator+=(const rvector_slice& v) {
00489       return spf_vv_addassign(*this,v);
00490     }
00491 
00493     scivector& operator+=(const cvector_slice& v) {
00494       return spf_vv_addassign(*this,v);
00495     }
00496 
00498     scivector& operator+=(const ivector_slice& v) {
00499       return spf_vv_addassign(*this,v);
00500     }
00501 
00503     scivector& operator+=(const civector_slice& v) {
00504       return spf_vv_addassign(*this,v);
00505     }
00506 
00508     scivector& operator+=(const srvector& v) {
00509       return spsp_vv_addassign(*this,v);
00510     }
00511 
00513     scivector& operator+=(const scvector& v) {
00514       return spsp_vv_addassign(*this,v);
00515     }
00516 
00518     scivector& operator+=(const sivector& v) {
00519       return spsp_vv_addassign(*this,v);
00520     }
00521 
00523     scivector& operator+=(const scivector& v) {
00524       return spsp_vv_addassign(*this,v);
00525     }
00526 
00528     scivector& operator-=(const rvector& v) {
00529       return spf_vv_subassign(*this,v);
00530     }
00531 
00533     scivector& operator-=(const cvector& v) {
00534       return spf_vv_subassign(*this,v);
00535     }
00536 
00538     scivector& operator-=(const ivector& v) {
00539       return spf_vv_subassign(*this,v);
00540     }
00541 
00543     scivector& operator-=(const civector& v) {
00544       return spf_vv_subassign(*this,v);
00545     }
00546 
00548     scivector& operator-=(const rvector_slice& v) {
00549       return spf_vv_subassign(*this,v);
00550     }
00551 
00553     scivector& operator-=(const cvector_slice& v) {
00554       return spf_vv_subassign(*this,v);
00555     }
00556 
00558     scivector& operator-=(const ivector_slice& v) {
00559       return spf_vv_subassign(*this,v);
00560     }
00561 
00563     scivector& operator-=(const civector_slice& v) {
00564       return spf_vv_subassign(*this,v);
00565     }
00566 
00568     scivector& operator-=(const srvector& v) {
00569       return spsp_vv_subassign(*this,v);
00570     }
00571 
00573     scivector& operator-=(const scvector& v) {
00574       return spsp_vv_subassign(*this,v);
00575     }
00576 
00578     scivector& operator-=(const sivector& v) {
00579       return spsp_vv_subassign(*this,v);
00580     }
00581 
00583     scivector& operator-=(const scivector& v) {
00584       return spsp_vv_subassign(*this,v);
00585     }
00586 
00588     scivector& operator|=(const rvector& v) {
00589       return spf_vv_hullassign(*this,v);
00590     }
00591 
00593     scivector& operator|=(const cvector& v) {
00594       return spf_vv_hullassign(*this,v);
00595     }
00596 
00598     scivector& operator|=(const ivector& v) {
00599       return spf_vv_hullassign(*this,v);
00600     }
00601 
00603     scivector& operator|=(const civector& v) {
00604       return spf_vv_hullassign(*this,v);
00605     }
00606 
00608     scivector& operator|=(const rvector_slice& v) {
00609       return spf_vv_hullassign(*this,v);
00610     }
00611 
00613     scivector& operator|=(const cvector_slice& v) {
00614       return spf_vv_hullassign(*this,v);
00615     }
00616 
00618     scivector& operator|=(const ivector_slice& v) {
00619       return spf_vv_hullassign(*this,v);
00620     }
00621 
00623     scivector& operator|=(const civector_slice& v) {
00624       return spf_vv_hullassign(*this,v);
00625     }
00626 
00628     scivector& operator|=(const srvector& v) {
00629       return spsp_vv_hullassign(*this,v);
00630     }
00631 
00633     scivector& operator|=(const scvector& v) {
00634       return spsp_vv_hullassign(*this,v);
00635     }
00636 
00638     scivector& operator|=(const sivector& v) {
00639       return spsp_vv_hullassign(*this,v);
00640     }
00641 
00643     scivector& operator|=(const scivector& v) {
00644       return spsp_vv_hullassign(*this,v);
00645     }
00646 
00648     scivector& operator&=(const ivector& v) {
00649       return spf_vv_intersectassign(*this,v);
00650     }
00651 
00653     scivector& operator&=(const civector& v) {
00654       return spf_vv_intersectassign(*this,v);
00655     }
00656 
00658     scivector& operator&=(const ivector_slice& v) {
00659       return spf_vv_intersectassign(*this,v);
00660     }
00661 
00663     scivector& operator&=(const civector_slice& v) {
00664       return spf_vv_intersectassign(*this,v);
00665     }
00666 
00668     scivector& operator&=(const sivector& v) {
00669       return spsp_vv_intersectassign(*this,v);
00670     }
00671 
00673     scivector& operator&=(const scivector& v) {
00674       return spsp_vv_intersectassign(*this,v);
00675     }
00676 
00677 
00679     scivector& operator+=(const srvector_slice&);
00681     scivector& operator+=(const scvector_slice&);
00683     scivector& operator+=(const sivector_slice&);
00685     scivector& operator+=(const scivector_slice&);
00687     scivector& operator-=(const srvector_slice&);
00689     scivector& operator-=(const scvector_slice&);
00691     scivector& operator-=(const sivector_slice&);
00693     scivector& operator-=(const scivector_slice&);
00695     scivector& operator|=(const srvector_slice&);
00697     scivector& operator|=(const scvector_slice&);
00699     scivector& operator|=(const sivector_slice&);
00701     scivector& operator|=(const scivector_slice&);
00703     scivector& operator&=(const sivector_slice&);
00705     scivector& operator&=(const scivector_slice&);
00706 
00707     friend void SetLb(scivector&, const int);
00708     friend void SetUb(scivector&, const int);
00709     friend int Lb(const scivector&);
00710     friend int Ub(const scivector&);
00711     friend sivector Re(const scivector&);
00712     friend sivector Im(const scivector&);
00713     friend scvector Inf(const scivector&);
00714     friend scvector Sup(const scivector&);
00715     friend srvector InfRe(const scivector&);
00716     friend srvector InfIm(const scivector&);
00717     friend srvector SupRe(const scivector&);
00718     friend srvector SupIm(const scivector&);
00719     friend scivector conj(const scivector&);
00720     friend scivector conj(const scivector_slice&);
00721     friend sivector abs(const scivector&);
00722     friend scvector mid(const scivector&);
00723     friend scvector diam(const scivector&);
00724     friend int VecLen(const scivector&);
00725 
00726     friend class srvector_slice;
00727     friend class scvector_slice;
00728     friend class sivector_slice;
00729     friend class scivector_slice;
00730     friend class civector;
00731     friend class civector_slice;
00732 
00733 #include "vector_friend_declarations.inl"
00734 };
00735 
00736 inline civector::civector(const srvector& v) {
00737   l = v.lb;
00738   u = v.ub;
00739   size = v.n;
00740   dat = new cinterval[v.n];
00741   for(int i=0 ; i<v.n ; i++)
00742     dat[i] = 0.0;
00743   for(int i=0 ; i<v.get_nnz() ; i++)
00744     dat[v.p[i]] = v.x[i];
00745 }
00746 
00747 inline civector::civector(const scvector& v) {
00748   l = v.lb;
00749   u = v.ub;
00750   size = v.n;
00751   dat = new cinterval[v.n];
00752   for(int i=0 ; i<v.n ; i++)
00753     dat[i] = 0.0;
00754   for(int i=0 ; i<v.get_nnz() ; i++)
00755     dat[v.p[i]] = v.x[i];
00756 }
00757 
00758 inline civector::civector(const sivector& v) {
00759   l = v.lb;
00760   u = v.ub;
00761   size = v.n;
00762   dat = new cinterval[v.n];
00763   for(int i=0 ; i<v.n ; i++)
00764     dat[i] = 0.0;
00765   for(int i=0 ; i<v.get_nnz() ; i++)
00766     dat[v.p[i]] = v.x[i];
00767 }
00768 
00769 inline civector::civector(const scivector& v) {
00770   l = v.lb;
00771   u = v.ub;
00772   size = v.n;
00773   dat = new cinterval[v.n];
00774   for(int i=0 ; i<v.n ; i++)
00775     dat[i] = 0.0;
00776   for(int i=0 ; i<v.get_nnz() ; i++)
00777     dat[v.p[i]] = v.x[i];
00778 }
00779 
00780 inline civector& civector::operator=(const scivector& v) {
00781   return fsp_vv_assign<civector,scivector,cinterval>(*this,v);
00782 }
00783 
00784 inline civector& civector::operator=(const scivector_slice& v) {
00785   return fsl_vv_assign<civector,scivector_slice,cinterval>(*this,v);
00786 }
00787 
00788 inline civector& civector::operator=(const srvector& v) {
00789   return fsp_vv_assign<civector,srvector,cinterval>(*this,v);
00790 }
00791 
00792 inline civector& civector::operator=(const srvector_slice& v) {
00793   return fsl_vv_assign<civector,srvector_slice,cinterval>(*this,v);
00794 }
00795 
00796 inline civector& civector::operator=(const scvector& v) {
00797   return fsp_vv_assign<civector,scvector,cinterval>(*this,v);
00798 }
00799 
00800 inline civector& civector::operator=(const scvector_slice& v) {
00801   return fsl_vv_assign<civector,scvector_slice,cinterval>(*this,v);
00802 }
00803 
00804 inline civector& civector::operator=(const sivector& v) {
00805   return fsp_vv_assign<civector,sivector,cinterval>(*this,v);
00806 }
00807 
00808 inline civector& civector::operator=(const sivector_slice& v) {
00809   return fsl_vv_assign<civector,sivector_slice,cinterval>(*this,v);
00810 }
00811 
00812 
00814 
00817 inline void SetLb(scivector& v, const int i) {
00818   v.lb = i;
00819   v.ub = v.lb + v.n - 1;
00820 }
00821 
00823 
00826 inline void SetUb(scivector& v, const int j) {
00827   v.ub = j;
00828   v.lb = v.ub - v.n + 1;
00829 }
00830 
00832 inline int Lb(const scivector& v) {
00833   return v.lb;
00834 }
00835 
00837 inline int Ub(const scivector& v) {
00838   return v.ub;
00839 }
00840 
00842 inline void Resize(scivector& v) {
00843   sp_v_resize(v);
00844 }
00845 
00847 
00850 inline void Resize(scivector& v, const int n) {
00851   sp_v_resize(v,n);
00852 }
00853 
00855 
00859 inline void Resize(scivector& v, const int l, const int u) {
00860   sp_v_resize(v,l,u);
00861 }
00862 
00864 inline sivector abs(const scivector& v) {
00865   sivector res(v.n, v.get_nnz());
00866   res.lb = v.lb;
00867   res.ub = v.ub;
00868   res.p = v.p;
00869   for(int i=0 ; i<v.get_nnz() ; i++)
00870     res.x.push_back(abs(v.x[i]));
00871   return res;
00872 }
00873 
00875 inline scivector conj(const scivector& v) {
00876   scivector res(v.n, v.get_nnz());
00877   res.lb = v.lb;
00878   res.ub = v.ub;
00879   res.p = v.p;
00880   for(int i=0 ; i<v.get_nnz() ; i++)
00881     res.x.push_back(conj(v.x[i]));
00882   return res;
00883 }
00884 
00886 inline scvector mid(const scivector& v) {
00887   scvector res(v.n, v.get_nnz());
00888   res.lb = v.lb;
00889   res.ub = v.ub;
00890   res.p = v.p;
00891   for(int i=0 ; i<v.get_nnz() ; i++)
00892     res.x.push_back(mid(v.x[i]));
00893   return res;
00894 }
00895 
00897 inline scvector diam(const scivector& v) {
00898   scvector res(v.n, v.get_nnz());
00899   res.lb = v.lb;
00900   res.ub = v.ub;
00901   res.p = v.p;
00902   for(int i=0 ; i<v.get_nnz() ; i++)
00903     res.x.push_back(diam(v.x[i]));
00904   return res;
00905 }
00906 
00908 inline sivector Re(const scivector& v) {
00909   sivector res(v.n, v.get_nnz());
00910   res.lb = v.lb;
00911   res.ub = v.ub;
00912   res.p  = v.p;
00913   for(int i=0 ; i<v.get_nnz() ; i++)
00914     res.x[i] = Re(v.x[i]);
00915   return res;
00916 }
00917 
00919 inline sivector Im(const scivector& v) {
00920   sivector res(v.n, v.get_nnz());
00921   res.lb = v.lb;
00922   res.ub = v.ub;
00923   res.p  = v.p;
00924   for(int i=0 ; i<v.get_nnz() ; i++)
00925     res.x[i] = Im(v.x[i]);
00926   return res;
00927 }
00928 
00930 inline scvector Inf(const scivector& v) {
00931   scvector res(v.n, v.get_nnz());
00932   res.lb = v.lb;
00933   res.ub = v.ub;
00934   res.p  = v.p;
00935   for(int i=0 ; i<v.get_nnz() ; i++)
00936     res.x[i] = Inf(v.x[i]);
00937   return res;
00938 }
00939 
00941 inline scvector Sup(const scivector& v) {
00942   scvector res(v.n, v.get_nnz());
00943   res.lb = v.lb;
00944   res.ub = v.ub;
00945   res.p  = v.p;
00946   for(int i=0 ; i<v.get_nnz() ; i++)
00947     res.x[i] = Sup(v.x[i]);
00948   return res;
00949 }
00950 
00952 inline srvector InfRe(const scivector& v) {
00953   srvector res(v.n, v.get_nnz());
00954   res.lb = v.lb;
00955   res.ub = v.ub;
00956   res.p  = v.p;
00957   for(int i=0 ; i<v.get_nnz() ; i++)
00958     res.x[i] = InfRe(v.x[i]);
00959   return res;
00960 }
00961 
00963 inline srvector InfIm(const scivector& v) {
00964   srvector res(v.n, v.get_nnz());
00965   res.lb = v.lb;
00966   res.ub = v.ub;
00967   res.p  = v.p;
00968   for(int i=0 ; i<v.get_nnz() ; i++)
00969     res.x[i] = InfIm(v.x[i]);
00970   return res;
00971 }
00972 
00974 inline srvector SupRe(const scivector& v) {
00975   srvector res(v.n, v.get_nnz());
00976   res.lb = v.lb;
00977   res.ub = v.ub;
00978   res.p  = v.p;
00979   for(int i=0 ; i<v.get_nnz() ; i++)
00980     res.x[i] = SupRe(v.x[i]);
00981   return res;
00982 }
00983 
00985 inline srvector SupIm(const scivector& v) {
00986   srvector res(v.n, v.get_nnz());
00987   res.lb = v.lb;
00988   res.ub = v.ub;
00989   res.p  = v.p;
00990   for(int i=0 ; i<v.get_nnz() ; i++)
00991     res.x[i] = SupIm(v.x[i]);
00992   return res;
00993 }
00994 
00996 inline int VecLen(const scivector& v) {
00997   return v.n;
00998 }
00999 
01001 inline bool in (const scivector& v1, const scivector& v2) {
01002   for(int i=0 ; i<VecLen(v1) ; i++)
01003     if(!in(v1(i+Lb(v1)), v2(i+Lb(v2)))) return false;
01004   return true;
01005 }
01006 
01008 inline scivector operator-(const scivector& v) {
01009   return sp_v_negative(v);
01010 }
01011 
01013 
01019 inline cinterval operator*(const scivector& v1, const cvector& v2) {
01020   return spf_vv_mult<scivector,cvector,cinterval,sparse_cidot>(v1,v2);
01021 }
01022 
01024 
01030 inline cinterval operator*(const scivector& v1, const rvector& v2) {
01031   return spf_vv_mult<scivector,rvector,cinterval,sparse_cidot>(v1,v2);
01032 }
01033 
01035 
01041 inline cinterval operator*(const scivector& v1, const ivector& v2) {
01042   return spf_vv_mult<scivector,ivector,cinterval,sparse_cidot>(v1,v2);
01043 }
01044 
01046 
01052 inline cinterval operator*(const scivector& v1, const civector& v2) {
01053   return spf_vv_mult<scivector,civector,cinterval,sparse_cidot>(v1,v2);
01054 }
01055 
01057 
01063 inline cinterval operator*(const scvector& v1, const civector& v2) {
01064   return spf_vv_mult<scvector,civector,cinterval,sparse_cidot>(v1,v2);
01065 }
01066 
01068 
01074 inline cinterval operator*(const srvector& v1, const civector& v2) {
01075   return spf_vv_mult<srvector,civector,cinterval,sparse_cidot>(v1,v2);
01076 }
01077 
01079 
01085 inline cinterval operator*(const sivector& v1, const civector& v2) {
01086   return spf_vv_mult<sivector,civector,cinterval,sparse_cidot>(v1,v2);
01087 }
01088 
01090 
01096 inline cinterval operator*(const scvector& v1, const ivector& v2) {
01097   return spf_vv_mult<scvector,ivector,cinterval,sparse_cidot>(v1,v2);
01098 }
01099 
01101 
01107 inline cinterval operator*(const sivector& v1, const cvector& v2) {
01108   return spf_vv_mult<sivector,cvector,cinterval,sparse_cidot>(v1,v2);
01109 }
01110 
01112 
01118 inline cinterval operator*(const rvector& v1, const scivector& v2) {
01119   return fsp_vv_mult<rvector,scivector,cinterval,sparse_cidot>(v1,v2);
01120 }
01121 
01123 
01129 inline cinterval operator*(const cvector& v1, const scivector& v2) {
01130   return fsp_vv_mult<cvector,scivector,cinterval,sparse_cidot>(v1,v2);
01131 }
01132 
01134 
01140 inline cinterval operator*(const ivector& v1, const scivector& v2) {
01141   return fsp_vv_mult<ivector,scivector,cinterval,sparse_cidot>(v1,v2);
01142 }
01143 
01145 
01151 inline cinterval operator*(const civector& v1, const scivector& v2) {
01152   return fsp_vv_mult<civector,scivector,cinterval,sparse_cidot>(v1,v2);
01153 }
01154 
01156 
01162 inline cinterval operator*(const civector& v1, const srvector& v2) {
01163   return fsp_vv_mult<civector,srvector,cinterval,sparse_cidot>(v1,v2);
01164 }
01165 
01167 
01173 inline cinterval operator*(const civector& v1, const scvector& v2) {
01174   return fsp_vv_mult<civector,scvector,cinterval,sparse_cidot>(v1,v2);
01175 }
01176 
01178 
01184 inline cinterval operator*(const civector& v1, const sivector& v2) {
01185   return fsp_vv_mult<civector,sivector,cinterval,sparse_cidot>(v1,v2);
01186 }
01187 
01189 
01195 inline cinterval operator*(const ivector& v1, const scvector& v2) {
01196   return fsp_vv_mult<ivector,scvector,cinterval,sparse_cidot>(v1,v2);
01197 }
01198 
01200 
01206 inline cinterval operator*(const cvector& v1, const sivector& v2) {
01207   return fsp_vv_mult<cvector,sivector,cinterval,sparse_cidot>(v1,v2);
01208 }
01209 
01211 
01217 inline cinterval operator*(const scivector& v1, const cvector_slice& v2) {
01218   return spf_vv_mult<scivector,cvector_slice,cinterval,sparse_cidot>(v1,v2);
01219 }
01220 
01222 
01228 inline cinterval operator*(const scivector& v1, const rvector_slice& v2) {
01229   return spf_vv_mult<scivector,rvector_slice,cinterval,sparse_cidot>(v1,v2);
01230 }
01231 
01233 
01239 inline cinterval operator*(const scivector& v1, const ivector_slice& v2) {
01240   return spf_vv_mult<scivector,ivector_slice,cinterval,sparse_cidot>(v1,v2);
01241 }
01242 
01244 
01250 inline cinterval operator*(const scivector& v1, const civector_slice& v2) {
01251   return spf_vv_mult<scivector,civector_slice,cinterval,sparse_cidot>(v1,v2);
01252 }
01253 
01255 
01261 inline cinterval operator*(const scvector& v1, const civector_slice& v2) {
01262   return spf_vv_mult<scvector,civector_slice,cinterval,sparse_cidot>(v1,v2);
01263 }
01264 
01266 
01272 inline cinterval operator*(const srvector& v1, const civector_slice& v2) {
01273   return spf_vv_mult<srvector,civector_slice,cinterval,sparse_cidot>(v1,v2);
01274 }
01275 
01277 
01283 inline cinterval operator*(const sivector& v1, const civector_slice& v2) {
01284   return spf_vv_mult<sivector,civector_slice,cinterval,sparse_cidot>(v1,v2);
01285 }
01286 
01288 
01294 inline cinterval operator*(const scvector& v1, const ivector_slice& v2) {
01295   return spf_vv_mult<scvector,ivector_slice,cinterval,sparse_cidot>(v1,v2);
01296 }
01297 
01299 
01305 inline cinterval operator*(const sivector& v1, const cvector_slice& v2) {
01306   return spf_vv_mult<sivector,cvector_slice,cinterval,sparse_cidot>(v1,v2);
01307 }
01308 
01310 
01316 inline cinterval operator*(const rvector_slice& v1, const scivector& v2) {
01317   return fsp_vv_mult<rvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
01318 }
01319 
01321 
01327 inline cinterval operator*(const cvector_slice& v1, const scivector& v2) {
01328   return fsp_vv_mult<cvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
01329 }
01330 
01332 
01338 inline cinterval operator*(const ivector_slice& v1, const scivector& v2) {
01339   return fsp_vv_mult<ivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
01340 }
01341 
01343 
01349 inline cinterval operator*(const civector_slice& v1, const scivector& v2) {
01350   return fsp_vv_mult<civector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
01351 }
01352 
01354 
01360 inline cinterval operator*(const civector_slice& v1, const srvector& v2) {
01361   return fsp_vv_mult<civector_slice,srvector,cinterval,sparse_cidot>(v1,v2);
01362 }
01363 
01365 
01371 inline cinterval operator*(const civector_slice& v1, const scvector& v2) {
01372   return fsp_vv_mult<civector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
01373 }
01374 
01376 
01382 inline cinterval operator*(const civector_slice& v1, const sivector& v2) {
01383   return fsp_vv_mult<civector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
01384 }
01385 
01387 
01393 inline cinterval operator*(const ivector_slice& v1, const scvector& v2) {
01394   return fsp_vv_mult<ivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
01395 }
01396 
01398 
01404 inline cinterval operator*(const cvector_slice& v1, const sivector& v2) {
01405   return fsp_vv_mult<cvector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
01406 }
01407 
01409 
01415 inline cinterval operator*(const scivector& v1, const srvector& v2) {
01416   return spsp_vv_mult<scivector,srvector,cinterval,sparse_cidot>(v1,v2);
01417 }
01418 
01420 
01426 inline cinterval operator*(const scivector& v1, const scvector& v2) {
01427   return spsp_vv_mult<scivector,scvector,cinterval,sparse_cidot>(v1,v2);
01428 }
01429 
01431 
01437 inline cinterval operator*(const scivector& v1, const sivector& v2) {
01438   return spsp_vv_mult<scivector,sivector,cinterval,sparse_cidot>(v1,v2);
01439 }
01440 
01442 
01448 inline cinterval operator*(const scivector& v1, const scivector& v2) {
01449   return spsp_vv_mult<scivector,scivector,cinterval,sparse_cidot>(v1,v2);
01450 }
01451 
01453 
01459 inline cinterval operator*(const srvector& v1, const scivector& v2) {
01460   return spsp_vv_mult<srvector,scivector,cinterval,sparse_cidot>(v1,v2);
01461 }
01462 
01464 
01470 inline cinterval operator*(const scvector& v1, const scivector& v2) {
01471   return spsp_vv_mult<scvector,scivector,cinterval,sparse_cidot>(v1,v2);
01472 }
01473 
01475 
01481 inline cinterval operator*(const sivector& v1, const scivector& v2) {
01482   return spsp_vv_mult<sivector,scivector,cinterval,sparse_cidot>(v1,v2);
01483 }
01484 
01486 
01492 inline cinterval operator*(const scvector& v1, const sivector& v2) {
01493   return spsp_vv_mult<scvector,sivector,cinterval,sparse_cidot>(v1,v2);
01494 }
01495 
01497 
01503 inline cinterval operator*(const sivector& v1, const scvector& v2) {
01504   return spsp_vv_mult<sivector,scvector,cinterval,sparse_cidot>(v1,v2);
01505 }
01506 
01508 inline scivector operator*(const scivector& v, const real& s) {
01509   return sp_vs_mult<scivector,real,scivector>(v,s);
01510 }
01511 
01513 inline scivector operator*(const scivector& v, const complex& s) {
01514   return sp_vs_mult<scivector,complex,scivector>(v,s);
01515 }
01516 
01518 inline scivector operator*(const scivector& v, const interval& s) {
01519   return sp_vs_mult<scivector,interval,scivector>(v,s);
01520 }
01521 
01523 inline scivector operator*(const scivector& v, const cinterval& s) {
01524   return sp_vs_mult<scivector,cinterval,scivector>(v,s);
01525 }
01526 
01528 inline scivector operator*(const scvector& v, const interval& s) {
01529   return sp_vs_mult<scvector,interval,scivector>(v,s);
01530 }
01531 
01533 inline scivector operator*(const sivector& v, const complex& s) {
01534   return sp_vs_mult<sivector,complex,scivector>(v,s);
01535 }
01536 
01538 inline scivector operator/(const scivector& v, const real& s) {
01539   return sp_vs_div<scivector,real,scivector>(v,s);
01540 }
01541 
01543 inline scivector operator/(const scivector& v, const complex& s) {
01544   return sp_vs_div<scivector,complex,scivector>(v,s);
01545 }
01546 
01548 inline scivector operator/(const scivector& v, const interval& s) {
01549   return sp_vs_div<scivector,interval,scivector>(v,s);
01550 }
01551 
01553 inline scivector operator/(const scivector& v, const cinterval& s) {
01554   return sp_vs_div<scivector,cinterval,scivector>(v,s);
01555 }
01556 
01558 inline scivector operator/(const srvector& v, const cinterval& s) {
01559   return sp_vs_div<srvector,cinterval,scivector>(v,s);
01560 }
01561 
01563 inline scivector operator/(const scvector& v, const cinterval& s) {
01564   return sp_vs_div<scvector,cinterval,scivector>(v,s);
01565 }
01566 
01568 inline scivector operator/(const sivector& v, const cinterval& s) {
01569   return sp_vs_div<sivector,cinterval,scivector>(v,s);
01570 }
01571 
01573 inline scivector operator/(const scvector& v, const interval& s) {
01574   return sp_vs_div<scvector,interval,scivector>(v,s);
01575 }
01576 
01578 inline scivector operator/(const sivector& v, const complex& s) {
01579   return sp_vs_div<sivector,complex,scivector>(v,s);
01580 }
01581 
01583 inline scivector operator*(const real& s, const scivector& v) {
01584   return sp_sv_mult<real,scivector,scivector>(s,v);
01585 }
01586 
01588 inline scivector operator*(const complex& s, const scivector& v) {
01589   return sp_sv_mult<complex,scivector,scivector>(s,v);
01590 }
01591 
01593 inline scivector operator*(const interval& s, const scivector& v) {
01594   return sp_sv_mult<interval,scivector,scivector>(s,v);
01595 }
01596 
01598 inline scivector operator*(const cinterval& s, const srvector& v) {
01599   return sp_sv_mult<cinterval,srvector,scivector>(s,v);
01600 }
01601 
01603 inline scivector operator*(const cinterval& s, const sivector& v) {
01604   return sp_sv_mult<cinterval,sivector,scivector>(s,v);
01605 }
01606 
01608 inline scivector operator*(const cinterval& s, const scvector& v) {
01609   return sp_sv_mult<cinterval,scvector,scivector>(s,v);
01610 }
01611 
01613 inline scivector operator*(const cinterval& s, const scivector& v) {
01614   return sp_sv_mult<cinterval,scivector,scivector>(s,v);
01615 }
01616 
01618 inline scivector operator*(const srvector& v, const cinterval& s) {
01619   return sp_sv_mult<cinterval,srvector,scivector>(s,v);
01620 }
01621 
01623 inline scivector operator*(const sivector& v, const cinterval& s) {
01624   return sp_sv_mult<cinterval,sivector,scivector>(s,v);
01625 }
01626 
01628 inline scivector operator*(const scvector& v, const cinterval& s) {
01629   return sp_sv_mult<cinterval,scvector,scivector>(s,v);
01630 }
01631 
01633 inline scivector operator*(const complex& s, const sivector& v) {
01634   return sp_sv_mult<complex,sivector,scivector>(s,v);
01635 }
01636 
01638 inline scivector operator*(const interval& s, const scvector& v) {
01639   return sp_sv_mult<interval,scvector,scivector>(s,v);
01640 }
01641 
01643 inline civector operator+(const civector& v1, const srvector& v2) {
01644   return fsp_vv_add<civector,srvector,civector>(v1,v2);
01645 }
01646 
01648 inline civector operator+(const civector& v1, const scvector& v2) {
01649   return fsp_vv_add<civector,scvector,civector>(v1,v2);
01650 }
01651 
01653 inline civector operator+(const civector& v1, const sivector& v2) {
01654   return fsp_vv_add<civector,sivector,civector>(v1,v2);
01655 }
01656 
01658 inline civector operator+(const civector& v1, const scivector& v2) {
01659   return fsp_vv_add<civector,scivector,civector>(v1,v2);
01660 }
01661 
01663 inline civector operator+(const rvector& v1, const scivector& v2) {
01664   return fsp_vv_add<rvector,scivector,civector>(v1,v2);
01665 }
01666 
01668 inline civector operator+(const cvector& v1, const scivector& v2) {
01669   return fsp_vv_add<cvector,scivector,civector>(v1,v2);
01670 }
01671 
01673 inline civector operator+(const ivector& v1, const scivector& v2) {
01674   return fsp_vv_add<ivector,scivector,civector>(v1,v2);
01675 }
01676 
01678 inline civector operator+(const cvector& v1, const sivector& v2) {
01679   return fsp_vv_add<cvector,sivector,civector>(v1,v2);
01680 }
01681 
01683 inline civector operator+(const ivector& v1, const scvector& v2) {
01684   return fsp_vv_add<ivector,scvector,civector>(v1,v2);
01685 }
01686 
01688 inline civector operator+(const scivector& v1, const rvector& v2) {
01689   return spf_vv_add<scivector,rvector,civector>(v1,v2);
01690 }
01691 
01693 inline civector operator+(const scivector& v1, const cvector& v2) {
01694   return spf_vv_add<scivector,cvector,civector>(v1,v2);
01695 }
01696 
01698 inline civector operator+(const scivector& v1, const ivector& v2) {
01699   return spf_vv_add<scivector,ivector,civector>(v1,v2);
01700 }
01701 
01703 inline civector operator+(const scivector& v1, const civector& v2) {
01704   return spf_vv_add<scivector,civector,civector>(v1,v2);
01705 }
01706 
01708 inline civector operator+(const srvector& v1, const civector& v2) {
01709   return spf_vv_add<srvector,civector,civector>(v1,v2);
01710 }
01711 
01713 inline civector operator+(const scvector& v1, const civector& v2) {
01714   return spf_vv_add<scvector,civector,civector>(v1,v2);
01715 }
01716 
01718 inline civector operator+(const sivector& v1, const civector& v2) {
01719   return spf_vv_add<sivector,civector,civector>(v1,v2);
01720 }
01721 
01723 inline civector operator+(const scvector& v1, const ivector& v2) {
01724   return spf_vv_add<scvector,ivector,civector>(v1,v2);
01725 }
01726 
01728 inline civector operator+(const sivector& v1, const cvector& v2) {
01729   return spf_vv_add<sivector,cvector,civector>(v1,v2);
01730 }
01731 
01733 inline civector operator+(const civector_slice& v1, const srvector& v2) {
01734   return fsp_vv_add<civector_slice,srvector,civector>(v1,v2);
01735 }
01736 
01738 inline civector operator+(const civector_slice& v1, const scvector& v2) {
01739   return fsp_vv_add<civector_slice,scvector,civector>(v1,v2);
01740 }
01741 
01743 inline civector operator+(const civector_slice& v1, const sivector& v2) {
01744   return fsp_vv_add<civector_slice,sivector,civector>(v1,v2);
01745 }
01746 
01748 inline civector operator+(const civector_slice& v1, const scivector& v2) {
01749   return fsp_vv_add<civector_slice,scivector,civector>(v1,v2);
01750 }
01751 
01753 inline civector operator+(const rvector_slice& v1, const scivector& v2) {
01754   return fsp_vv_add<rvector_slice,scivector,civector>(v1,v2);
01755 }
01756 
01758 inline civector operator+(const cvector_slice& v1, const scivector& v2) {
01759   return fsp_vv_add<cvector_slice,scivector,civector>(v1,v2);
01760 }
01761 
01763 inline civector operator+(const ivector_slice& v1, const scivector& v2) {
01764   return fsp_vv_add<ivector_slice,scivector,civector>(v1,v2);
01765 }
01766 
01768 inline civector operator+(const cvector_slice& v1, const sivector& v2) {
01769   return fsp_vv_add<cvector_slice,sivector,civector>(v1,v2);
01770 }
01771 
01773 inline civector operator+(const ivector_slice& v1, const scvector& v2) {
01774   return fsp_vv_add<ivector_slice,scvector,civector>(v1,v2);
01775 }
01776 
01778 inline civector operator+(const scivector& v1, const rvector_slice& v2) {
01779   return spf_vv_add<scivector,rvector_slice,civector>(v1,v2);
01780 }
01781 
01783 inline civector operator+(const scivector& v1, const cvector_slice& v2) {
01784   return spf_vv_add<scivector,cvector_slice,civector>(v1,v2);
01785 }
01786 
01788 inline civector operator+(const scivector& v1, const ivector_slice& v2) {
01789   return spf_vv_add<scivector,ivector_slice,civector>(v1,v2);
01790 }
01791 
01793 inline civector operator+(const scivector& v1, const civector_slice& v2) {
01794   return spf_vv_add<scivector,civector_slice,civector>(v1,v2);
01795 }
01796 
01798 inline civector operator+(const srvector& v1, const civector_slice& v2) {
01799   return spf_vv_add<srvector,civector_slice,civector>(v1,v2);
01800 }
01801 
01803 inline civector operator+(const scvector& v1, const civector_slice& v2) {
01804   return spf_vv_add<scvector,civector_slice,civector>(v1,v2);
01805 }
01806 
01808 inline civector operator+(const sivector& v1, const civector_slice& v2) {
01809   return spf_vv_add<sivector,civector_slice,civector>(v1,v2);
01810 }
01811 
01813 inline civector operator+(const scvector& v1, const ivector_slice& v2) {
01814   return spf_vv_add<scvector,ivector_slice,civector>(v1,v2);
01815 }
01816 
01818 inline civector operator+(const sivector& v1, const cvector_slice& v2) {
01819   return spf_vv_add<sivector,cvector_slice,civector>(v1,v2);
01820 }
01821 
01823 inline scivector operator+(const scivector& v1, const srvector& v2) {
01824   return spsp_vv_add<scivector,srvector,scivector,cinterval>(v1,v2);
01825 }
01826 
01828 inline scivector operator+(const scivector& v1, const scvector& v2) {
01829   return spsp_vv_add<scivector,scvector,scivector,cinterval>(v1,v2);
01830 }
01831 
01833 inline scivector operator+(const scivector& v1, const sivector& v2) {
01834   return spsp_vv_add<scivector,sivector,scivector,cinterval>(v1,v2);
01835 }
01836 
01838 inline scivector operator+(const scivector& v1, const scivector& v2) {
01839   return spsp_vv_add<scivector,scivector,scivector,cinterval>(v1,v2);
01840 }
01841 
01843 inline scivector operator+(const srvector& v1, const scivector& v2) {
01844   return spsp_vv_add<srvector,scivector,scivector,cinterval>(v1,v2);
01845 }
01846 
01848 inline scivector operator+(const scvector& v1, const scivector& v2) {
01849   return spsp_vv_add<scvector,scivector,scivector,cinterval>(v1,v2);
01850 }
01851 
01853 inline scivector operator+(const sivector& v1, const scivector& v2) {
01854   return spsp_vv_add<sivector,scivector,scivector,cinterval>(v1,v2);
01855 }
01856 
01858 inline scivector operator+(const scvector& v1, const sivector& v2) {
01859   return spsp_vv_add<scvector,sivector,scivector,cinterval>(v1,v2);
01860 }
01861 
01863 inline scivector operator+(const sivector& v1, const scvector& v2) {
01864   return spsp_vv_add<sivector,scvector,scivector,cinterval>(v1,v2);
01865 }
01866 
01868 inline civector operator-(const civector& v1, const srvector& v2) {
01869   return fsp_vv_sub<civector,srvector,civector>(v1,v2);
01870 }
01871 
01873 inline civector operator-(const civector& v1, const sivector& v2) {
01874   return fsp_vv_sub<civector,sivector,civector>(v1,v2);
01875 }
01876 
01878 inline civector operator-(const civector& v1, const scvector& v2) {
01879   return fsp_vv_sub<civector,scvector,civector>(v1,v2);
01880 }
01881 
01883 inline civector operator-(const civector& v1, const scivector& v2) {
01884   return fsp_vv_sub<civector,scivector,civector>(v1,v2);
01885 }
01886 
01888 inline civector operator-(const rvector& v1, const scivector& v2) {
01889   return fsp_vv_sub<rvector,scivector,civector>(v1,v2);
01890 }
01891 
01893 inline civector operator-(const cvector& v1, const scivector& v2) {
01894   return fsp_vv_sub<cvector,scivector,civector>(v1,v2);
01895 }
01896 
01898 inline civector operator-(const ivector& v1, const scivector& v2) {
01899   return fsp_vv_sub<ivector,scivector,civector>(v1,v2);
01900 }
01901 
01903 inline civector operator-(const cvector& v1, const sivector& v2) {
01904   return fsp_vv_sub<cvector,sivector,civector>(v1,v2);
01905 }
01906 
01908 inline civector operator-(const ivector& v1, const scvector& v2) {
01909   return fsp_vv_sub<ivector,scvector,civector>(v1,v2);
01910 }
01911 
01913 inline civector operator-(const scivector& v1, const rvector& v2) {
01914   return spf_vv_sub<scivector,rvector,civector>(v1,v2);
01915 }
01916 
01918 inline civector operator-(const scivector& v1, const cvector& v2) {
01919   return spf_vv_sub<scivector,cvector,civector>(v1,v2);
01920 }
01921 
01923 inline civector operator-(const scivector& v1, const ivector& v2) {
01924   return spf_vv_sub<scivector,ivector,civector>(v1,v2);
01925 }
01926 
01928 inline civector operator-(const scivector& v1, const civector& v2) {
01929   return spf_vv_sub<scivector,civector,civector>(v1,v2);
01930 }
01931 
01933 inline civector operator-(const srvector& v1, const civector& v2) {
01934   return spf_vv_sub<srvector,civector,civector>(v1,v2);
01935 }
01936 
01938 inline civector operator-(const scvector& v1, const civector& v2) {
01939   return spf_vv_sub<scvector,civector,civector>(v1,v2);
01940 }
01941 
01943 inline civector operator-(const sivector& v1, const civector& v2) {
01944   return spf_vv_sub<sivector,civector,civector>(v1,v2);
01945 }
01946 
01948 inline civector operator-(const scvector& v1, const ivector& v2) {
01949   return spf_vv_sub<scvector,ivector,civector>(v1,v2);
01950 }
01951 
01953 inline civector operator-(const sivector& v1, const cvector& v2) {
01954   return spf_vv_sub<sivector,cvector,civector>(v1,v2);
01955 }
01956 
01958 inline civector operator-(const civector_slice& v1, const srvector& v2) {
01959   return fsp_vv_sub<civector_slice,srvector,civector>(v1,v2);
01960 }
01961 
01963 inline civector operator-(const civector_slice& v1, const sivector& v2) {
01964   return fsp_vv_sub<civector_slice,sivector,civector>(v1,v2);
01965 }
01966 
01968 inline civector operator-(const civector_slice& v1, const scvector& v2) {
01969   return fsp_vv_sub<civector_slice,scvector,civector>(v1,v2);
01970 }
01971 
01973 inline civector operator-(const civector_slice& v1, const scivector& v2) {
01974   return fsp_vv_sub<civector_slice,scivector,civector>(v1,v2);
01975 }
01976 
01978 inline civector operator-(const rvector_slice& v1, const scivector& v2) {
01979   return fsp_vv_sub<rvector_slice,scivector,civector>(v1,v2);
01980 }
01981 
01983 inline civector operator-(const cvector_slice& v1, const scivector& v2) {
01984   return fsp_vv_sub<cvector_slice,scivector,civector>(v1,v2);
01985 }
01986 
01988 inline civector operator-(const ivector_slice& v1, const scivector& v2) {
01989   return fsp_vv_sub<ivector_slice,scivector,civector>(v1,v2);
01990 }
01991 
01993 inline civector operator-(const cvector_slice& v1, const sivector& v2) {
01994   return fsp_vv_sub<cvector_slice,sivector,civector>(v1,v2);
01995 }
01996 
01998 inline civector operator-(const ivector_slice& v1, const scvector& v2) {
01999   return fsp_vv_sub<ivector_slice,scvector,civector>(v1,v2);
02000 }
02001 
02003 inline civector operator-(const scivector& v1, const rvector_slice& v2) {
02004   return spf_vv_sub<scivector,rvector_slice,civector>(v1,v2);
02005 }
02006 
02008 inline civector operator-(const scivector& v1, const cvector_slice& v2) {
02009   return spf_vv_sub<scivector,cvector_slice,civector>(v1,v2);
02010 }
02011 
02013 inline civector operator-(const scivector& v1, const ivector_slice& v2) {
02014   return spf_vv_sub<scivector,ivector_slice,civector>(v1,v2);
02015 }
02016 
02018 inline civector operator-(const scivector& v1, const civector_slice& v2) {
02019   return spf_vv_sub<scivector,civector_slice,civector>(v1,v2);
02020 }
02021 
02023 inline civector operator-(const srvector& v1, const civector_slice& v2) {
02024   return spf_vv_sub<srvector,civector_slice,civector>(v1,v2);
02025 }
02026 
02028 inline civector operator-(const scvector& v1, const civector_slice& v2) {
02029   return spf_vv_sub<scvector,civector_slice,civector>(v1,v2);
02030 }
02031 
02033 inline civector operator-(const sivector& v1, const civector_slice& v2) {
02034   return spf_vv_sub<sivector,civector_slice,civector>(v1,v2);
02035 }
02036 
02038 inline civector operator-(const scvector& v1, const ivector_slice& v2) {
02039   return spf_vv_sub<scvector,ivector_slice,civector>(v1,v2);
02040 }
02041 
02043 inline civector operator-(const sivector& v1, const cvector_slice& v2) {
02044   return spf_vv_sub<sivector,cvector_slice,civector>(v1,v2);
02045 }
02046 
02048 inline scivector operator-(const scivector& v1, const srvector& v2) {
02049   return spsp_vv_sub<scivector,srvector,scivector,cinterval>(v1,v2);
02050 }
02051 
02053 inline scivector operator-(const scivector& v1, const scvector& v2) {
02054   return spsp_vv_sub<scivector,scvector,scivector,cinterval>(v1,v2);
02055 }
02056 
02058 inline scivector operator-(const scivector& v1, const sivector& v2) {
02059   return spsp_vv_sub<scivector,sivector,scivector,cinterval>(v1,v2);
02060 }
02061 
02063 inline scivector operator-(const scivector& v1, const scivector& v2) {
02064   return spsp_vv_sub<scivector,scivector,scivector,cinterval>(v1,v2);
02065 }
02066 
02068 inline scivector operator-(const srvector& v1, const scivector& v2) {
02069   return spsp_vv_sub<srvector,scivector,scivector,cinterval>(v1,v2);
02070 }
02071 
02073 inline scivector operator-(const scvector& v1, const scivector& v2) {
02074   return spsp_vv_sub<scvector,scivector,scivector,cinterval>(v1,v2);
02075 }
02076 
02078 inline scivector operator-(const sivector& v1, const scivector& v2) {
02079   return spsp_vv_sub<sivector,scivector,scivector,cinterval>(v1,v2);
02080 }
02081 
02083 inline scivector operator-(const scvector& v1, const sivector& v2) {
02084   return spsp_vv_sub<scvector,sivector,scivector,cinterval>(v1,v2);
02085 }
02086 
02088 inline scivector operator-(const sivector& v1, const scvector& v2) {
02089   return spsp_vv_sub<sivector,scvector,scivector,cinterval>(v1,v2);
02090 }
02091 
02093 inline civector operator|(const civector& v1, const srvector& v2) {
02094   return fsp_vv_hull<civector,srvector,civector>(v1,v2);
02095 }
02096 
02098 inline civector operator|(const civector& v1, const scvector& v2) {
02099   return fsp_vv_hull<civector,scvector,civector>(v1,v2);
02100 }
02101 
02103 inline civector operator|(const civector& v1, const sivector& v2) {
02104   return fsp_vv_hull<civector,sivector,civector>(v1,v2);
02105 }
02106 
02108 inline civector operator|(const civector& v1, const scivector& v2) {
02109   return fsp_vv_hull<civector,scivector,civector>(v1,v2);
02110 }
02111 
02113 inline civector operator|(const rvector& v1, const scivector& v2) {
02114   return fsp_vv_hull<rvector,scivector,civector>(v1,v2);
02115 }
02116 
02118 inline civector operator|(const cvector& v1, const scivector& v2) {
02119   return fsp_vv_hull<cvector,scivector,civector>(v1,v2);
02120 }
02121 
02123 inline civector operator|(const ivector& v1, const scivector& v2) {
02124   return fsp_vv_hull<ivector,scivector,civector>(v1,v2);
02125 }
02126 
02128 inline civector operator|(const cvector& v1, const sivector& v2) {
02129   return fsp_vv_hull<cvector,sivector,civector>(v1,v2);
02130 }
02131 
02133 inline civector operator|(const ivector& v1, const scvector& v2) {
02134   return fsp_vv_hull<ivector,scvector,civector>(v1,v2);
02135 }
02136 
02138 inline civector operator|(const scivector& v1, const rvector& v2) {
02139   return spf_vv_hull<scivector,rvector,civector>(v1,v2);
02140 }
02141 
02143 inline civector operator|(const scivector& v1, const cvector& v2) {
02144   return spf_vv_hull<scivector,cvector,civector>(v1,v2);
02145 }
02146 
02148 inline civector operator|(const scivector& v1, const ivector& v2) {
02149   return spf_vv_hull<scivector,ivector,civector>(v1,v2);
02150 }
02151 
02153 inline civector operator|(const scivector& v1, const civector& v2) {
02154   return spf_vv_hull<scivector,civector,civector>(v1,v2);
02155 }
02156 
02158 inline civector operator|(const srvector& v1, const civector& v2) {
02159   return spf_vv_hull<srvector,civector,civector>(v1,v2);
02160 }
02161 
02163 inline civector operator|(const scvector& v1, const civector& v2) {
02164   return spf_vv_hull<scvector,civector,civector>(v1,v2);
02165 }
02166 
02168 inline civector operator|(const sivector& v1, const civector& v2) {
02169   return spf_vv_hull<sivector,civector,civector>(v1,v2);
02170 }
02171 
02173 inline civector operator|(const scvector& v1, const ivector& v2) {
02174   return spf_vv_hull<scvector,ivector,civector>(v1,v2);
02175 }
02176 
02178 inline civector operator|(const sivector& v1, const cvector& v2) {
02179   return spf_vv_hull<sivector,cvector,civector>(v1,v2);
02180 }
02181 
02183 inline civector operator|(const civector_slice& v1, const srvector& v2) {
02184   return fsp_vv_hull<civector_slice,srvector,civector>(v1,v2);
02185 }
02186 
02188 inline civector operator|(const civector_slice& v1, const scvector& v2) {
02189   return fsp_vv_hull<civector_slice,scvector,civector>(v1,v2);
02190 }
02191 
02193 inline civector operator|(const civector_slice& v1, const sivector& v2) {
02194   return fsp_vv_hull<civector_slice,sivector,civector>(v1,v2);
02195 }
02196 
02198 inline civector operator|(const civector_slice& v1, const scivector& v2) {
02199   return fsp_vv_hull<civector_slice,scivector,civector>(v1,v2);
02200 }
02201 
02203 inline civector operator|(const rvector_slice& v1, const scivector& v2) {
02204   return fsp_vv_hull<rvector_slice,scivector,civector>(v1,v2);
02205 }
02206 
02208 inline civector operator|(const cvector_slice& v1, const scivector& v2) {
02209   return fsp_vv_hull<cvector_slice,scivector,civector>(v1,v2);
02210 }
02211 
02213 inline civector operator|(const ivector_slice& v1, const scivector& v2) {
02214   return fsp_vv_hull<ivector_slice,scivector,civector>(v1,v2);
02215 }
02216 
02218 inline civector operator|(const cvector_slice& v1, const sivector& v2) {
02219   return fsp_vv_hull<cvector_slice,sivector,civector>(v1,v2);
02220 }
02221 
02223 inline civector operator|(const ivector_slice& v1, const scvector& v2) {
02224   return fsp_vv_hull<ivector_slice,scvector,civector>(v1,v2);
02225 }
02226 
02228 inline civector operator|(const scivector& v1, const rvector_slice& v2) {
02229   return spf_vv_hull<scivector,rvector_slice,civector>(v1,v2);
02230 }
02231 
02233 inline civector operator|(const scivector& v1, const cvector_slice& v2) {
02234   return spf_vv_hull<scivector,cvector_slice,civector>(v1,v2);
02235 }
02236 
02238 inline civector operator|(const scivector& v1, const ivector_slice& v2) {
02239   return spf_vv_hull<scivector,ivector_slice,civector>(v1,v2);
02240 }
02241 
02243 inline civector operator|(const scivector& v1, const civector_slice& v2) {
02244   return spf_vv_hull<scivector,civector_slice,civector>(v1,v2);
02245 }
02246 
02248 inline civector operator|(const srvector& v1, const civector_slice& v2) {
02249   return spf_vv_hull<srvector,civector_slice,civector>(v1,v2);
02250 }
02251 
02253 inline civector operator|(const scvector& v1, const civector_slice& v2) {
02254   return spf_vv_hull<scvector,civector_slice,civector>(v1,v2);
02255 }
02256 
02258 inline civector operator|(const sivector& v1, const civector_slice& v2) {
02259   return spf_vv_hull<sivector,civector_slice,civector>(v1,v2);
02260 }
02261 
02263 inline civector operator|(const scvector& v1, const ivector_slice& v2) {
02264   return spf_vv_hull<scvector,ivector_slice,civector>(v1,v2);
02265 }
02266 
02268 inline civector operator|(const sivector& v1, const cvector_slice& v2) {
02269   return spf_vv_hull<sivector,cvector_slice,civector>(v1,v2);
02270 }
02271 
02273 inline scivector operator|(const scivector& v1, const srvector& v2) {
02274   return spsp_vv_hull<scivector,srvector,scivector,cinterval>(v1,v2);
02275 }
02276 
02278 inline scivector operator|(const scivector& v1, const scvector& v2) {
02279   return spsp_vv_hull<scivector,scvector,scivector,cinterval>(v1,v2);
02280 }
02281 
02283 inline scivector operator|(const scivector& v1, const sivector& v2) {
02284   return spsp_vv_hull<scivector,sivector,scivector,cinterval>(v1,v2);
02285 }
02286 
02288 inline scivector operator|(const scivector& v1, const scivector& v2) {
02289   return spsp_vv_hull<scivector,scivector,scivector,cinterval>(v1,v2);
02290 }
02291 
02293 inline scivector operator|(const srvector& v1, const scivector& v2) {
02294   return spsp_vv_hull<srvector,scivector,scivector,cinterval>(v1,v2);
02295 }
02296 
02298 inline scivector operator|(const scvector& v1, const scivector& v2) {
02299   return spsp_vv_hull<scvector,scivector,scivector,cinterval>(v1,v2);
02300 }
02301 
02303 inline scivector operator|(const sivector& v1, const scivector& v2) {
02304   return spsp_vv_hull<sivector,scivector,scivector,cinterval>(v1,v2);
02305 }
02306 
02308 inline scivector operator|(const scvector& v1, const sivector& v2) {
02309   return spsp_vv_hull<scvector,sivector,scivector,cinterval>(v1,v2);
02310 }
02311 
02313 inline scivector operator|(const sivector& v1, const scvector& v2) {
02314   return spsp_vv_hull<sivector,scvector,scivector,cinterval>(v1,v2);
02315 }
02316 
02318 inline civector operator|(const cvector& v1, const srvector& v2) {
02319   return fsp_vv_hull<cvector,srvector,civector>(v1,v2);
02320 }
02321 
02323 inline civector operator|(const rvector& v1, const scvector& v2) {
02324   return fsp_vv_hull<rvector,scvector,civector>(v1,v2);
02325 }
02326 
02328 inline civector operator|(const cvector& v1, const scvector& v2) {
02329   return fsp_vv_hull<cvector,scvector,civector>(v1,v2);
02330 }
02331 
02333 inline civector operator|(const scvector& v1, const rvector& v2) {
02334   return spf_vv_hull<scvector,rvector,civector>(v1,v2);
02335 }
02336 
02338 inline civector operator|(const srvector& v1, const cvector& v2) {
02339   return spf_vv_hull<srvector,cvector,civector>(v1,v2);
02340 }
02341 
02343 inline civector operator|(const scvector& v1, const cvector& v2) {
02344   return spf_vv_hull<scvector,cvector,civector>(v1,v2);
02345 }
02346 
02348 inline civector operator|(const cvector_slice& v1, const srvector& v2) {
02349   return fsp_vv_hull<cvector_slice,srvector,civector>(v1,v2);
02350 }
02351 
02353 inline civector operator|(const rvector_slice& v1, const scvector& v2) {
02354   return fsp_vv_hull<rvector_slice,scvector,civector>(v1,v2);
02355 }
02356 
02358 inline civector operator|(const cvector_slice& v1, const scvector& v2) {
02359   return fsp_vv_hull<cvector_slice,scvector,civector>(v1,v2);
02360 }
02361 
02363 inline civector operator|(const scvector& v1, const rvector_slice& v2) {
02364   return spf_vv_hull<scvector,rvector_slice,civector>(v1,v2);
02365 }
02366 
02368 inline civector operator|(const srvector& v1, const cvector_slice& v2) {
02369   return spf_vv_hull<srvector,cvector_slice,civector>(v1,v2);
02370 }
02371 
02373 inline civector operator|(const scvector& v1, const cvector_slice& v2) {
02374   return spf_vv_hull<scvector,cvector_slice,civector>(v1,v2);
02375 }
02376 
02378 inline scivector operator|(const scvector& v1, const srvector& v2) {
02379   return spsp_vv_hull<scvector,srvector,scivector,cinterval>(v1,v2);
02380 }
02381 
02383 inline scivector operator|(const srvector& v1, const scvector& v2) {
02384   return spsp_vv_hull<srvector,scvector,scivector,cinterval>(v1,v2);
02385 }
02386 
02388 inline scivector operator|(const scvector& v1, const scvector& v2) {
02389   return spsp_vv_hull<scvector,scvector,scivector,cinterval>(v1,v2);
02390 }
02391 
02393 inline civector operator|(const cvector& v1, const srvector_slice& v2) {
02394   return fsl_vv_hull<cvector,srvector_slice,civector>(v1,v2);
02395 }
02396 
02398 inline civector operator|(const rvector& v1, const scvector_slice& v2) {
02399   return fsl_vv_hull<rvector,scvector_slice,civector>(v1,v2);
02400 }
02401 
02403 inline civector operator|(const cvector& v1, const scvector_slice& v2) {
02404   return fsl_vv_hull<cvector,scvector_slice,civector>(v1,v2);
02405 }
02406 
02408 inline civector operator|(const scvector_slice& v1, const rvector& v2) {
02409   return slf_vv_hull<scvector_slice,rvector,civector>(v1,v2);
02410 }
02411 
02413 inline civector operator|(const srvector_slice& v1, const cvector& v2) {
02414   return slf_vv_hull<srvector_slice,cvector,civector>(v1,v2);
02415 }
02416 
02418 inline civector operator|(const scvector_slice& v1, const cvector& v2) {
02419   return slf_vv_hull<scvector_slice,cvector,civector>(v1,v2);
02420 }
02421 
02423 inline civector operator|(const cvector_slice& v1, const srvector_slice& v2) {
02424   return fsl_vv_hull<cvector_slice,srvector_slice,civector>(v1,v2);
02425 }
02426 
02428 inline civector operator|(const rvector_slice& v1, const scvector_slice& v2) {
02429   return fsl_vv_hull<rvector_slice,scvector_slice,civector>(v1,v2);
02430 }
02431 
02433 inline civector operator|(const cvector_slice& v1, const scvector_slice& v2) {
02434   return fsl_vv_hull<cvector_slice,scvector_slice,civector>(v1,v2);
02435 }
02436 
02438 inline civector operator|(const scvector_slice& v1, const rvector_slice& v2) {
02439   return slf_vv_hull<scvector_slice,rvector_slice,civector>(v1,v2);
02440 }
02441 
02443 inline civector operator|(const srvector_slice& v1, const cvector_slice& v2) {
02444   return slf_vv_hull<srvector_slice,cvector_slice,civector>(v1,v2);
02445 }
02446 
02448 inline civector operator|(const scvector_slice& v1, const cvector_slice& v2) {
02449   return slf_vv_hull<scvector_slice,cvector_slice,civector>(v1,v2);
02450 }
02451 
02453 inline scivector operator|(const scvector_slice& v1, const srvector_slice& v2) {
02454   return slsl_vv_hull<scvector_slice,srvector_slice,scivector,cinterval>(v1,v2);
02455 }
02456 
02458 inline scivector operator|(const srvector_slice& v1, const scvector_slice& v2) {
02459   return slsl_vv_hull<srvector_slice,scvector_slice,scivector,cinterval>(v1,v2);
02460 }
02461 
02463 inline scivector operator|(const scvector_slice& v1, const scvector_slice& v2) {
02464   return slsl_vv_hull<scvector_slice,scvector_slice,scivector,cinterval>(v1,v2);
02465 }
02466 
02468 inline scivector operator|(const scvector& v1, const srvector_slice& v2) {
02469   return spsl_vv_hull<scvector,srvector_slice,scivector,cinterval>(v1,v2);
02470 }
02471 
02473 inline scivector operator|(const srvector& v1, const scvector_slice& v2) {
02474   return spsl_vv_hull<srvector,scvector_slice,scivector,cinterval>(v1,v2);
02475 }
02476 
02478 inline scivector operator|(const scvector& v1, const scvector_slice& v2) {
02479   return spsl_vv_hull<scvector,scvector_slice,scivector,cinterval>(v1,v2);
02480 }
02481 
02483 inline scivector operator|(const scvector_slice& v1, const srvector& v2) {
02484   return slsp_vv_hull<scvector_slice,srvector,scivector,cinterval>(v1,v2);
02485 }
02486 
02488 inline scivector operator|(const srvector_slice& v1, const scvector& v2) {
02489   return slsp_vv_hull<srvector_slice,scvector,scivector,cinterval>(v1,v2);
02490 }
02491 
02493 inline scivector operator|(const scvector_slice& v1, const scvector& v2) {
02494   return slsp_vv_hull<scvector_slice,scvector,scivector,cinterval>(v1,v2);
02495 }
02496 
02498 inline civector operator&(const civector& v1, const sivector& v2) {
02499   return fsp_vv_intersect<civector,sivector,civector>(v1,v2);
02500 }
02501 
02503 inline civector operator&(const civector& v1, const scivector& v2) {
02504   return fsp_vv_intersect<civector,scivector,civector>(v1,v2);
02505 }
02506 
02508 inline civector operator&(const ivector& v1, const scivector& v2) {
02509   return fsp_vv_intersect<ivector,scivector,civector>(v1,v2);
02510 }
02511 
02513 inline civector operator&(const scivector& v1, const ivector& v2) {
02514   return spf_vv_intersect<scivector,ivector,civector>(v1,v2);
02515 }
02516 
02518 inline civector operator&(const scivector& v1, const civector& v2) {
02519   return spf_vv_intersect<scivector,civector,civector>(v1,v2);
02520 }
02521 
02523 inline civector operator&(const sivector& v1, const civector& v2) {
02524   return spf_vv_intersect<sivector,civector,civector>(v1,v2);
02525 }
02526 
02528 inline civector operator&(const civector_slice& v1, const sivector& v2) {
02529   return fsp_vv_intersect<civector_slice,sivector,civector>(v1,v2);
02530 }
02531 
02533 inline civector operator&(const civector_slice& v1, const scivector& v2) {
02534   return fsp_vv_intersect<civector_slice,scivector,civector>(v1,v2);
02535 }
02536 
02538 inline civector operator&(const ivector_slice& v1, const scivector& v2) {
02539   return fsp_vv_intersect<ivector_slice,scivector,civector>(v1,v2);
02540 }
02541 
02543 inline civector operator&(const scivector& v1, const ivector_slice& v2) {
02544   return spf_vv_intersect<scivector,ivector_slice,civector>(v1,v2);
02545 }
02546 
02548 inline civector operator&(const scivector& v1, const civector_slice& v2) {
02549   return spf_vv_intersect<scivector,civector_slice,civector>(v1,v2);
02550 }
02551 
02553 inline civector operator&(const sivector& v1, const civector_slice& v2) {
02554   return spf_vv_intersect<sivector,civector_slice,civector>(v1,v2);
02555 }
02556 
02558 inline scivector operator&(const scivector& v1, const sivector& v2) {
02559   return spsp_vv_intersect<scivector,sivector,scivector,cinterval>(v1,v2);
02560 }
02561 
02563 inline scivector operator&(const scivector& v1, const scivector& v2) {
02564   return spsp_vv_intersect<scivector,scivector,scivector,cinterval>(v1,v2);
02565 }
02566 
02568 inline scivector operator&(const sivector& v1, const scivector& v2) {
02569   return spsp_vv_intersect<sivector,scivector,scivector,cinterval>(v1,v2);
02570 }
02571 
02572 inline civector& civector::operator+=(const srvector& v2) {
02573   return fsp_vv_addassign(*this,v2);
02574 }
02575 
02576 inline civector& civector::operator+=(const scvector& v2) {
02577   return fsp_vv_addassign(*this,v2);
02578 }
02579 
02580 inline civector& civector::operator+=(const sivector& v2) {
02581   return fsp_vv_addassign(*this,v2);
02582 }
02583 
02584 inline civector& civector::operator+=(const scivector& v2) {
02585   return fsp_vv_addassign(*this,v2);
02586 }
02587 
02588 inline civector_slice& civector_slice::operator+=(const srvector& v2) {
02589   return fsp_vv_addassign(*this,v2);
02590 }
02591 
02592 inline civector_slice& civector_slice::operator+=(const scvector& v2) {
02593   return fsp_vv_addassign(*this,v2);
02594 }
02595 
02596 inline civector_slice& civector_slice::operator+=(const sivector& v2) {
02597   return fsp_vv_addassign(*this,v2);
02598 }
02599 
02600 inline civector_slice& civector_slice::operator+=(const scivector& v2) {
02601   return fsp_vv_addassign(*this,v2);
02602 }
02603 
02604 inline civector& civector::operator-=(const srvector& v2) {
02605   return fsp_vv_subassign(*this,v2);
02606 }
02607 
02608 inline civector& civector::operator-=(const scvector& v2) {
02609   return fsp_vv_subassign(*this,v2);
02610 }
02611 
02612 inline civector& civector::operator-=(const sivector& v2) {
02613   return fsp_vv_subassign(*this,v2);
02614 }
02615 
02616 inline civector& civector::operator-=(const scivector& v2) {
02617   return fsp_vv_subassign(*this,v2);
02618 }
02619 
02620 inline civector_slice& civector_slice::operator-=(const srvector& v2) {
02621   return fsp_vv_subassign(*this,v2);
02622 }
02623 
02624 inline civector_slice& civector_slice::operator-=(const scvector& v2) {
02625   return fsp_vv_subassign(*this,v2);
02626 }
02627 
02628 inline civector_slice& civector_slice::operator-=(const sivector& v2) {
02629   return fsp_vv_subassign(*this,v2);
02630 }
02631 
02632 inline civector_slice& civector_slice::operator-=(const scivector& v2) {
02633   return fsp_vv_subassign(*this,v2);
02634 }
02635 
02636 inline civector& civector::operator|=(const srvector& v2) {
02637   return fsp_vv_hullassign(*this,v2);
02638 }
02639 
02640 inline civector& civector::operator|=(const scvector& v2) {
02641   return fsp_vv_hullassign(*this,v2);
02642 }
02643 
02644 inline civector& civector::operator|=(const sivector& v2) {
02645   return fsp_vv_hullassign(*this,v2);
02646 }
02647 
02648 inline civector& civector::operator|=(const scivector& v2) {
02649   return fsp_vv_hullassign(*this,v2);
02650 }
02651 
02652 inline civector_slice& civector_slice::operator|=(const srvector& v2) {
02653   return fsp_vv_hullassign(*this,v2);
02654 }
02655 
02656 inline civector_slice& civector_slice::operator|=(const scvector& v2) {
02657   return fsp_vv_hullassign(*this,v2);
02658 }
02659 
02660 inline civector_slice& civector_slice::operator|=(const sivector& v2) {
02661   return fsp_vv_hullassign(*this,v2);
02662 }
02663 
02664 inline civector_slice& civector_slice::operator|=(const scivector& v2) {
02665   return fsp_vv_hullassign(*this,v2);
02666 }
02667 
02668 inline civector& civector::operator&=(const sivector& v2) {
02669   return fsp_vv_intersectassign(*this,v2);
02670 }
02671 
02672 inline civector& civector::operator&=(const scivector& v2) {
02673   return fsp_vv_intersectassign(*this,v2);
02674 }
02675 
02676 inline civector_slice& civector_slice::operator&=(const sivector& v2) {
02677   return fsp_vv_intersectassign(*this,v2);
02678 }
02679 
02680 inline civector_slice& civector_slice::operator&=(const scivector& v2) {
02681   return fsp_vv_intersectassign(*this,v2);
02682 }
02683 
02685 
02688 inline bool operator==(const scivector& v1, const scivector& v2) {
02689   return spsp_vv_comp(v1,v2);
02690 }
02691 
02693 
02696 inline bool operator==(const scivector& v1, const srvector& v2) {
02697   return spsp_vv_comp(v1,v2);
02698 }
02699 
02701 
02704 inline bool operator==(const scivector& v1, const sivector& v2) {
02705   return spsp_vv_comp(v1,v2);
02706 }
02707 
02709 
02712 inline bool operator==(const scivector& v1, const scvector& v2) {
02713   return spsp_vv_comp(v1,v2);
02714 }
02715 
02717 
02720 inline bool operator==(const srvector& v1, const scivector& v2) {
02721   return spsp_vv_comp(v1,v2);
02722 }
02723 
02725 
02728 inline bool operator==(const scvector& v1, const scivector& v2) {
02729   return spsp_vv_comp(v1,v2);
02730 }
02731 
02733 
02736 inline bool operator==(const sivector& v1, const scivector& v2) {
02737   return spsp_vv_comp(v1,v2);
02738 }
02739 
02741 
02744 inline bool operator==(const scivector& v1, const rvector& v2) {
02745   return spf_vv_comp(v1,v2);
02746 }
02747 
02749 
02752 inline bool operator==(const scivector& v1, const cvector& v2) {
02753   return spf_vv_comp(v1,v2);
02754 }
02755 
02757 
02760 inline bool operator==(const scivector& v1, const ivector& v2) {
02761   return spf_vv_comp(v1,v2);
02762 }
02763 
02765 
02768 inline bool operator==(const scivector& v1, const civector& v2) {
02769   return spf_vv_comp(v1,v2);
02770 }
02771 
02773 
02776 inline bool operator==(const srvector& v1, const civector& v2) {
02777   return spf_vv_comp(v1,v2);
02778 }
02779 
02781 
02784 inline bool operator==(const scvector& v1, const civector& v2) {
02785   return spf_vv_comp(v1,v2);
02786 }
02787 
02789 
02792 inline bool operator==(const sivector& v1, const civector& v2) {
02793   return spf_vv_comp(v1,v2);
02794 }
02795 
02797 
02800 inline bool operator==(const civector& v1, const srvector& v2) {
02801   return fsp_vv_comp(v1,v2);
02802 }
02803 
02805 
02808 inline bool operator==(const civector& v1, const scvector& v2) {
02809   return fsp_vv_comp(v1,v2);
02810 }
02811 
02813 
02816 inline bool operator==(const civector& v1, const sivector& v2) {
02817   return fsp_vv_comp(v1,v2);
02818 }
02819 
02821 
02824 inline bool operator==(const civector& v1, const scivector& v2) {
02825   return fsp_vv_comp(v1,v2);
02826 }
02827 
02829 
02832 inline bool operator==(const rvector& v1, const scivector& v2) {
02833   return fsp_vv_comp(v1,v2);
02834 }
02835 
02837 
02840 inline bool operator==(const cvector& v1, const scivector& v2) {
02841   return fsp_vv_comp(v1,v2);
02842 }
02843 
02845 
02848 inline bool operator==(const ivector& v1, const scivector& v2) {
02849   return fsp_vv_comp(v1,v2);
02850 }
02851 
02853 
02856 inline bool operator==(const scivector& v1, const rvector_slice& v2) {
02857   return spf_vv_comp(v1,v2);
02858 }
02859 
02861 
02864 inline bool operator==(const scivector& v1, const ivector_slice& v2) {
02865   return spf_vv_comp(v1,v2);
02866 }
02867 
02869 
02872 inline bool operator==(const scivector& v1, const cvector_slice& v2) {
02873   return spf_vv_comp(v1,v2);
02874 }
02875 
02877 
02880 inline bool operator==(const srvector& v1, const civector_slice& v2) {
02881   return spf_vv_comp(v1,v2);
02882 }
02883 
02885 
02888 inline bool operator==(const scvector& v1, const civector_slice& v2) {
02889   return spf_vv_comp(v1,v2);
02890 }
02891 
02893 
02896 inline bool operator==(const sivector& v1, const civector_slice& v2) {
02897   return spf_vv_comp(v1,v2);
02898 }
02899 
02901 
02904 inline bool operator==(const scivector& v1, const civector_slice& v2) {
02905   return spf_vv_comp(v1,v2);
02906 }
02907 
02909 
02912 inline bool operator==(const civector_slice& v1, const srvector& v2) {
02913   return fsp_vv_comp(v1,v2);
02914 }
02915 
02917 
02920 inline bool operator==(const civector_slice& v1, const sivector& v2) {
02921   return fsp_vv_comp(v1,v2);
02922 }
02923 
02925 
02928 inline bool operator==(const civector_slice& v1, const scvector& v2) {
02929   return fsp_vv_comp(v1,v2);
02930 }
02931 
02933 
02936 inline bool operator==(const rvector_slice& v1, const scivector& v2) {
02937   return fsp_vv_comp(v1,v2);
02938 }
02939 
02941 
02944 inline bool operator==(const ivector_slice& v1, const scivector& v2) {
02945   return fsp_vv_comp(v1,v2);
02946 }
02947 
02949 
02952 inline bool operator==(const cvector_slice& v1, const scivector& v2) {
02953   return fsp_vv_comp(v1,v2);
02954 }
02955 
02957 
02960 inline bool operator==(const civector_slice& v1, const scivector& v2) {
02961   return fsp_vv_comp(v1,v2);
02962 }
02963 
02965 
02968 inline bool operator!=(const scivector& v1, const scivector& v2) {
02969   return !spsp_vv_comp(v1,v2);
02970 }
02971 
02973 
02976 inline bool operator!=(const scivector& v1, const srvector& v2) {
02977   return !spsp_vv_comp(v1,v2);
02978 }
02979 
02981 
02984 inline bool operator!=(const scivector& v1, const sivector& v2) {
02985   return !spsp_vv_comp(v1,v2);
02986 }
02987 
02989 
02992 inline bool operator!=(const scivector& v1, const scvector& v2) {
02993   return !spsp_vv_comp(v1,v2);
02994 }
02995 
02997 
03000 inline bool operator!=(const srvector& v1, const scivector& v2) {
03001   return !spsp_vv_comp(v1,v2);
03002 }
03003 
03005 
03008 inline bool operator!=(const scvector& v1, const scivector& v2) {
03009   return !spsp_vv_comp(v1,v2);
03010 }
03011 
03013 
03016 inline bool operator!=(const sivector& v1, const scivector& v2) {
03017   return !spsp_vv_comp(v1,v2);
03018 }
03019 
03021 
03024 inline bool operator!=(const scivector& v1, const rvector& v2) {
03025   return !spf_vv_comp(v1,v2);
03026 }
03027 
03029 
03032 inline bool operator!=(const scivector& v1, const cvector& v2) {
03033   return !spf_vv_comp(v1,v2);
03034 }
03035 
03037 
03040 inline bool operator!=(const scivector& v1, const ivector& v2) {
03041   return !spf_vv_comp(v1,v2);
03042 }
03043 
03045 
03048 inline bool operator!=(const scivector& v1, const civector& v2) {
03049   return !spf_vv_comp(v1,v2);
03050 }
03051 
03053 
03056 inline bool operator!=(const srvector& v1, const civector& v2) {
03057   return !spf_vv_comp(v1,v2);
03058 }
03059 
03061 
03064 inline bool operator!=(const scvector& v1, const civector& v2) {
03065   return !spf_vv_comp(v1,v2);
03066 }
03067 
03069 
03072 inline bool operator!=(const sivector& v1, const civector& v2) {
03073   return !spf_vv_comp(v1,v2);
03074 }
03075 
03077 
03080 inline bool operator!=(const civector& v1, const srvector& v2) {
03081   return !fsp_vv_comp(v1,v2);
03082 }
03083 
03085 
03088 inline bool operator!=(const civector& v1, const sivector& v2) {
03089   return !fsp_vv_comp(v1,v2);
03090 }
03091 
03093 
03096 inline bool operator!=(const civector& v1, const scivector& v2) {
03097   return !fsp_vv_comp(v1,v2);
03098 }
03099 
03101 
03104 inline bool operator!=(const rvector& v1, const scivector& v2) {
03105   return !fsp_vv_comp(v1,v2);
03106 }
03107 
03109 
03112 inline bool operator!=(const cvector& v1, const scivector& v2) {
03113   return !fsp_vv_comp(v1,v2);
03114 }
03115 
03117 
03120 inline bool operator!=(const ivector& v1, const scivector& v2) {
03121   return !fsp_vv_comp(v1,v2);
03122 }
03123 
03125 
03128 inline bool operator!=(const scivector& v1, const rvector_slice& v2) {
03129   return !spf_vv_comp(v1,v2);
03130 }
03131 
03133 
03136 inline bool operator!=(const scivector& v1, const ivector_slice& v2) {
03137   return !spf_vv_comp(v1,v2);
03138 }
03139 
03141 
03144 inline bool operator!=(const scivector& v1, const cvector_slice& v2) {
03145   return !spf_vv_comp(v1,v2);
03146 }
03147 
03149 
03152 inline bool operator!=(const srvector& v1, const civector_slice& v2) {
03153   return !spf_vv_comp(v1,v2);
03154 }
03155 
03157 
03160 inline bool operator!=(const scvector& v1, const civector_slice& v2) {
03161   return !spf_vv_comp(v1,v2);
03162 }
03163 
03165 
03168 inline bool operator!=(const sivector& v1, const civector_slice& v2) {
03169   return !spf_vv_comp(v1,v2);
03170 }
03171 
03173 
03176 inline bool operator!=(const scivector& v1, const civector_slice& v2) {
03177   return !spf_vv_comp(v1,v2);
03178 }
03179 
03181 
03184 inline bool operator!=(const civector_slice& v1, const srvector& v2) {
03185   return !fsp_vv_comp(v1,v2);
03186 }
03187 
03189 
03192 inline bool operator!=(const civector_slice& v1, const sivector& v2) {
03193   return !fsp_vv_comp(v1,v2);
03194 }
03195 
03197 
03200 inline bool operator!=(const civector_slice& v1, const scvector& v2) {
03201   return !fsp_vv_comp(v1,v2);
03202 }
03203 
03205 
03208 inline bool operator!=(const rvector_slice& v1, const scivector& v2) {
03209   return !fsp_vv_comp(v1,v2);
03210 }
03211 
03213 
03216 inline bool operator!=(const ivector_slice& v1, const scivector& v2) {
03217   return !fsp_vv_comp(v1,v2);
03218 }
03219 
03221 
03224 inline bool operator!=(const cvector_slice& v1, const scivector& v2) {
03225   return !fsp_vv_comp(v1,v2);
03226 }
03227 
03229 
03232 inline bool operator!=(const civector_slice& v1, const scivector& v2) {
03233   return !fsp_vv_comp(v1,v2);
03234 }
03235 
03237 
03240 inline bool operator<(const scivector& v1, const scivector& v2) {
03241   return spsp_vv_less<scivector,scivector,cinterval>(v1,v2);
03242 }
03243 
03245 
03248 inline bool operator<(const scivector& v1, const sivector& v2) {
03249   return spsp_vv_less<scivector,sivector,cinterval>(v1,v2);
03250 }
03251 
03253 
03256 inline bool operator<(const srvector& v1, const scivector& v2) {
03257   return spsp_vv_less<srvector,scivector,cinterval>(v1,v2);
03258 }
03259 
03261 
03264 inline bool operator<(const scvector& v1, const scivector& v2) {
03265   return spsp_vv_less<scvector,scivector,cinterval>(v1,v2);
03266 }
03267 
03269 
03272 inline bool operator<(const sivector& v1, const scivector& v2) {
03273   return spsp_vv_less<sivector,scivector,cinterval>(v1,v2);
03274 }
03275 
03277 
03280 inline bool operator<(const scivector& v1, const ivector& v2) {
03281   return spf_vv_less<scivector,ivector,cinterval>(v1,v2);
03282 }
03283 
03285 
03288 inline bool operator<(const scivector& v1, const civector& v2) {
03289   return spf_vv_less<scivector,civector,cinterval>(v1,v2);
03290 }
03291 
03293 
03296 inline bool operator<(const srvector& v1, const civector& v2) {
03297   return spf_vv_less<srvector,civector,cinterval>(v1,v2);
03298 }
03299 
03301 
03304 inline bool operator<(const scvector& v1, const civector& v2) {
03305   return spf_vv_less<scvector,civector,cinterval>(v1,v2);
03306 }
03307 
03309 
03312 inline bool operator<(const sivector& v1, const civector& v2) {
03313   return spf_vv_less<sivector,civector,cinterval>(v1,v2);
03314 }
03315 
03317 
03320 inline bool operator<(const civector& v1, const sivector& v2) {
03321   return fsp_vv_less<civector,sivector,cinterval>(v1,v2);
03322 }
03323 
03325 
03328 inline bool operator<(const civector& v1, const scivector& v2) {
03329   return fsp_vv_less<civector,scivector,cinterval>(v1,v2);
03330 }
03331 
03333 
03336 inline bool operator<(const rvector& v1, const scivector& v2) {
03337   return fsp_vv_less<rvector,scivector,cinterval>(v1,v2);
03338 }
03339 
03341 
03344 inline bool operator<(const cvector& v1, const scivector& v2) {
03345   return fsp_vv_less<cvector,scivector,cinterval>(v1,v2);
03346 }
03347 
03349 
03352 inline bool operator<(const ivector& v1, const scivector& v2) {
03353   return fsp_vv_less<ivector,scivector,cinterval>(v1,v2);
03354 }
03355 
03357 
03360 inline bool operator<(const scivector& v1, const ivector_slice& v2) {
03361   return spf_vv_less<scivector,ivector_slice,cinterval>(v1,v2);
03362 }
03363 
03365 
03368 inline bool operator<(const srvector& v1, const civector_slice& v2) {
03369   return spf_vv_less<srvector,civector_slice,cinterval>(v1,v2);
03370 }
03371 
03373 
03376 inline bool operator<(const scvector& v1, const civector_slice& v2) {
03377   return spf_vv_less<scvector,civector_slice,cinterval>(v1,v2);
03378 }
03379 
03381 
03384 inline bool operator<(const sivector& v1, const civector_slice& v2) {
03385   return spf_vv_less<sivector,civector_slice,cinterval>(v1,v2);
03386 }
03387 
03389 
03392 inline bool operator<(const scivector& v1, const civector_slice& v2) {
03393   return spf_vv_less<scivector,civector_slice,cinterval>(v1,v2);
03394 }
03395 
03397 
03400 inline bool operator<(const civector_slice& v1, const sivector& v2) {
03401   return fsp_vv_less<civector_slice,sivector,cinterval>(v1,v2);
03402 }
03403 
03405 
03408 inline bool operator<(const rvector_slice& v1, const scivector& v2) {
03409   return fsp_vv_less<rvector_slice,scivector,cinterval>(v1,v2);
03410 }
03411 
03413 
03416 inline bool operator<(const ivector_slice& v1, const scivector& v2) {
03417   return fsp_vv_less<ivector_slice,scivector,cinterval>(v1,v2);
03418 }
03419 
03421 
03424 inline bool operator<(const cvector_slice& v1, const scivector& v2) {
03425   return fsp_vv_less<cvector_slice,scivector,cinterval>(v1,v2);
03426 }
03427 
03429 
03432 inline bool operator<(const civector_slice& v1, const scivector& v2) {
03433   return fsp_vv_less<civector_slice,scivector,cinterval>(v1,v2);
03434 }
03435 
03437 
03440 inline bool operator<=(const scivector& v1, const scivector& v2) {
03441   return spsp_vv_leq<scivector,scivector,cinterval>(v1,v2);
03442 }
03443 
03445 
03448 inline bool operator<=(const scivector& v1, const sivector& v2) {
03449   return spsp_vv_leq<scivector,sivector,cinterval>(v1,v2);
03450 }
03451 
03453 
03456 inline bool operator<=(const srvector& v1, const scivector& v2) {
03457   return spsp_vv_leq<srvector,scivector,cinterval>(v1,v2);
03458 }
03459 
03461 
03464 inline bool operator<=(const scvector& v1, const scivector& v2) {
03465   return spsp_vv_leq<scvector,scivector,cinterval>(v1,v2);
03466 }
03467 
03469 
03472 inline bool operator<=(const sivector& v1, const scivector& v2) {
03473   return spsp_vv_leq<sivector,scivector,cinterval>(v1,v2);
03474 }
03475 
03477 
03480 inline bool operator<=(const scivector& v1, const ivector& v2) {
03481   return spf_vv_leq<scivector,ivector,cinterval>(v1,v2);
03482 }
03483 
03485 
03488 inline bool operator<=(const scivector& v1, const civector& v2) {
03489   return spf_vv_leq<scivector,civector,cinterval>(v1,v2);
03490 }
03491 
03493 
03496 inline bool operator<=(const srvector& v1, const civector& v2) {
03497   return spf_vv_leq<srvector,civector,cinterval>(v1,v2);
03498 }
03499 
03501 
03504 inline bool operator<=(const scvector& v1, const civector& v2) {
03505   return spf_vv_leq<scvector,civector,cinterval>(v1,v2);
03506 }
03507 
03509 
03512 inline bool operator<=(const sivector& v1, const civector& v2) {
03513   return spf_vv_leq<sivector,civector,cinterval>(v1,v2);
03514 }
03515 
03517 
03520 inline bool operator<=(const civector& v1, const sivector& v2) {
03521   return fsp_vv_leq<civector,sivector,cinterval>(v1,v2);
03522 }
03523 
03525 
03528 inline bool operator<=(const civector& v1, const scivector& v2) {
03529   return fsp_vv_leq<civector,scivector,cinterval>(v1,v2);
03530 }
03531 
03533 
03536 inline bool operator<=(const rvector& v1, const scivector& v2) {
03537   return fsp_vv_leq<rvector,scivector,cinterval>(v1,v2);
03538 }
03539 
03541 
03544 inline bool operator<=(const cvector& v1, const scivector& v2) {
03545   return fsp_vv_leq<cvector,scivector,cinterval>(v1,v2);
03546 }
03547 
03549 
03552 inline bool operator<=(const ivector& v1, const scivector& v2) {
03553   return fsp_vv_leq<ivector,scivector,cinterval>(v1,v2);
03554 }
03555 
03557 
03560 inline bool operator<=(const scivector& v1, const ivector_slice& v2) {
03561   return spf_vv_leq<scivector,ivector_slice,cinterval>(v1,v2);
03562 }
03563 
03565 
03568 inline bool operator<=(const srvector& v1, const civector_slice& v2) {
03569   return spf_vv_leq<srvector,civector_slice,cinterval>(v1,v2);
03570 }
03571 
03573 
03576 inline bool operator<=(const scvector& v1, const civector_slice& v2) {
03577   return spf_vv_leq<scvector,civector_slice,cinterval>(v1,v2);
03578 }
03579 
03581 
03584 inline bool operator<=(const sivector& v1, const civector_slice& v2) {
03585   return spf_vv_leq<sivector,civector_slice,cinterval>(v1,v2);
03586 }
03587 
03589 
03592 inline bool operator<=(const scivector& v1, const civector_slice& v2) {
03593   return spf_vv_leq<scivector,civector_slice,cinterval>(v1,v2);
03594 }
03595 
03597 
03600 inline bool operator<=(const civector_slice& v1, const sivector& v2) {
03601   return fsp_vv_leq<civector_slice,sivector,cinterval>(v1,v2);
03602 }
03603 
03605 
03608 inline bool operator<=(const rvector_slice& v1, const scivector& v2) {
03609   return fsp_vv_leq<rvector_slice,scivector,cinterval>(v1,v2);
03610 }
03611 
03613 
03616 inline bool operator<=(const ivector_slice& v1, const scivector& v2) {
03617   return fsp_vv_leq<ivector_slice,scivector,cinterval>(v1,v2);
03618 }
03619 
03621 
03624 inline bool operator<=(const cvector_slice& v1, const scivector& v2) {
03625   return fsp_vv_leq<cvector_slice,scivector,cinterval>(v1,v2);
03626 }
03627 
03629 
03632 inline bool operator<=(const civector_slice& v1, const scivector& v2) {
03633   return fsp_vv_leq<civector_slice,scivector,cinterval>(v1,v2);
03634 }
03635 
03637 
03640 inline bool operator>(const scivector& v1, const scivector& v2) {
03641   return spsp_vv_greater<scivector,scivector,cinterval>(v1,v2);
03642 }
03643 
03645 
03648 inline bool operator>(const scivector& v1, const srvector& v2) {
03649   return spsp_vv_greater<scivector,srvector,cinterval>(v1,v2);
03650 }
03651 
03653 
03656 inline bool operator>(const scivector& v1, const sivector& v2) {
03657   return spsp_vv_greater<scivector,sivector,cinterval>(v1,v2);
03658 }
03659 
03661 
03664 inline bool operator>(const scivector& v1, const scvector& v2) {
03665   return spsp_vv_greater<scivector,scvector,cinterval>(v1,v2);
03666 }
03667 
03669 
03672 inline bool operator>(const sivector& v1, const scivector& v2) {
03673   return spsp_vv_greater<sivector,scivector,cinterval>(v1,v2);
03674 }
03675 
03677 
03680 inline bool operator>(const scivector& v1, const rvector& v2) {
03681   return spf_vv_greater<scivector,rvector,cinterval>(v1,v2);
03682 }
03683 
03685 
03688 inline bool operator>(const scivector& v1, const cvector& v2) {
03689   return spf_vv_greater<scivector,cvector,cinterval>(v1,v2);
03690 }
03691 
03693 
03696 inline bool operator>(const scivector& v1, const ivector& v2) {
03697   return spf_vv_greater<scivector,ivector,cinterval>(v1,v2);
03698 }
03699 
03701 
03704 inline bool operator>(const scivector& v1, const civector& v2) {
03705   return spf_vv_greater<scivector,civector,cinterval>(v1,v2);
03706 }
03707 
03709 
03712 inline bool operator>(const sivector& v1, const civector& v2) {
03713   return spf_vv_greater<sivector,civector,cinterval>(v1,v2);
03714 }
03715 
03717 
03720 inline bool operator>(const civector& v1, const srvector& v2) {
03721   return fsp_vv_greater<civector,srvector,cinterval>(v1,v2);
03722 }
03723 
03725 
03728 inline bool operator>(const civector& v1, const scvector& v2) {
03729   return fsp_vv_greater<civector,scvector,cinterval>(v1,v2);
03730 }
03731 
03733 
03736 inline bool operator>(const civector& v1, const sivector& v2) {
03737   return fsp_vv_greater<civector,sivector,cinterval>(v1,v2);
03738 }
03739 
03741 
03744 inline bool operator>(const civector& v1, const scivector& v2) {
03745   return fsp_vv_greater<civector,scivector,cinterval>(v1,v2);
03746 }
03747 
03749 
03752 inline bool operator>(const ivector& v1, const scivector& v2) {
03753   return fsp_vv_greater<ivector,scivector,cinterval>(v1,v2);
03754 }
03755 
03757 
03760 inline bool operator>(const scivector& v1, const rvector_slice& v2) {
03761   return spf_vv_greater<scivector,rvector_slice,cinterval>(v1,v2);
03762 }
03763 
03765 
03768 inline bool operator>(const scivector& v1, const ivector_slice& v2) {
03769   return spf_vv_greater<scivector,ivector_slice,cinterval>(v1,v2);
03770 }
03771 
03773 
03776 inline bool operator>(const scivector& v1, const cvector_slice& v2) {
03777   return spf_vv_greater<scivector,cvector_slice,cinterval>(v1,v2);
03778 }
03779 
03781 
03784 inline bool operator>(const sivector& v1, const civector_slice& v2) {
03785   return spf_vv_greater<sivector,civector_slice,cinterval>(v1,v2);
03786 }
03787 
03789 
03792 inline bool operator>(const scivector& v1, const civector_slice& v2) {
03793   return spf_vv_greater<scivector,civector_slice,cinterval>(v1,v2);
03794 }
03795 
03797 
03800 inline bool operator>(const civector_slice& v1, const srvector& v2) {
03801   return fsp_vv_greater<civector_slice,srvector,cinterval>(v1,v2);
03802 }
03803 
03805 
03808 inline bool operator>(const civector_slice& v1, const sivector& v2) {
03809   return fsp_vv_greater<civector_slice,sivector,cinterval>(v1,v2);
03810 }
03811 
03813 
03816 inline bool operator>(const civector_slice& v1, const scvector& v2) {
03817   return fsp_vv_greater<civector_slice,scvector,cinterval>(v1,v2);
03818 }
03819 
03821 
03824 inline bool operator>(const ivector_slice& v1, const scivector& v2) {
03825   return fsp_vv_greater<ivector_slice,scivector,cinterval>(v1,v2);
03826 }
03827 
03829 
03832 inline bool operator>(const civector_slice& v1, const scivector& v2) {
03833   return fsp_vv_greater<civector_slice,scivector,cinterval>(v1,v2);
03834 }
03835 
03837 
03840 inline bool operator>=(const scivector& v1, const scivector& v2) {
03841   return spsp_vv_geq<scivector,scivector,cinterval>(v1,v2);
03842 }
03843 
03845 
03848 inline bool operator>=(const scivector& v1, const srvector& v2) {
03849   return spsp_vv_geq<scivector,srvector,cinterval>(v1,v2);
03850 }
03851 
03853 
03856 inline bool operator>=(const scivector& v1, const sivector& v2) {
03857   return spsp_vv_geq<scivector,sivector,cinterval>(v1,v2);
03858 }
03859 
03861 
03864 inline bool operator>=(const scivector& v1, const scvector& v2) {
03865   return spsp_vv_geq<scivector,scvector,cinterval>(v1,v2);
03866 }
03867 
03869 
03872 inline bool operator>=(const sivector& v1, const scivector& v2) {
03873   return spsp_vv_geq<sivector,scivector,cinterval>(v1,v2);
03874 }
03875 
03877 
03880 inline bool operator>=(const scivector& v1, const rvector& v2) {
03881   return spf_vv_geq<scivector,rvector,cinterval>(v1,v2);
03882 }
03883 
03885 
03888 inline bool operator>=(const scivector& v1, const cvector& v2) {
03889   return spf_vv_geq<scivector,cvector,cinterval>(v1,v2);
03890 }
03891 
03893 
03896 inline bool operator>=(const scivector& v1, const ivector& v2) {
03897   return spf_vv_geq<scivector,ivector,cinterval>(v1,v2);
03898 }
03899 
03901 
03904 inline bool operator>=(const scivector& v1, const civector& v2) {
03905   return spf_vv_geq<scivector,civector,cinterval>(v1,v2);
03906 }
03907 
03909 
03912 inline bool operator>=(const sivector& v1, const civector& v2) {
03913   return spf_vv_geq<sivector,civector,cinterval>(v1,v2);
03914 }
03915 
03917 
03920 inline bool operator>=(const civector& v1, const srvector& v2) {
03921   return fsp_vv_geq<civector,srvector,cinterval>(v1,v2);
03922 }
03923 
03925 
03928 inline bool operator>=(const civector& v1, const scvector& v2) {
03929   return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
03930 }
03931 
03933 
03936 inline bool operator>=(const civector& v1, const sivector& v2) {
03937   return fsp_vv_geq<civector,sivector,cinterval>(v1,v2);
03938 }
03939 
03941 
03944 inline bool operator>=(const civector& v1, const scivector& v2) {
03945   return fsp_vv_geq<civector,scivector,cinterval>(v1,v2);
03946 }
03947 
03949 
03952 inline bool operator>=(const ivector& v1, const scivector& v2) {
03953   return fsp_vv_geq<ivector,scivector,cinterval>(v1,v2);
03954 }
03955 
03957 
03960 inline bool operator>=(const scivector& v1, const rvector_slice& v2) {
03961   return spf_vv_geq<scivector,rvector_slice,cinterval>(v1,v2);
03962 }
03963 
03965 
03968 inline bool operator>=(const scivector& v1, const ivector_slice& v2) {
03969   return spf_vv_geq<scivector,ivector_slice,cinterval>(v1,v2);
03970 }
03971 
03973 
03976 inline bool operator>=(const scivector& v1, const cvector_slice& v2) {
03977   return spf_vv_geq<scivector,cvector_slice,cinterval>(v1,v2);
03978 }
03979 
03981 
03984 inline bool operator>=(const sivector& v1, const civector_slice& v2) {
03985   return spf_vv_geq<sivector,civector_slice,cinterval>(v1,v2);
03986 }
03987 
03989 
03992 inline bool operator>=(const scivector& v1, const civector_slice& v2) {
03993   return spf_vv_geq<scivector,civector_slice,cinterval>(v1,v2);
03994 }
03995 
03997 
04000 inline bool operator>=(const civector_slice& v1, const srvector& v2) {
04001   return fsp_vv_geq<civector_slice,srvector,cinterval>(v1,v2);
04002 }
04003 
04005 
04008 inline bool operator>=(const civector_slice& v1, const sivector& v2) {
04009   return fsp_vv_geq<civector_slice,sivector,cinterval>(v1,v2);
04010 }
04011 
04013 
04016 inline bool operator>=(const civector_slice& v1, const scvector& v2) {
04017   return fsp_vv_geq<civector,scvector,cinterval>(v1,v2);
04018 }
04019 
04021 
04024 inline bool operator>=(const ivector_slice& v1, const scivector& v2) {
04025   return fsp_vv_geq<ivector_slice,scivector,cinterval>(v1,v2);
04026 }
04027 
04029 
04032 inline bool operator>=(const civector_slice& v1, const scivector& v2) {
04033   return fsp_vv_geq<civector_slice,scivector,cinterval>(v1,v2);
04034 }
04035 
04037 
04042 inline std::ostream& operator<<(std::ostream& os, const scivector& v) {
04043   return sp_v_output<scivector,cinterval>(os,v);
04044 }
04045 
04047 
04052 inline std::istream& operator>>(std::istream& is, scivector& v) {
04053   return sp_v_input<scivector,cinterval>(is,v);
04054 }
04055 
04056 
04058 
04063 class scivector_slice {
04064   private:
04065     std::vector<int>& p;
04066     std::vector<cinterval>& x;
04067     scivector& orig;
04068     int start,end;
04069     int lb;
04070     int ub;
04071     int n;
04072     int nnz;
04073     int offset;
04074 
04076 
04080     scivector_slice(scivector& v, int l, int u) : p(v.p), x(v.x), orig(v), lb(l), ub(u), n(u-l+1) {
04081       int i;
04082 
04083       for(i=0 ; i<v.get_nnz() && p[i]<lb-v.lb ; i++);
04084 
04085       start = i;
04086 
04087       for(i=start ; i<v.get_nnz() && p[i]<=ub-v.lb ; i++);
04088 
04089       end = i-1;
04090 
04091       nnz = end-start+1;
04092       offset = lb-v.lb;
04093     }
04094 
04095   public:
04096 
04098     int get_nnz() const {
04099       return nnz;
04100     }
04101 
04103     real density() const {
04104       return (double)nnz/n;
04105     }
04106 
04108 
04112     cinterval& operator[](const int i) {
04113 #if(CXSC_INDEX_CHECK)
04114       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator[](const int)"));
04115 #endif
04116       int k;
04117 
04118       for(k=start ; k<end+1 && p[k]-start<=i-lb ; k++) {
04119         if(p[k]-offset == i-lb) 
04120           return x[k];
04121       }
04122 
04123       p.insert(p.begin() + k, i-lb);
04124       x.insert(x.begin() + k, cinterval(0.0));
04125       end++;
04126 
04127       return x[k];
04128     }
04129 
04131 
04135     cinterval operator[](const int i) const {
04136 #if(CXSC_INDEX_CHECK)
04137       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator[](const int)"));
04138 #endif
04139       return (*this)(i);
04140     }
04141 
04143 
04147     const cinterval operator()(const int i) const {
04148 #if(CXSC_INDEX_CHECK)
04149       if(i<lb || i>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator()(const int)"));
04150 #endif
04151       cinterval r(0.0);
04152 
04153       for(int k=start ; k<end && p[k]-start<=i-lb ; k++) {
04154         if(p[k]-start == i-lb) 
04155           r = x[k];
04156       }
04157 
04158       return r; 
04159     }
04160 
04162     scivector_slice& operator=(const real& v) {
04163       return sl_vs_assign<scivector_slice,real,cinterval,std::vector<cinterval>::iterator>(*this,v);
04164     }
04165 
04167     scivector_slice& operator=(const complex& v) {
04168       return sl_vs_assign<scivector_slice,complex,cinterval,std::vector<cinterval>::iterator>(*this,v);
04169     }
04170 
04172     scivector_slice& operator=(const interval& v) {
04173       return sl_vs_assign<scivector_slice,interval,cinterval,std::vector<cinterval>::iterator>(*this,v);
04174     }
04175 
04177     scivector_slice& operator=(const cinterval& v) {
04178       return sl_vs_assign<scivector_slice,cinterval,cinterval,std::vector<cinterval>::iterator>(*this,v);
04179     }
04180 
04182     scivector_slice& operator=(const srvector_slice& v) {
04183       return slsl_vv_assign<scivector_slice,srvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04184     }
04185 
04187     scivector_slice& operator=(const scvector_slice& v) {
04188       return slsl_vv_assign<scivector_slice,scvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04189     }
04190 
04192     scivector_slice& operator=(const sivector_slice& v) {
04193       return slsl_vv_assign<scivector_slice,sivector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04194     }
04195 
04197     scivector_slice& operator=(const scivector_slice& v) {
04198       return slsl_vv_assign<scivector_slice,scivector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04199     }
04200 
04202     scivector_slice& operator=(const srvector& v) {
04203       return slsp_vv_assign<scivector_slice,srvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04204     }
04205 
04207     scivector_slice& operator=(const scvector& v) {
04208       return slsp_vv_assign<scivector_slice,scvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04209     }
04210 
04212     scivector_slice& operator=(const sivector& v) {
04213       return slsp_vv_assign<scivector_slice,sivector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04214     }
04215 
04217     scivector_slice& operator=(const scivector& v) {
04218       return slsp_vv_assign<scivector_slice,scivector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04219     }
04220 
04222     scivector_slice& operator=(const rvector& v) {
04223       return slf_vv_assign<scivector_slice,rvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04224     }
04225 
04227     scivector_slice& operator=(const cvector& v) {
04228       return slf_vv_assign<scivector_slice,cvector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04229     }
04230 
04232     scivector_slice& operator=(const ivector& v) {
04233       return slf_vv_assign<scivector_slice,ivector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04234     }
04235 
04237     scivector_slice& operator=(const civector& v) {
04238       return slf_vv_assign<scivector_slice,civector,cinterval,std::vector<cinterval>::iterator>(*this,v);
04239     }
04240 
04242     scivector_slice& operator=(const rvector_slice& v) {
04243       return slf_vv_assign<scivector_slice,rvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04244     }
04245 
04247     scivector_slice& operator=(const cvector_slice& v) {
04248       return slf_vv_assign<scivector_slice,cvector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04249     }
04250 
04252     scivector_slice& operator=(const ivector_slice& v) {
04253       return slf_vv_assign<scivector_slice,ivector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04254     }
04255 
04257     scivector_slice& operator=(const civector_slice& v) {
04258       return slf_vv_assign<scivector_slice,civector_slice,cinterval,std::vector<cinterval>::iterator>(*this,v);
04259     }
04260 
04262     scivector_slice& operator*=(const real& s) {
04263       return sl_vs_multassign(*this,s);
04264     }
04265 
04267     scivector_slice& operator*=(const complex& s) {
04268       return sl_vs_multassign(*this,s);
04269     }
04270 
04272     scivector_slice& operator*=(const interval& s) {
04273       return sl_vs_multassign(*this,s);
04274     }
04275 
04277     scivector_slice& operator*=(const cinterval& s) {
04278       return sl_vs_multassign(*this,s);
04279     }
04280 
04282     scivector_slice& operator/=(const real& s) {
04283       return sl_vs_divassign(*this,s);
04284     }
04285 
04287     scivector_slice& operator/=(const complex& s) {
04288       return sl_vs_divassign(*this,s);
04289     }
04291     scivector_slice& operator/=(const interval& s) {
04292       return sl_vs_divassign(*this,s);
04293     }
04294 
04296     scivector_slice& operator/=(const cinterval& s) {
04297       return sl_vs_divassign(*this,s);
04298     }
04299 
04301     scivector_slice& operator+=(const rvector& v) {
04302       return slf_vv_addassign<scivector_slice,rvector,cinterval>(*this,v);
04303     }
04304 
04306     scivector_slice& operator+=(const ivector& v) {
04307       return slf_vv_addassign<scivector_slice,ivector,cinterval>(*this,v);
04308     }
04309 
04311     scivector_slice& operator+=(const cvector& v) {
04312       return slf_vv_addassign<scivector_slice,cvector,cinterval>(*this,v);
04313     }
04314 
04316     scivector_slice& operator+=(const civector& v) {
04317       return slf_vv_addassign<scivector_slice,civector,cinterval>(*this,v);
04318     }
04319 
04321     scivector_slice& operator+=(const rvector_slice& v) {
04322       return slf_vv_addassign<scivector_slice,rvector_slice,cinterval>(*this,v);
04323     }
04324 
04326     scivector_slice& operator+=(const cvector_slice& v) {
04327       return slf_vv_addassign<scivector_slice,cvector_slice,cinterval>(*this,v);
04328     }
04329 
04331     scivector_slice& operator+=(const ivector_slice& v) {
04332       return slf_vv_addassign<scivector_slice,ivector_slice,cinterval>(*this,v);
04333     }
04334 
04336     scivector_slice& operator+=(const civector_slice& v) {
04337       return slf_vv_addassign<scivector_slice,civector_slice,cinterval>(*this,v);
04338     }
04339 
04341     scivector_slice& operator+=(const srvector& v) {
04342       return slsp_vv_addassign(*this,v);
04343     }
04344 
04346     scivector_slice& operator+=(const scvector& v) {
04347       return slsp_vv_addassign(*this,v);
04348     }
04349 
04351     scivector_slice& operator+=(const sivector& v) {
04352       return slsp_vv_addassign(*this,v);
04353     }
04354 
04356     scivector_slice& operator+=(const scivector& v) {
04357       return slsp_vv_addassign(*this,v);
04358     }
04359 
04361     scivector_slice& operator+=(const srvector_slice& v) {
04362       return slsl_vv_addassign(*this,v);
04363     }
04364 
04366     scivector_slice& operator+=(const scvector_slice& v) {
04367       return slsl_vv_addassign(*this,v);
04368     }
04369 
04371     scivector_slice& operator+=(const sivector_slice& v) {
04372       return slsl_vv_addassign(*this,v);
04373     }
04374 
04376     scivector_slice& operator+=(const scivector_slice& v) {
04377       return slsl_vv_addassign(*this,v);
04378     }
04379 
04381     scivector_slice& operator-=(const rvector& v) {
04382       return slf_vv_subassign<scivector_slice,rvector,cinterval>(*this,v);
04383     }
04384 
04386     scivector_slice& operator-=(const ivector& v) {
04387       return slf_vv_subassign<scivector_slice,ivector,cinterval>(*this,v);
04388     }
04389 
04391     scivector_slice& operator-=(const cvector& v) {
04392       return slf_vv_subassign<scivector_slice,cvector,cinterval>(*this,v);
04393     }
04394 
04396     scivector_slice& operator-=(const civector& v) {
04397       return slf_vv_subassign<scivector_slice,civector,cinterval>(*this,v);
04398     }
04399 
04401     scivector_slice& operator-=(const rvector_slice& v) {
04402       return slf_vv_subassign<scivector_slice,rvector_slice,cinterval>(*this,v);
04403     }
04404 
04406     scivector_slice& operator-=(const cvector_slice& v) {
04407       return slf_vv_subassign<scivector_slice,cvector_slice,cinterval>(*this,v);
04408     }
04409 
04411     scivector_slice& operator-=(const ivector_slice& v) {
04412       return slf_vv_subassign<scivector_slice,ivector_slice,cinterval>(*this,v);
04413     }
04414 
04416     scivector_slice& operator-=(const civector_slice& v) {
04417       return slf_vv_subassign<scivector_slice,civector_slice,cinterval>(*this,v);
04418     }
04419 
04421     scivector_slice& operator-=(const srvector& v) {
04422       return slsp_vv_subassign(*this,v);
04423     }
04424 
04426     scivector_slice& operator-=(const scvector& v) {
04427       return slsp_vv_subassign(*this,v);
04428     }
04429 
04431     scivector_slice& operator-=(const sivector& v) {
04432       return slsp_vv_subassign(*this,v);
04433     }
04434 
04436     scivector_slice& operator-=(const scivector& v) {
04437       return slsp_vv_subassign(*this,v);
04438     }
04439 
04441     scivector_slice& operator-=(const srvector_slice& v) {
04442       return slsl_vv_subassign(*this,v);
04443     }
04444 
04446     scivector_slice& operator-=(const scvector_slice& v) {
04447       return slsl_vv_subassign(*this,v);
04448     }
04449 
04451     scivector_slice& operator-=(const sivector_slice& v) {
04452       return slsl_vv_subassign(*this,v);
04453     }
04454 
04456     scivector_slice& operator-=(const scivector_slice& v) {
04457       return slsl_vv_subassign(*this,v);
04458     }
04459 
04461     scivector_slice& operator|=(const rvector& v) {
04462       return slf_vv_hullassign<scivector_slice,rvector,cinterval>(*this,v);
04463     }
04464 
04466     scivector_slice& operator|=(const ivector& v) {
04467       return slf_vv_hullassign<scivector_slice,ivector,cinterval>(*this,v);
04468     }
04469 
04471     scivector_slice& operator|=(const cvector& v) {
04472       return slf_vv_hullassign<scivector_slice,cvector,cinterval>(*this,v);
04473     }
04474 
04476     scivector_slice& operator|=(const civector& v) {
04477       return slf_vv_hullassign<scivector_slice,civector,cinterval>(*this,v);
04478     }
04479 
04481     scivector_slice& operator|=(const rvector_slice& v) {
04482       return slf_vv_hullassign<scivector_slice,rvector_slice,cinterval>(*this,v);
04483     }
04484 
04486     scivector_slice& operator|=(const cvector_slice& v) {
04487       return slf_vv_hullassign<scivector_slice,cvector_slice,cinterval>(*this,v);
04488     }
04489 
04491     scivector_slice& operator|=(const ivector_slice& v) {
04492       return slf_vv_hullassign<scivector_slice,ivector_slice,cinterval>(*this,v);
04493     }
04494 
04496     scivector_slice& operator|=(const civector_slice& v) {
04497       return slf_vv_hullassign<scivector_slice,civector_slice,cinterval>(*this,v);
04498     }
04499 
04501     scivector_slice& operator|=(const srvector& v) {
04502       return slsp_vv_hullassign(*this,v);
04503     }
04504 
04506     scivector_slice& operator|=(const scvector& v) {
04507       return slsp_vv_hullassign(*this,v);
04508     }
04509 
04511     scivector_slice& operator|=(const sivector& v) {
04512       return slsp_vv_hullassign(*this,v);
04513     }
04514 
04516     scivector_slice& operator|=(const scivector& v) {
04517       return slsp_vv_hullassign(*this,v);
04518     }
04519 
04521     scivector_slice& operator|=(const srvector_slice& v) {
04522       return slsl_vv_hullassign(*this,v);
04523     }
04524 
04526     scivector_slice& operator|=(const scvector_slice& v) {
04527       return slsl_vv_hullassign(*this,v);
04528     }
04529 
04531     scivector_slice& operator|=(const sivector_slice& v) {
04532       return slsl_vv_hullassign(*this,v);
04533     }
04534 
04536     scivector_slice& operator|=(const scivector_slice& v) {
04537       return slsl_vv_hullassign(*this,v);
04538     }
04539 
04541     scivector_slice& operator&=(const ivector& v) {
04542       return slf_vv_intersectassign<scivector_slice,ivector,cinterval>(*this,v);
04543     }
04544 
04546     scivector_slice& operator&=(const civector& v) {
04547       return slf_vv_intersectassign<scivector_slice,civector,cinterval>(*this,v);
04548     }
04549 
04551     scivector_slice& operator&=(const ivector_slice& v) {
04552       return slf_vv_intersectassign<scivector_slice,ivector_slice,cinterval>(*this,v);
04553     }
04554 
04556     scivector_slice& operator&=(const civector_slice& v) {
04557       return slf_vv_intersectassign<scivector_slice,civector_slice,cinterval>(*this,v);
04558     }
04559 
04561     scivector_slice& operator&=(const sivector& v) {
04562       return slsp_vv_intersectassign(*this,v);
04563     }
04564 
04566     scivector_slice& operator&=(const scivector& v) {
04567       return slsp_vv_intersectassign(*this,v);
04568     }
04569 
04571     scivector_slice& operator&=(const sivector_slice& v) {
04572       return slsl_vv_intersectassign(*this,v);
04573     }
04574 
04576     scivector_slice& operator&=(const scivector_slice& v) {
04577       return slsl_vv_intersectassign(*this,v);
04578     }
04579 
04580     friend int Lb(const scivector_slice&);
04581     friend int Ub(const scivector_slice&);
04582     friend sivector Re(const scivector_slice&);
04583     friend sivector Im(const scivector_slice&);
04584     friend scvector Inf(const scivector_slice&);
04585     friend scvector Sup(const scivector_slice&);
04586     friend srvector InfRe(const scivector_slice&);
04587     friend srvector InfIm(const scivector_slice&);
04588     friend srvector SupRe(const scivector_slice&);
04589     friend srvector SupIm(const scivector_slice&);
04590     friend sivector abs(const scivector_slice&);
04591     friend scivector conj(const scivector_slice&);
04592     friend scvector mid(const scivector_slice&);
04593     friend scvector diam(const scivector_slice&);
04594     friend int VecLen(const scivector_slice&);
04595 
04596 //     friend srvector operator*(const srmatrix&, const srvector_slice&); //ok
04597 //     friend srvector operator*(const srmatrix_slice&, const srvector_slice&); //ok
04598 
04599     friend class srvector;
04600     friend class scvector;
04601     friend class sivector;
04602     friend class scivector;
04603     friend class civector;
04604     friend class civector_slice;
04605 
04606 #include "vector_friend_declarations.inl"
04607 };
04608 
04609 inline civector::civector(const srvector_slice& v) {
04610   l = v.lb;
04611   u = v.ub;
04612   size = v.n;
04613   dat = new cinterval[v.n];
04614   for(int i=0 ; i<v.n ; i++)
04615     dat[i] = 0.0;
04616   for(int i=v.start ; i<=v.end ; i++)
04617     dat[v.p[i]] = v.x[i];
04618 }
04619 
04620 inline civector::civector(const scvector_slice& v) {
04621   l = v.lb;
04622   u = v.ub;
04623   size = v.n;
04624   dat = new cinterval[v.n];
04625   for(int i=0 ; i<v.n ; i++)
04626     dat[i] = 0.0;
04627   for(int i=v.start ; i<=v.end ; i++)
04628     dat[v.p[i]] = v.x[i];
04629 }
04630 
04631 inline civector::civector(const sivector_slice& v) {
04632   l = v.lb;
04633   u = v.ub;
04634   size = v.n;
04635   dat = new cinterval[v.n];
04636   for(int i=0 ; i<v.n ; i++)
04637     dat[i] = 0.0;
04638   for(int i=v.start ; i<=v.end ; i++)
04639     dat[v.p[i]] = v.x[i];
04640 }
04641 
04642 inline civector::civector(const scivector_slice& v) {
04643   l = v.lb;
04644   u = v.ub;
04645   size = v.n;
04646   dat = new cinterval[v.n];
04647   for(int i=0 ; i<v.n ; i++)
04648     dat[i] = 0.0;
04649   for(int i=v.start ; i<=v.end ; i++)
04650     dat[v.p[i]] = v.x[i];
04651 }
04652 
04653 inline civector_slice& civector_slice::operator=(const srvector& v) {
04654   *this = rvector(v);
04655   return *this;
04656 }
04657 
04658 inline civector_slice& civector_slice::operator=(const srvector_slice& v) {
04659   *this = rvector(v);
04660   return *this;
04661 }
04662 
04663 inline civector_slice& civector_slice::operator=(const sivector& v) {
04664   *this = ivector(v);
04665   return *this;
04666 }
04667 
04668 inline civector_slice& civector_slice::operator=(const sivector_slice& v) {
04669   *this = ivector(v);
04670   return *this;
04671 }
04672 
04673 inline civector_slice& civector_slice::operator=(const scvector& v) {
04674   *this = cvector(v);
04675   return *this;
04676 }
04677 
04678 inline civector_slice& civector_slice::operator=(const scvector_slice& v) {
04679   *this = cvector(v);
04680   return *this;
04681 }
04682 
04683 inline civector_slice& civector_slice::operator=(const scivector& v) {
04684   *this = civector(v);
04685   return *this;
04686 }
04687 
04688 inline civector_slice& civector_slice::operator=(const scivector_slice& v) {
04689   *this = civector(v);
04690   return *this;
04691 }
04692 
04693 inline scivector::scivector(const srvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n)  {
04694   p.reserve(s.nnz);
04695   x.reserve(s.nnz);
04696 
04697   for(int i=s.start ; i<=s.end ; i++) {
04698     p.push_back(s.p[i]-s.offset);
04699     x.push_back(cinterval(s.x[i]));
04700   }
04701 
04702 }
04703 
04704 inline scivector::scivector(const scvector_slice& s) : lb(s.lb), ub(s.ub), n(s.n)  {
04705   p.reserve(s.nnz);
04706   x.reserve(s.nnz);
04707 
04708   for(int i=s.start ; i<=s.end ; i++) {
04709     p.push_back(s.p[i]-s.offset);
04710     x.push_back(cinterval(s.x[i]));
04711   }
04712 
04713 }
04714 
04715 inline scivector::scivector(const sivector_slice& s) : lb(s.lb), ub(s.ub), n(s.n)  {
04716   p.reserve(s.nnz);
04717   x.reserve(s.nnz);
04718 
04719   for(int i=s.start ; i<=s.end ; i++) {
04720     p.push_back(s.p[i]-s.offset);
04721     x.push_back(cinterval(s.x[i]));
04722   }
04723 
04724 }
04725 
04726 inline scivector::scivector(const scivector_slice& s) : lb(s.lb), ub(s.ub), n(s.n)  {
04727   p.reserve(s.nnz);
04728   x.reserve(s.nnz);
04729 
04730   for(int i=s.start ; i<=s.end ; i++) {
04731     p.push_back(s.p[i]-s.offset);
04732     x.push_back(s.x[i]);
04733   }
04734 
04735 }
04736 
04737 inline scivector& scivector::operator=(const srvector_slice& v) {
04738   return spsl_vv_assign<scivector,srvector_slice,cinterval>(*this,v);
04739 }
04740 
04741 inline scivector& scivector::operator=(const scvector_slice& v) {
04742   return spsl_vv_assign<scivector,scvector_slice,cinterval>(*this,v);
04743 }
04744 
04745 inline scivector& scivector::operator=(const sivector_slice& v) {
04746   return spsl_vv_assign<scivector,sivector_slice,cinterval>(*this,v);
04747 }
04748 
04749 inline scivector& scivector::operator=(const scivector_slice& v) {
04750   return spsl_vv_assign<scivector,scivector_slice,cinterval>(*this,v);
04751 }
04752 
04753 inline scivector_slice scivector::operator()(const int i, const int j) {
04754 #if(CXSC_INDEX_CHECK)
04755   if(i<lb || j>ub) cxscthrow(ELEMENT_NOT_IN_VEC("scivector_slice::operator()(const int, const int)"));
04756 #endif
04757   return scivector_slice(*this,i,j);
04758 }
04759 
04761 inline scivector operator-(const scivector_slice& v) {
04762   return sl_v_negative<scivector_slice,scivector>(v);
04763 }
04764 
04766 inline int Lb(const scivector_slice& v) {
04767   return v.lb;
04768 }
04769 
04771 inline int Ub(const scivector_slice& v) {
04772   return v.ub;
04773 }
04774 
04776 inline sivector Re(const scivector_slice& v) {
04777   return Re(scivector(v));
04778 }
04779 
04781 inline sivector Im(const scivector_slice& v) {
04782   return Im(scivector(v));
04783 }
04784 
04786 inline scvector Inf(const scivector_slice& v) {
04787   return Inf(scivector(v));
04788 }
04789 
04791 inline scvector Sup(const scivector_slice& v) {
04792   return Sup(scivector(v));
04793 }
04794 
04796 inline srvector InfRe(const scivector_slice& v) {
04797   return InfRe(scivector(v));
04798 }
04799 
04801 inline srvector InfIm(const scivector_slice& v) {
04802   return InfIm(scivector(v));
04803 }
04804 
04806 inline srvector SupRe(const scivector_slice& v) {
04807   return SupRe(scivector(v));
04808 }
04809 
04811 inline srvector SupIm(const scivector_slice& v) {
04812   return SupIm(scivector(v));
04813 }
04814 
04816 inline scivector conj(const scivector_slice& v) {
04817   scivector res(v.n, v.nnz);
04818   res.lb = v.lb;
04819   res.ub = v.ub;
04820   res.p = v.p;
04821   for(int i=v.start ; i<=v.end ; i++)
04822     res.x.push_back(conj(v.x[i]));
04823   return res;
04824 }
04825 
04827 inline sivector abs(const scivector_slice& v) {
04828   sivector res(v.n, v.nnz);
04829   res.lb = v.lb;
04830   res.ub = v.ub;
04831   res.p = v.p;
04832   for(int i=v.start ; i<=v.end ; i++)
04833     res.x.push_back(abs(v.x[i]));
04834   return res;
04835 }
04836 
04838 inline scvector mid(const scivector_slice& v) {
04839   scvector res(v.n, v.nnz);
04840   res.lb = v.lb;
04841   res.ub = v.ub;
04842   res.p = v.p;
04843   for(int i=v.start ; i<=v.end ; i++)
04844     res.x.push_back(mid(v.x[i]));
04845   return res;
04846 }
04847 
04849 inline scvector diam(const scivector_slice& v) {
04850   scvector res(v.n, v.nnz);
04851   res.lb = v.lb;
04852   res.ub = v.ub;
04853   res.p = v.p;
04854   for(int i=v.start ; i<v.end ; i++)
04855     res.x.push_back(diam(v.x[i]));
04856   return res;
04857 }
04858 
04860 inline int VecLen(const scivector_slice& v) {
04861   return v.n;
04862 }
04863 
04865 
04871 inline cinterval operator*(const scivector_slice& v1, const rvector& v2) {
04872   return slf_vv_mult<scivector_slice,rvector,cinterval,sparse_cidot>(v1,v2);
04873 }
04874 
04876 
04882 inline cinterval operator*(const scivector_slice& v1, const cvector& v2) {
04883   return slf_vv_mult<scivector_slice,cvector,cinterval,sparse_cidot>(v1,v2);
04884 }
04885 
04887 
04893 inline cinterval operator*(const scivector_slice& v1, const ivector& v2) {
04894   return slf_vv_mult<scivector_slice,ivector,cinterval,sparse_cidot>(v1,v2);
04895 }
04896 
04898 
04904 inline cinterval operator*(const scivector_slice& v1, const civector& v2) {
04905   return slf_vv_mult<scivector_slice,civector,cinterval,sparse_cidot>(v1,v2);
04906 }
04907 
04909 
04915 inline cinterval operator*(const srvector_slice& v1, const civector& v2) {
04916   return slf_vv_mult<srvector_slice,civector,cinterval,sparse_cidot>(v1,v2);
04917 }
04918 
04920 
04926 inline cinterval operator*(const sivector_slice& v1, const civector& v2) {
04927   return slf_vv_mult<sivector_slice,civector,cinterval,sparse_cidot>(v1,v2);
04928 }
04929 
04931 
04937 inline cinterval operator*(const scvector_slice& v1, const civector& v2) {
04938   return slf_vv_mult<scvector_slice,civector,cinterval,sparse_cidot>(v1,v2);
04939 }
04940 
04942 
04948 inline cinterval operator*(const scvector_slice& v1, const ivector& v2) {
04949   return slf_vv_mult<scvector_slice,ivector,cinterval,sparse_cidot>(v1,v2);
04950 }
04951 
04953 
04959 inline cinterval operator*(const sivector_slice& v1, const cvector& v2) {
04960   return slf_vv_mult<sivector_slice,cvector,cinterval,sparse_cidot>(v1,v2);
04961 }
04962 
04964 
04970 inline cinterval operator*(const civector& v1, const srvector_slice& v2) {
04971   return fsl_vv_mult<civector,srvector_slice,cinterval,sparse_cidot>(v1,v2);
04972 }
04973 
04975 
04981 inline cinterval operator*(const civector& v1, const scvector_slice& v2) {
04982   return fsl_vv_mult<civector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
04983 }
04984 
04986 
04992 inline cinterval operator*(const civector& v1, const sivector_slice& v2) {
04993   return fsl_vv_mult<civector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
04994 }
04995 
04997 
05003 inline cinterval operator*(const civector& v1, const scivector_slice& v2) {
05004   return fsl_vv_mult<civector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05005 }
05006 
05008 
05014 inline cinterval operator*(const rvector& v1, const scivector_slice& v2) {
05015   return fsl_vv_mult<rvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05016 }
05017 
05019 
05025 inline cinterval operator*(const cvector& v1, const scivector_slice& v2) {
05026   return fsl_vv_mult<cvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05027 }
05028 
05030 
05036 inline cinterval operator*(const ivector& v1, const scivector_slice& v2) {
05037   return fsl_vv_mult<ivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05038 }
05039 
05041 
05047 inline cinterval operator*(const cvector& v1, const sivector_slice& v2) {
05048   return fsl_vv_mult<cvector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05049 }
05050 
05052 
05058 inline cinterval operator*(const ivector& v1, const scvector_slice& v2) {
05059   return fsl_vv_mult<ivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05060 }
05061 
05063 
05069 inline cinterval operator*(const scivector_slice& v1, const rvector_slice& v2) {
05070   return slf_vv_mult<scivector_slice,rvector_slice,cinterval,sparse_cidot>(v1,v2);
05071 }
05072 
05074 
05080 inline cinterval operator*(const scivector_slice& v1, const ivector_slice& v2) {
05081   return slf_vv_mult<scivector_slice,ivector_slice,cinterval,sparse_cidot>(v1,v2);
05082 }
05083 
05085 
05091 inline cinterval operator*(const scivector_slice& v1, const cvector_slice& v2) {
05092   return slf_vv_mult<scivector_slice,cvector_slice,cinterval,sparse_cidot>(v1,v2);
05093 }
05094 
05096 
05102 inline cinterval operator*(const scivector_slice& v1, const civector_slice& v2) {
05103   return slf_vv_mult<scivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
05104 }
05105 
05107 
05113 inline cinterval operator*(const srvector_slice& v1, const civector_slice& v2) {
05114   return slf_vv_mult<srvector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
05115 }
05116 
05118 
05124 inline cinterval operator*(const scvector_slice& v1, const civector_slice& v2) {
05125   return slf_vv_mult<scvector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
05126 }
05127 
05129 
05135 inline cinterval operator*(const sivector_slice& v1, const civector_slice& v2) {
05136   return slf_vv_mult<sivector_slice,civector_slice,cinterval,sparse_cidot>(v1,v2);
05137 }
05138 
05140 
05146 inline cinterval operator*(const scvector_slice& v1, const ivector_slice& v2) {
05147   return slf_vv_mult<scvector_slice,ivector_slice,cinterval,sparse_cidot>(v1,v2);
05148 }
05149 
05151 
05157 inline cinterval operator*(const sivector_slice& v1, const cvector_slice& v2) {
05158   return slf_vv_mult<sivector_slice,cvector_slice,cinterval,sparse_cidot>(v1,v2);
05159 }
05160 
05162 
05168 inline cinterval operator*(const civector_slice& v1, const srvector_slice& v2) {
05169   return fsl_vv_mult<civector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
05170 }
05171 
05173 
05179 inline cinterval operator*(const civector_slice& v1, const scvector_slice& v2) {
05180   return fsl_vv_mult<civector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05181 }
05182 
05184 
05190 inline cinterval operator*(const civector_slice& v1, const sivector_slice& v2) {
05191   return fsl_vv_mult<civector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05192 }
05193 
05195 
05201 inline cinterval operator*(const civector_slice& v1, const scivector_slice& v2) {
05202   return fsl_vv_mult<civector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05203 }
05204 
05206 
05212 inline cinterval operator*(const rvector_slice& v1, const scivector_slice& v2) {
05213   return fsl_vv_mult<rvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05214 }
05215 
05217 
05223 inline cinterval operator*(const ivector_slice& v1, const scivector_slice& v2) {
05224   return fsl_vv_mult<ivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05225 }
05226 
05228 
05234 inline cinterval operator*(const cvector_slice& v1, const scivector_slice& v2) {
05235   return fsl_vv_mult<cvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05236 }
05237 
05239 
05245 inline cinterval operator*(const cvector_slice& v1, const sivector_slice& v2) {
05246   return fsl_vv_mult<cvector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05247 }
05248 
05250 
05256 inline cinterval operator*(const ivector_slice& v1, const scvector_slice& v2) {
05257   return fsl_vv_mult<ivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05258 }
05259 
05261 
05267 inline cinterval operator*(const scivector& v1, const srvector_slice& v2) {
05268   return spsl_vv_mult<scivector,srvector_slice,cinterval,sparse_cidot>(v1,v2);
05269 }
05270 
05272 
05278 inline cinterval operator*(const scivector& v1, const scvector_slice& v2) {
05279   return spsl_vv_mult<scivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05280 }
05281 
05283 
05289 inline cinterval operator*(const scivector& v1, const sivector_slice& v2) {
05290   return spsl_vv_mult<scivector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05291 }
05292 
05294 
05300 inline cinterval operator*(const scivector& v1, const scivector_slice& v2) {
05301   return spsl_vv_mult<scivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05302 }
05303 
05305 
05311 inline cinterval operator*(const srvector& v1, const scivector_slice& v2) {
05312   return spsl_vv_mult<srvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05313 }
05314 
05316 
05322 inline cinterval operator*(const scvector& v1, const scivector_slice& v2) {
05323   return spsl_vv_mult<scvector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05324 }
05325 
05327 
05333 inline cinterval operator*(const sivector& v1, const scivector_slice& v2) {
05334   return spsl_vv_mult<sivector,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05335 }
05336 
05338 
05344 inline cinterval operator*(const scvector& v1, const sivector_slice& v2) {
05345   return spsl_vv_mult<scvector,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05346 }
05347 
05349 
05355 inline cinterval operator*(const sivector& v1, const scvector_slice& v2) {
05356   return spsl_vv_mult<sivector,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05357 }
05358 
05360 
05366 inline cinterval operator*(const scivector_slice& v1, const srvector& v2) {
05367   return slsp_vv_mult<scivector_slice,srvector,cinterval,sparse_cidot>(v1,v2);
05368 }
05369 
05371 
05377 inline cinterval operator*(const scivector_slice& v1, const scvector& v2) {
05378   return slsp_vv_mult<scivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
05379 }
05380 
05382 
05388 inline cinterval operator*(const scivector_slice& v1, const sivector& v2) {
05389   return slsp_vv_mult<scivector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
05390 }
05391 
05393 
05399 inline cinterval operator*(const scivector_slice& v1, const scivector& v2) {
05400   return slsp_vv_mult<scivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
05401 }
05402 
05404 
05410 inline cinterval operator*(const srvector_slice& v1, const scivector& v2) {
05411   return slsp_vv_mult<srvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
05412 }
05413 
05415 
05421 inline cinterval operator*(const sivector_slice& v1, const scivector& v2) {
05422   return slsp_vv_mult<sivector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
05423 }
05424 
05426 
05432 inline cinterval operator*(const scvector_slice& v1, const scivector& v2) {
05433   return slsp_vv_mult<scvector_slice,scivector,cinterval,sparse_cidot>(v1,v2);
05434 }
05435 
05437 
05443 inline cinterval operator*(const scvector_slice& v1, const sivector& v2) {
05444   return slsp_vv_mult<scvector_slice,sivector,cinterval,sparse_cidot>(v1,v2);
05445 }
05446 
05448 
05454 inline cinterval operator*(const sivector_slice& v1, const scvector& v2) {
05455   return slsp_vv_mult<sivector_slice,scvector,cinterval,sparse_cidot>(v1,v2);
05456 }
05457 
05459 
05465 inline cinterval operator*(const scivector_slice& v1, const srvector_slice& v2) {
05466   return slsl_vv_mult<scivector_slice,srvector_slice,cinterval,sparse_cidot>(v1,v2);
05467 }
05468 
05470 
05476 inline cinterval operator*(const scivector_slice& v1, const scvector_slice& v2) {
05477   return slsl_vv_mult<scivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05478 }
05479 
05481 
05487 inline cinterval operator*(const scivector_slice& v1, const sivector_slice& v2) {
05488   return slsl_vv_mult<scivector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05489 }
05490 
05492 
05498 inline cinterval operator*(const scivector_slice& v1, const scivector_slice& v2) {
05499   return slsl_vv_mult<scivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05500 }
05501 
05503 
05509 inline cinterval operator*(const srvector_slice& v1, const scivector_slice& v2) {
05510   return slsl_vv_mult<srvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05511 }
05512 
05514 
05520 inline cinterval operator*(const scvector_slice& v1, const scivector_slice& v2) {
05521   return slsl_vv_mult<scvector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05522 }
05523 
05525 
05531 inline cinterval operator*(const sivector_slice& v1, const scivector_slice& v2) {
05532   return slsl_vv_mult<sivector_slice,scivector_slice,cinterval,sparse_cidot>(v1,v2);
05533 }
05534 
05536 
05542 inline cinterval operator*(const sivector_slice& v1, const scvector_slice& v2) {
05543   return slsl_vv_mult<sivector_slice,scvector_slice,cinterval,sparse_cidot>(v1,v2);
05544 }
05545 
05547 
05553 inline cinterval operator*(const scvector_slice& v1, const sivector_slice& v2) {
05554   return slsl_vv_mult<scvector_slice,sivector_slice,cinterval,sparse_cidot>(v1,v2);
05555 }
05556 
05558 inline scivector operator*(const scivector_slice& v, const real& s) {
05559   return sp_vs_mult<scivector_slice,real,scivector>(v,s);
05560 }
05561 
05563 inline scivector operator*(const scivector_slice& v, const complex& s) {
05564   return sp_vs_mult<scivector_slice,complex,scivector>(v,s);
05565 }
05566 
05568 inline scivector operator*(const scivector_slice& v, const interval& s) {
05569   return sp_vs_mult<scivector_slice,interval,scivector>(v,s);
05570 }
05571 
05573 inline scivector operator*(const scivector_slice& v, const cinterval& s) {
05574   return sp_vs_mult<scivector_slice,cinterval,scivector>(v,s);
05575 }
05576 
05578 inline scivector operator*(const srvector_slice& v, const cinterval& s) {
05579   return sp_vs_mult<srvector_slice,cinterval,scivector>(v,s);
05580 }
05581 
05583 inline scivector operator*(const scvector_slice& v, const cinterval& s) {
05584   return sp_vs_mult<scvector_slice,cinterval,scivector>(v,s);
05585 }
05586 
05588 inline scivector operator*(const sivector_slice& v, const cinterval& s) {
05589   return sp_vs_mult<sivector_slice,cinterval,scivector>(v,s);
05590 }
05591 
05593 inline scivector operator*(const scvector_slice& v, const interval& s) {
05594   return sp_vs_mult<scvector_slice,interval,scivector>(v,s);
05595 }
05596 
05598 inline scivector operator*(const sivector_slice& v, const complex& s) {
05599   return sp_vs_mult<sivector_slice,complex,scivector>(v,s);
05600 }
05601 
05603 inline scivector operator/(const scivector_slice& v, const real& s) {
05604   return sp_vs_div<scivector_slice,real,scivector>(v,s);
05605 }
05606 
05608 inline scivector operator/(const scivector_slice& v, const complex& s) {
05609   return sp_vs_div<scivector_slice,complex,scivector>(v,s);
05610 }
05611 
05613 inline scivector operator/(const scivector_slice& v, const interval& s) {
05614   return sp_vs_div<scivector_slice,interval,scivector>(v,s);
05615 }
05616 
05618 inline scivector operator/(const scivector_slice& v, const cinterval& s) {
05619   return sp_vs_div<scivector_slice,cinterval,scivector>(v,s);
05620 }
05621 
05623 inline scivector operator/(const srvector_slice& v, const cinterval& s) {
05624   return sp_vs_div<srvector_slice,cinterval,scivector>(v,s);
05625 }
05626 
05628 inline scivector operator/(const scvector_slice& v, const cinterval& s) {
05629   return sp_vs_div<scvector_slice,cinterval,scivector>(v,s);
05630 }
05631 
05633 inline scivector operator/(const sivector_slice& v, const cinterval& s) {
05634   return sp_vs_div<sivector_slice,cinterval,scivector>(v,s);
05635 }
05636 
05638 inline scivector operator/(const scvector_slice& v, const interval& s) {
05639   return sp_vs_div<scvector_slice,interval,scivector>(v,s);
05640 }
05641 
05643 inline scivector operator/(const sivector_slice& v, const complex& s) {
05644   return sp_vs_div<sivector_slice,complex,scivector>(v,s);
05645 }
05646 
05648 inline scivector operator*(const real& s, const scivector_slice& v) {
05649   return sp_sv_mult<real,scivector_slice,scivector>(s,v);
05650 }
05651 
05653 inline scivector operator*(const complex& s, const scivector_slice& v) {
05654   return sp_sv_mult<complex,scivector_slice,scivector>(s,v);
05655 }
05656 
05658 inline scivector operator*(const interval& s, const scivector_slice& v) {
05659   return sp_sv_mult<interval,scivector_slice,scivector>(s,v);
05660 }
05661 
05663 inline scivector operator*(const cinterval& s, const scivector_slice& v) {
05664   return sp_sv_mult<cinterval,scivector_slice,scivector>(s,v);
05665 }
05666 
05668 inline scivector operator*(const cinterval& s, const srvector_slice& v) {
05669   return sp_sv_mult<cinterval,srvector_slice,scivector>(s,v);
05670 }
05671 
05673 inline scivector operator*(const cinterval& s, const scvector_slice& v) {
05674   return sp_sv_mult<cinterval,scvector_slice,scivector>(s,v);
05675 }
05676 
05678 inline scivector operator*(const cinterval& s, const sivector_slice& v) {
05679   return sp_sv_mult<cinterval,sivector_slice,scivector>(s,v);
05680 }
05681 
05683 inline scivector operator*(const complex& s, const sivector_slice& v) {
05684   return sp_sv_mult<complex,sivector_slice,scivector>(s,v);
05685 }
05686 
05688 inline scivector operator*(const interval& s, const scvector_slice& v) {
05689   return sp_sv_mult<interval,scvector_slice,scivector>(s,v);
05690 }
05691 
05693 inline civector operator+(const civector& v1, const srvector_slice& v2) {
05694   return fsl_vv_add<civector,srvector_slice,civector>(v1,v2);
05695 }
05696 
05698 inline civector operator+(const civector& v1, const scvector_slice& v2) {
05699   return fsl_vv_add<civector,scvector_slice,civector>(v1,v2);
05700 }
05701 
05703 inline civector operator+(const civector& v1, const sivector_slice& v2) {
05704   return fsl_vv_add<civector,sivector_slice,civector>(v1,v2);
05705 }
05706 
05708 inline civector operator+(const civector& v1, const scivector_slice& v2) {
05709   return fsl_vv_add<civector,scivector_slice,civector>(v1,v2);
05710 }
05711 
05713 inline civector operator+(const rvector& v1, const scivector_slice& v2) {
05714   return fsl_vv_add<rvector,scivector_slice,civector>(v1,v2);
05715 }
05716 
05718 inline civector operator+(const cvector& v1, const scivector_slice& v2) {
05719   return fsl_vv_add<cvector,scivector_slice,civector>(v1,v2);
05720 }
05721 
05723 inline civector operator+(const ivector& v1, const scivector_slice& v2) {
05724   return fsl_vv_add<ivector,scivector_slice,civector>(v1,v2);
05725 }
05726 
05728 inline civector operator+(const cvector& v1, const sivector_slice& v2) {
05729   return fsl_vv_add<cvector,sivector_slice,civector>(v1,v2);
05730 }
05731 
05733 inline civector operator+(const ivector& v1, const scvector_slice& v2) {
05734   return fsl_vv_add<ivector,scvector_slice,civector>(v1,v2);
05735 }
05736 
05738 inline civector operator+(const scivector_slice& v1, const rvector& v2) {
05739   return slf_vv_add<scivector_slice,rvector,civector>(v1,v2);
05740 }
05741 
05743 inline civector operator+(const scivector_slice& v1, const cvector& v2) {
05744   return slf_vv_add<scivector_slice,cvector,civector>(v1,v2);
05745 }
05746 
05748 inline civector operator+(const scivector_slice& v1, const ivector& v2) {
05749   return slf_vv_add<scivector_slice,ivector,civector>(v1,v2);
05750 }
05751 
05753 inline civector operator+(const scivector_slice& v1, const civector& v2) {
05754   return slf_vv_add<scivector_slice,civector,civector>(v1,v2);
05755 }
05756 
05758 inline civector operator+(const srvector_slice& v1, const civector& v2) {
05759   return slf_vv_add<srvector_slice,civector,civector>(v1,v2);
05760 }
05761 
05763 inline civector operator+(const scvector_slice& v1, const civector& v2) {
05764   return slf_vv_add<scvector_slice,civector,civector>(v1,v2);
05765 }
05766 
05768 inline civector operator+(const sivector_slice& v1, const civector& v2) {
05769   return slf_vv_add<sivector_slice,civector,civector>(v1,v2);
05770 }
05771 
05773 inline civector operator+(const scvector_slice& v1, const ivector& v2) {
05774   return slf_vv_add<scvector_slice,ivector,civector>(v1,v2);
05775 }
05776 
05778 inline civector operator+(const sivector_slice& v1, const cvector& v2) {
05779   return slf_vv_add<sivector_slice,cvector,civector>(v1,v2);
05780 }
05781 
05783 inline civector operator+(const civector_slice& v1, const srvector_slice& v2) {
05784   return fsl_vv_add<civector_slice,srvector_slice,civector>(v1,v2);
05785 }
05786 
05788 inline civector operator+(const civector_slice& v1, const scvector_slice& v2) {
05789   return fsl_vv_add<civector_slice,scvector_slice,civector>(v1,v2);
05790 }
05791 
05793 inline civector operator+(const civector_slice& v1, const sivector_slice& v2) {
05794   return fsl_vv_add<civector_slice,sivector_slice,civector>(v1,v2);
05795 }
05796 
05798 inline civector operator+(const civector_slice& v1, const scivector_slice& v2) {
05799   return fsl_vv_add<civector_slice,scivector_slice,civector>(v1,v2);
05800 }
05801 
05803 inline civector operator+(const rvector_slice& v1, const scivector_slice& v2) {
05804   return fsl_vv_add<rvector_slice,scivector_slice,civector>(v1,v2);
05805 }
05806 
05808 inline civector operator+(const cvector_slice& v1, const scivector_slice& v2) {
05809   return fsl_vv_add<cvector_slice,scivector_slice,civector>(v1,v2);
05810 }
05811 
05813 inline civector operator+(const ivector_slice& v1, const scivector_slice& v2) {
05814   return fsl_vv_add<ivector_slice,scivector_slice,civector>(v1,v2);
05815 }
05816 
05818 inline civector operator+(const ivector_slice& v1, const scvector_slice& v2) {
05819   return fsl_vv_add<ivector_slice,scvector_slice,civector>(v1,v2);
05820 }
05821 
05823 inline civector operator+(const cvector_slice& v1, const sivector_slice& v2) {
05824   return fsl_vv_add<cvector_slice,sivector_slice,civector>(v1,v2);
05825 }
05826 
05828 inline civector operator+(const scivector_slice& v1, const rvector_slice& v2) {
05829   return slf_vv_add<scivector_slice,rvector_slice,civector>(v1,v2);
05830 }
05831 
05833 inline civector operator+(const scivector_slice& v1, const ivector_slice& v2) {
05834   return slf_vv_add<scivector_slice,ivector_slice,civector>(v1,v2);
05835 }
05836 
05838 inline civector operator+(const scivector_slice& v1, const cvector_slice& v2) {
05839   return slf_vv_add<scivector_slice,cvector_slice,civector>(v1,v2);
05840 }
05841 
05843 inline civector operator+(const scivector_slice& v1, const civector_slice& v2) {
05844   return slf_vv_add<scivector_slice,civector_slice,civector>(v1,v2);
05845 }
05846 
05848 inline civector operator+(const srvector_slice& v1, const civector_slice& v2) {
05849   return slf_vv_add<srvector_slice,civector_slice,civector>(v1,v2);
05850 }
05851 
05853 inline civector operator+(const sivector_slice& v1, const civector_slice& v2) {
05854   return slf_vv_add<sivector_slice,civector_slice,civector>(v1,v2);
05855 }
05856 
05858 inline civector operator+(const scvector_slice& v1, const civector_slice& v2) {
05859   return slf_vv_add<scvector_slice,civector_slice,civector>(v1,v2);
05860 }
05861 
05863 inline civector operator+(const scvector_slice& v1, const ivector_slice& v2) {
05864   return slf_vv_add<scvector_slice,ivector_slice,civector>(v1,v2);
05865 }
05866 
05868 inline civector operator+(const sivector_slice& v1, const cvector_slice& v2) {
05869   return slf_vv_add<sivector_slice,cvector_slice,civector>(v1,v2);
05870 }
05871 
05873 inline scivector operator+(const scivector_slice& v1, const srvector_slice& v2) {
05874   return slsl_vv_add<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
05875 }
05876 
05878 inline scivector operator+(const scivector_slice& v1, const scvector_slice& v2) {
05879   return slsl_vv_add<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
05880 }
05881 
05883 inline scivector operator+(const scivector_slice& v1, const sivector_slice& v2) {
05884   return slsl_vv_add<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
05885 }
05886 
05888 inline scivector operator+(const scivector_slice& v1, const scivector_slice& v2) {
05889   return slsl_vv_add<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
05890 }
05891 
05893 inline scivector operator+(const srvector_slice& v1, const scivector_slice& v2) {
05894   return slsl_vv_add<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
05895 }
05896 
05898 inline scivector operator+(const scvector_slice& v1, const scivector_slice& v2) {
05899   return slsl_vv_add<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
05900 }
05901 
05903 inline scivector operator+(const sivector_slice& v1, const scivector_slice& v2) {
05904   return slsl_vv_add<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
05905 }
05906 
05908 inline scivector operator+(const scvector_slice& v1, const sivector_slice& v2) {
05909   return slsl_vv_add<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
05910 }
05911 
05913 inline scivector operator+(const sivector_slice& v1, const scvector_slice& v2) {
05914   return slsl_vv_add<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
05915 }
05916 
05918 inline scivector operator+(const scivector& v1, const srvector_slice& v2) {
05919   return spsl_vv_add<scivector,srvector_slice,scivector,cinterval>(v1,v2);
05920 }
05921 
05923 inline scivector operator+(const scivector& v1, const scvector_slice& v2) {
05924   return spsl_vv_add<scivector,scvector_slice,scivector,cinterval>(v1,v2);
05925 }
05926 
05928 inline scivector operator+(const scivector& v1, const sivector_slice& v2) {
05929   return spsl_vv_add<scivector,sivector_slice,scivector,cinterval>(v1,v2);
05930 }
05931 
05933 inline scivector operator+(const scivector& v1, const scivector_slice& v2) {
05934   return spsl_vv_add<scivector,scivector_slice,scivector,cinterval>(v1,v2);
05935 }
05936 
05938 inline scivector operator+(const srvector& v1, const scivector_slice& v2) {
05939   return spsl_vv_add<srvector,scivector_slice,scivector,cinterval>(v1,v2);
05940 }
05941 
05943 inline scivector operator+(const scvector& v1, const scivector_slice& v2) {
05944   return spsl_vv_add<scvector,scivector_slice,scivector,cinterval>(v1,v2);
05945 }
05946 
05948 inline scivector operator+(const sivector& v1, const scivector_slice& v2) {
05949   return spsl_vv_add<sivector,scivector_slice,scivector,cinterval>(v1,v2);
05950 }
05951 
05953 inline scivector operator+(const scvector& v1, const sivector_slice& v2) {
05954   return spsl_vv_add<scvector,sivector_slice,scivector,cinterval>(v1,v2);
05955 }
05956 
05958 inline scivector operator+(const sivector& v1, const scvector_slice& v2) {
05959   return spsl_vv_add<sivector,scvector_slice,scivector,cinterval>(v1,v2);
05960 }
05961 
05963 inline scivector operator+(const scivector_slice& v1, const srvector& v2) {
05964   return slsp_vv_add<scivector_slice,srvector,scivector,cinterval>(v1,v2);
05965 }
05966 
05968 inline scivector operator+(const scivector_slice& v1, const scvector& v2) {
05969   return slsp_vv_add<scivector_slice,scvector,scivector,cinterval>(v1,v2);
05970 }
05971 
05973 inline scivector operator+(const scivector_slice& v1, const sivector& v2) {
05974   return slsp_vv_add<scivector_slice,sivector,scivector,cinterval>(v1,v2);
05975 }
05976 
05978 inline scivector operator+(const scivector_slice& v1, const scivector& v2) {
05979   return slsp_vv_add<scivector_slice,scivector,scivector,cinterval>(v1,v2);
05980 }
05981 
05983 inline scivector operator+(const srvector_slice& v1, const scivector& v2) {
05984   return slsp_vv_add<srvector_slice,scivector,scivector,cinterval>(v1,v2);
05985 }
05986 
05988 inline scivector operator+(const scvector_slice& v1, const scivector& v2) {
05989   return slsp_vv_add<scvector_slice,scivector,scivector,cinterval>(v1,v2);
05990 }
05991 
05993 inline scivector operator+(const sivector_slice& v1, const scivector& v2) {
05994   return slsp_vv_add<sivector_slice,scivector,scivector,cinterval>(v1,v2);
05995 }
05996 
05998 inline scivector operator+(const scvector_slice& v1, const sivector& v2) {
05999   return slsp_vv_add<scvector_slice,sivector,scivector,cinterval>(v1,v2);
06000 }
06001 
06003 inline scivector operator+(const sivector_slice& v1, const scvector& v2) {
06004   return slsp_vv_add<sivector_slice,scvector,scivector,cinterval>(v1,v2);
06005 }
06006 
06008 inline civector operator-(const civector& v1, const srvector_slice& v2) {
06009   return fsl_vv_sub<civector,srvector_slice,civector>(v1,v2);
06010 }
06011 
06013 inline civector operator-(const civector& v1, const scvector_slice& v2) {
06014   return fsl_vv_sub<civector,scvector_slice,civector>(v1,v2);
06015 }
06016 
06018 inline civector operator-(const civector& v1, const sivector_slice& v2) {
06019   return fsl_vv_sub<civector,sivector_slice,civector>(v1,v2);
06020 }
06021 
06023 inline civector operator-(const civector& v1, const scivector_slice& v2) {
06024   return fsl_vv_sub<civector,scivector_slice,civector>(v1,v2);
06025 }
06026 
06028 inline civector operator-(const rvector& v1, const scivector_slice& v2) {
06029   return fsl_vv_sub<rvector,scivector_slice,civector>(v1,v2);
06030 }
06031 
06033 inline civector operator-(const cvector& v1, const scivector_slice& v2) {
06034   return fsl_vv_sub<cvector,scivector_slice,civector>(v1,v2);
06035 }
06036 
06038 inline civector operator-(const ivector& v1, const scivector_slice& v2) {
06039   return fsl_vv_sub<ivector,scivector_slice,civector>(v1,v2);
06040 }
06041 
06043 inline civector operator-(const cvector& v1, const sivector_slice& v2) {
06044   return fsl_vv_sub<cvector,sivector_slice,civector>(v1,v2);
06045 }
06046 
06048 inline civector operator-(const ivector& v1, const scvector_slice& v2) {
06049   return fsl_vv_sub<ivector,scvector_slice,civector>(v1,v2);
06050 }
06051 
06053 inline civector operator-(const scivector_slice& v1, const rvector& v2) {
06054   return slf_vv_sub<scivector_slice,rvector,civector>(v1,v2);
06055 }
06056 
06058 inline civector operator-(const scivector_slice& v1, const cvector& v2) {
06059   return slf_vv_sub<scivector_slice,cvector,civector>(v1,v2);
06060 }
06061 
06063 inline civector operator-(const scivector_slice& v1, const ivector& v2) {
06064   return slf_vv_sub<scivector_slice,ivector,civector>(v1,v2);
06065 }
06066 
06068 inline civector operator-(const scivector_slice& v1, const civector& v2) {
06069   return slf_vv_sub<scivector_slice,civector,civector>(v1,v2);
06070 }
06071 
06073 inline civector operator-(const srvector_slice& v1, const civector& v2) {
06074   return slf_vv_sub<srvector_slice,civector,civector>(v1,v2);
06075 }
06076 
06078 inline civector operator-(const scvector_slice& v1, const civector& v2) {
06079   return slf_vv_sub<scvector_slice,civector,civector>(v1,v2);
06080 }
06081 
06083 inline civector operator-(const sivector_slice& v1, const civector& v2) {
06084   return slf_vv_sub<sivector_slice,civector,civector>(v1,v2);
06085 }
06086 
06088 inline civector operator-(const scvector_slice& v1, const ivector& v2) {
06089   return slf_vv_sub<scvector_slice,ivector,civector>(v1,v2);
06090 }
06091 
06093 inline civector operator-(const sivector_slice& v1, const cvector& v2) {
06094   return slf_vv_sub<sivector_slice,cvector,civector>(v1,v2);
06095 }
06096 
06098 inline civector operator-(const civector_slice& v1, const srvector_slice& v2) {
06099   return fsl_vv_sub<civector_slice,srvector_slice,civector>(v1,v2);
06100 }
06101 
06103 inline civector operator-(const civector_slice& v1, const scvector_slice& v2) {
06104   return fsl_vv_sub<civector_slice,scvector_slice,civector>(v1,v2);
06105 }
06106 
06108 inline civector operator-(const civector_slice& v1, const sivector_slice& v2) {
06109   return fsl_vv_sub<civector_slice,sivector_slice,civector>(v1,v2);
06110 }
06111 
06113 inline civector operator-(const civector_slice& v1, const scivector_slice& v2) {
06114   return fsl_vv_sub<civector_slice,scivector_slice,civector>(v1,v2);
06115 }
06116 
06118 inline civector operator-(const rvector_slice& v1, const scivector_slice& v2) {
06119   return fsl_vv_sub<rvector_slice,scivector_slice,civector>(v1,v2);
06120 }
06121 
06123 inline civector operator-(const cvector_slice& v1, const scivector_slice& v2) {
06124   return fsl_vv_sub<cvector_slice,scivector_slice,civector>(v1,v2);
06125 }
06126 
06128 inline civector operator-(const ivector_slice& v1, const scivector_slice& v2) {
06129   return fsl_vv_sub<ivector_slice,scivector_slice,civector>(v1,v2);
06130 }
06131 
06133 inline civector operator-(const ivector_slice& v1, const scvector_slice& v2) {
06134   return fsl_vv_sub<ivector_slice,scvector_slice,civector>(v1,v2);
06135 }
06136 
06138 inline civector operator-(const cvector_slice& v1, const sivector_slice& v2) {
06139   return fsl_vv_sub<cvector_slice,sivector_slice,civector>(v1,v2);
06140 }
06141 
06143 inline civector operator-(const scivector_slice& v1, const rvector_slice& v2) {
06144   return slf_vv_sub<scivector_slice,rvector_slice,civector>(v1,v2);
06145 }
06146 
06148 inline civector operator-(const scivector_slice& v1, const ivector_slice& v2) {
06149   return slf_vv_sub<scivector_slice,ivector_slice,civector>(v1,v2);
06150 }
06151 
06153 inline civector operator-(const scivector_slice& v1, const cvector_slice& v2) {
06154   return slf_vv_sub<scivector_slice,cvector_slice,civector>(v1,v2);
06155 }
06156 
06158 inline civector operator-(const scivector_slice& v1, const civector_slice& v2) {
06159   return slf_vv_sub<scivector_slice,civector_slice,civector>(v1,v2);
06160 }
06161 
06163 inline civector operator-(const srvector_slice& v1, const civector_slice& v2) {
06164   return slf_vv_sub<srvector_slice,civector_slice,civector>(v1,v2);
06165 }
06166 
06168 inline civector operator-(const sivector_slice& v1, const civector_slice& v2) {
06169   return slf_vv_sub<sivector_slice,civector_slice,civector>(v1,v2);
06170 }
06171 
06173 inline civector operator-(const scvector_slice& v1, const civector_slice& v2) {
06174   return slf_vv_sub<scvector_slice,civector_slice,civector>(v1,v2);
06175 }
06176 
06178 inline civector operator-(const scvector_slice& v1, const ivector_slice& v2) {
06179   return slf_vv_sub<scvector_slice,ivector_slice,civector>(v1,v2);
06180 }
06181 
06183 inline civector operator-(const sivector_slice& v1, const cvector_slice& v2) {
06184   return slf_vv_sub<sivector_slice,cvector_slice,civector>(v1,v2);
06185 }
06186 
06188 inline scivector operator-(const scivector_slice& v1, const srvector_slice& v2) {
06189   return slsl_vv_sub<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
06190 }
06191 
06193 inline scivector operator-(const scivector_slice& v1, const scvector_slice& v2) {
06194   return slsl_vv_sub<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
06195 }
06196 
06198 inline scivector operator-(const scivector_slice& v1, const sivector_slice& v2) {
06199   return slsl_vv_sub<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
06200 }
06201 
06203 inline scivector operator-(const scivector_slice& v1, const scivector_slice& v2) {
06204   return slsl_vv_sub<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06205 }
06206 
06208 inline scivector operator-(const srvector_slice& v1, const scivector_slice& v2) {
06209   return slsl_vv_sub<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06210 }
06211 
06213 inline scivector operator-(const scvector_slice& v1, const scivector_slice& v2) {
06214   return slsl_vv_sub<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06215 }
06216 
06218 inline scivector operator-(const sivector_slice& v1, const scivector_slice& v2) {
06219   return slsl_vv_sub<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06220 }
06221 
06223 inline scivector operator-(const scvector_slice& v1, const sivector_slice& v2) {
06224   return slsl_vv_sub<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
06225 }
06226 
06228 inline scivector operator-(const sivector_slice& v1, const scvector_slice& v2) {
06229   return slsl_vv_sub<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
06230 }
06231 
06233 inline scivector operator-(const scivector& v1, const srvector_slice& v2) {
06234   return spsl_vv_sub<scivector,srvector_slice,scivector,cinterval>(v1,v2);
06235 }
06236 
06238 inline scivector operator-(const scivector& v1, const scvector_slice& v2) {
06239   return spsl_vv_sub<scivector,scvector_slice,scivector,cinterval>(v1,v2);
06240 }
06241 
06243 inline scivector operator-(const scivector& v1, const sivector_slice& v2) {
06244   return spsl_vv_sub<scivector,sivector_slice,scivector,cinterval>(v1,v2);
06245 }
06246 
06248 inline scivector operator-(const scivector& v1, const scivector_slice& v2) {
06249   return spsl_vv_sub<scivector,scivector_slice,scivector,cinterval>(v1,v2);
06250 }
06251 
06253 inline scivector operator-(const srvector& v1, const scivector_slice& v2) {
06254   return spsl_vv_sub<srvector,scivector_slice,scivector,cinterval>(v1,v2);
06255 }
06256 
06258 inline scivector operator-(const scvector& v1, const scivector_slice& v2) {
06259   return spsl_vv_sub<scvector,scivector_slice,scivector,cinterval>(v1,v2);
06260 }
06261 
06263 inline scivector operator-(const sivector& v1, const scivector_slice& v2) {
06264   return spsl_vv_sub<sivector,scivector_slice,scivector,cinterval>(v1,v2);
06265 }
06266 
06268 inline scivector operator-(const scvector& v1, const sivector_slice& v2) {
06269   return spsl_vv_sub<scvector,sivector_slice,scivector,cinterval>(v1,v2);
06270 }
06271 
06273 inline scivector operator-(const sivector& v1, const scvector_slice& v2) {
06274   return spsl_vv_sub<sivector,scvector_slice,scivector,cinterval>(v1,v2);
06275 }
06276 
06278 inline scivector operator-(const scivector_slice& v1, const srvector& v2) {
06279   return slsp_vv_sub<scivector_slice,srvector,scivector,cinterval>(v1,v2);
06280 }
06281 
06283 inline scivector operator-(const scivector_slice& v1, const scvector& v2) {
06284   return slsp_vv_sub<scivector_slice,scvector,scivector,cinterval>(v1,v2);
06285 }
06286 
06288 inline scivector operator-(const scivector_slice& v1, const sivector& v2) {
06289   return slsp_vv_sub<scivector_slice,sivector,scivector,cinterval>(v1,v2);
06290 }
06291 
06293 inline scivector operator-(const scivector_slice& v1, const scivector& v2) {
06294   return slsp_vv_sub<scivector_slice,scivector,scivector,cinterval>(v1,v2);
06295 }
06296 
06298 inline scivector operator-(const srvector_slice& v1, const scivector& v2) {
06299   return slsp_vv_sub<srvector_slice,scivector,scivector,cinterval>(v1,v2);
06300 }
06301 
06303 inline scivector operator-(const scvector_slice& v1, const scivector& v2) {
06304   return slsp_vv_sub<scvector_slice,scivector,scivector,cinterval>(v1,v2);
06305 }
06306 
06308 inline scivector operator-(const sivector_slice& v1, const scivector& v2) {
06309   return slsp_vv_sub<sivector_slice,scivector,scivector,cinterval>(v1,v2);
06310 }
06311 
06313 inline scivector operator-(const scvector_slice& v1, const sivector& v2) {
06314   return slsp_vv_sub<scvector_slice,sivector,scivector,cinterval>(v1,v2);
06315 }
06316 
06318 inline scivector operator-(const sivector_slice& v1, const scvector& v2) {
06319   return slsp_vv_sub<sivector_slice,scvector,scivector,cinterval>(v1,v2);
06320 }
06321 
06323 inline civector operator|(const civector& v1, const srvector_slice& v2) {
06324   return fsl_vv_hull<civector,srvector_slice,civector>(v1,v2);
06325 }
06326 
06328 inline civector operator|(const civector& v1, const scvector_slice& v2) {
06329   return fsl_vv_hull<civector,scvector_slice,civector>(v1,v2);
06330 }
06331 
06333 inline civector operator|(const civector& v1, const sivector_slice& v2) {
06334   return fsl_vv_hull<civector,sivector_slice,civector>(v1,v2);
06335 }
06336 
06338 inline civector operator|(const civector& v1, const scivector_slice& v2) {
06339   return fsl_vv_hull<civector,scivector_slice,civector>(v1,v2);
06340 }
06341 
06343 inline civector operator|(const rvector& v1, const scivector_slice& v2) {
06344   return fsl_vv_hull<rvector,scivector_slice,civector>(v1,v2);
06345 }
06346 
06348 inline civector operator|(const cvector& v1, const scivector_slice& v2) {
06349   return fsl_vv_hull<cvector,scivector_slice,civector>(v1,v2);
06350 }
06351 
06353 inline civector operator|(const ivector& v1, const scivector_slice& v2) {
06354   return fsl_vv_hull<ivector,scivector_slice,civector>(v1,v2);
06355 }
06356 
06358 inline civector operator|(const cvector& v1, const sivector_slice& v2) {
06359   return fsl_vv_hull<cvector,sivector_slice,civector>(v1,v2);
06360 }
06361 
06363 inline civector operator|(const ivector& v1, const scvector_slice& v2) {
06364   return fsl_vv_hull<ivector,scvector_slice,civector>(v1,v2);
06365 }
06366 
06368 inline civector operator|(const scivector_slice& v1, const rvector& v2) {
06369   return slf_vv_hull<scivector_slice,rvector,civector>(v1,v2);
06370 }
06371 
06373 inline civector operator|(const scivector_slice& v1, const cvector& v2) {
06374   return slf_vv_hull<scivector_slice,cvector,civector>(v1,v2);
06375 }
06376 
06378 inline civector operator|(const scivector_slice& v1, const ivector& v2) {
06379   return slf_vv_hull<scivector_slice,ivector,civector>(v1,v2);
06380 }
06381 
06383 inline civector operator|(const scivector_slice& v1, const civector& v2) {
06384   return slf_vv_hull<scivector_slice,civector,civector>(v1,v2);
06385 }
06386 
06388 inline civector operator|(const srvector_slice& v1, const civector& v2) {
06389   return slf_vv_hull<srvector_slice,civector,civector>(v1,v2);
06390 }
06391 
06393 inline civector operator|(const scvector_slice& v1, const civector& v2) {
06394   return slf_vv_hull<scvector_slice,civector,civector>(v1,v2);
06395 }
06396 
06398 inline civector operator|(const sivector_slice& v1, const civector& v2) {
06399   return slf_vv_hull<sivector_slice,civector,civector>(v1,v2);
06400 }
06401 
06403 inline civector operator|(const scvector_slice& v1, const ivector& v2) {
06404   return slf_vv_hull<scvector_slice,ivector,civector>(v1,v2);
06405 }
06406 
06408 inline civector operator|(const sivector_slice& v1, const cvector& v2) {
06409   return slf_vv_hull<sivector_slice,cvector,civector>(v1,v2);
06410 }
06411 
06413 inline civector operator|(const civector_slice& v1, const srvector_slice& v2) {
06414   return fsl_vv_hull<civector_slice,srvector_slice,civector>(v1,v2);
06415 }
06416 
06418 inline civector operator|(const civector_slice& v1, const scvector_slice& v2) {
06419   return fsl_vv_hull<civector_slice,scvector_slice,civector>(v1,v2);
06420 }
06421 
06423 inline civector operator|(const civector_slice& v1, const sivector_slice& v2) {
06424   return fsl_vv_hull<civector_slice,sivector_slice,civector>(v1,v2);
06425 }
06426 
06428 inline civector operator|(const civector_slice& v1, const scivector_slice& v2) {
06429   return fsl_vv_hull<civector_slice,scivector_slice,civector>(v1,v2);
06430 }
06431 
06433 inline civector operator|(const rvector_slice& v1, const scivector_slice& v2) {
06434   return fsl_vv_hull<rvector_slice,scivector_slice,civector>(v1,v2);
06435 }
06436 
06438 inline civector operator|(const cvector_slice& v1, const scivector_slice& v2) {
06439   return fsl_vv_hull<cvector_slice,scivector_slice,civector>(v1,v2);
06440 }
06441 
06443 inline civector operator|(const ivector_slice& v1, const scivector_slice& v2) {
06444   return fsl_vv_hull<ivector_slice,scivector_slice,civector>(v1,v2);
06445 }
06446 
06448 inline civector operator|(const ivector_slice& v1, const scvector_slice& v2) {
06449   return fsl_vv_hull<ivector_slice,scvector_slice,civector>(v1,v2);
06450 }
06451 
06453 inline civector operator|(const cvector_slice& v1, const sivector_slice& v2) {
06454   return fsl_vv_hull<cvector_slice,sivector_slice,civector>(v1,v2);
06455 }
06456 
06458 inline civector operator|(const scivector_slice& v1, const rvector_slice& v2) {
06459   return slf_vv_hull<scivector_slice,rvector_slice,civector>(v1,v2);
06460 }
06461 
06463 inline civector operator|(const scivector_slice& v1, const ivector_slice& v2) {
06464   return slf_vv_hull<scivector_slice,ivector_slice,civector>(v1,v2);
06465 }
06466 
06468 inline civector operator|(const scivector_slice& v1, const cvector_slice& v2) {
06469   return slf_vv_hull<scivector_slice,cvector_slice,civector>(v1,v2);
06470 }
06471 
06473 inline civector operator|(const scivector_slice& v1, const civector_slice& v2) {
06474   return slf_vv_hull<scivector_slice,civector_slice,civector>(v1,v2);
06475 }
06476 
06478 inline civector operator|(const srvector_slice& v1, const civector_slice& v2) {
06479   return slf_vv_hull<srvector_slice,civector_slice,civector>(v1,v2);
06480 }
06481 
06483 inline civector operator|(const sivector_slice& v1, const civector_slice& v2) {
06484   return slf_vv_hull<sivector_slice,civector_slice,civector>(v1,v2);
06485 }
06486 
06488 inline civector operator|(const scvector_slice& v1, const civector_slice& v2) {
06489   return slf_vv_hull<scvector_slice,civector_slice,civector>(v1,v2);
06490 }
06491 
06493 inline civector operator|(const scvector_slice& v1, const ivector_slice& v2) {
06494   return slf_vv_hull<scvector_slice,ivector_slice,civector>(v1,v2);
06495 }
06496 
06498 inline civector operator|(const sivector_slice& v1, const cvector_slice& v2) {
06499   return slf_vv_hull<sivector_slice,cvector_slice,civector>(v1,v2);
06500 }
06501 
06503 inline scivector operator|(const scivector_slice& v1, const srvector_slice& v2) {
06504   return slsl_vv_hull<scivector_slice,srvector_slice,scivector,cinterval>(v1,v2);
06505 }
06506 
06508 inline scivector operator|(const scivector_slice& v1, const scvector_slice& v2) {
06509   return slsl_vv_hull<scivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
06510 }
06511 
06513 inline scivector operator|(const scivector_slice& v1, const sivector_slice& v2) {
06514   return slsl_vv_hull<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
06515 }
06516 
06518 inline scivector operator|(const scivector_slice& v1, const scivector_slice& v2) {
06519   return slsl_vv_hull<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06520 }
06521 
06523 inline scivector operator|(const srvector_slice& v1, const scivector_slice& v2) {
06524   return slsl_vv_hull<srvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06525 }
06526 
06528 inline scivector operator|(const scvector_slice& v1, const scivector_slice& v2) {
06529   return slsl_vv_hull<scvector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06530 }
06531 
06533 inline scivector operator|(const sivector_slice& v1, const scivector_slice& v2) {
06534   return slsl_vv_hull<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06535 }
06536 
06538 inline scivector operator|(const scvector_slice& v1, const sivector_slice& v2) {
06539   return slsl_vv_hull<scvector_slice,sivector_slice,scivector,cinterval>(v1,v2);
06540 }
06541 
06543 inline scivector operator|(const sivector_slice& v1, const scvector_slice& v2) {
06544   return slsl_vv_hull<sivector_slice,scvector_slice,scivector,cinterval>(v1,v2);
06545 }
06546 
06548 inline scivector operator|(const scivector& v1, const srvector_slice& v2) {
06549   return spsl_vv_hull<scivector,srvector_slice,scivector,cinterval>(v1,v2);
06550 }
06551 
06553 inline scivector operator|(const scivector& v1, const scvector_slice& v2) {
06554   return spsl_vv_hull<scivector,scvector_slice,scivector,cinterval>(v1,v2);
06555 }
06556 
06558 inline scivector operator|(const scivector& v1, const sivector_slice& v2) {
06559   return spsl_vv_hull<scivector,sivector_slice,scivector,cinterval>(v1,v2);
06560 }
06561 
06563 inline scivector operator|(const scivector& v1, const scivector_slice& v2) {
06564   return spsl_vv_hull<scivector,scivector_slice,scivector,cinterval>(v1,v2);
06565 }
06566 
06568 inline scivector operator|(const srvector& v1, const scivector_slice& v2) {
06569   return spsl_vv_hull<srvector,scivector_slice,scivector,cinterval>(v1,v2);
06570 }
06571 
06573 inline scivector operator|(const scvector& v1, const scivector_slice& v2) {
06574   return spsl_vv_hull<scvector,scivector_slice,scivector,cinterval>(v1,v2);
06575 }
06576 
06578 inline scivector operator|(const sivector& v1, const scivector_slice& v2) {
06579   return spsl_vv_hull<sivector,scivector_slice,scivector,cinterval>(v1,v2);
06580 }
06581 
06583 inline scivector operator|(const scvector& v1, const sivector_slice& v2) {
06584   return spsl_vv_hull<scvector,sivector_slice,scivector,cinterval>(v1,v2);
06585 }
06586 
06588 inline scivector operator|(const sivector& v1, const scvector_slice& v2) {
06589   return spsl_vv_hull<sivector,scvector_slice,scivector,cinterval>(v1,v2);
06590 }
06591 
06593 inline scivector operator|(const scivector_slice& v1, const srvector& v2) {
06594   return slsp_vv_hull<scivector_slice,srvector,scivector,cinterval>(v1,v2);
06595 }
06596 
06598 inline scivector operator|(const scivector_slice& v1, const scvector& v2) {
06599   return slsp_vv_hull<scivector_slice,scvector,scivector,cinterval>(v1,v2);
06600 }
06601 
06603 inline scivector operator|(const scivector_slice& v1, const sivector& v2) {
06604   return slsp_vv_hull<scivector_slice,sivector,scivector,cinterval>(v1,v2);
06605 }
06606 
06608 inline scivector operator|(const scivector_slice& v1, const scivector& v2) {
06609   return slsp_vv_hull<scivector_slice,scivector,scivector,cinterval>(v1,v2);
06610 }
06611 
06613 inline scivector operator|(const srvector_slice& v1, const scivector& v2) {
06614   return slsp_vv_hull<srvector_slice,scivector,scivector,cinterval>(v1,v2);
06615 }
06616 
06618 inline scivector operator|(const scvector_slice& v1, const scivector& v2) {
06619   return slsp_vv_hull<scvector_slice,scivector,scivector,cinterval>(v1,v2);
06620 }
06621 
06623 inline scivector operator|(const sivector_slice& v1, const scivector& v2) {
06624   return slsp_vv_hull<sivector_slice,scivector,scivector,cinterval>(v1,v2);
06625 }
06626 
06628 inline scivector operator|(const scvector_slice& v1, const sivector& v2) {
06629   return slsp_vv_hull<scvector_slice,sivector,scivector,cinterval>(v1,v2);
06630 }
06631 
06633 inline scivector operator|(const sivector_slice& v1, const scvector& v2) {
06634   return slsp_vv_hull<sivector_slice,scvector,scivector,cinterval>(v1,v2);
06635 }
06636 
06638 inline civector operator&(const civector& v1, const sivector_slice& v2) {
06639   return fsl_vv_intersect<civector,sivector_slice,civector>(v1,v2);
06640 }
06641 
06643 inline civector operator&(const civector& v1, const scivector_slice& v2) {
06644   return fsl_vv_intersect<civector,scivector_slice,civector>(v1,v2);
06645 }
06646 
06648 inline civector operator&(const ivector& v1, const scivector_slice& v2) {
06649   return fsl_vv_intersect<ivector,scivector_slice,civector>(v1,v2);
06650 }
06651 
06653 inline civector operator&(const scivector_slice& v1, const ivector& v2) {
06654   return slf_vv_intersect<scivector_slice,ivector,civector>(v1,v2);
06655 }
06656 
06658 inline civector operator&(const scivector_slice& v1, const civector& v2) {
06659   return slf_vv_intersect<scivector_slice,civector,civector>(v1,v2);
06660 }
06661 
06663 inline civector operator&(const sivector_slice& v1, const civector& v2) {
06664   return slf_vv_intersect<sivector_slice,civector,civector>(v1,v2);
06665 }
06666 
06668 inline civector operator&(const civector_slice& v1, const sivector_slice& v2) {
06669   return fsl_vv_intersect<civector_slice,sivector_slice,civector>(v1,v2);
06670 }
06671 
06673 inline civector operator&(const civector_slice& v1, const scivector_slice& v2) {
06674   return fsl_vv_intersect<civector_slice,scivector_slice,civector>(v1,v2);
06675 }
06676 
06678 inline civector operator&(const ivector_slice& v1, const scivector_slice& v2) {
06679   return fsl_vv_intersect<ivector_slice,scivector_slice,civector>(v1,v2);
06680 }
06681 
06683 inline civector operator&(const scivector_slice& v1, const ivector_slice& v2) {
06684   return slf_vv_intersect<scivector_slice,ivector_slice,civector>(v1,v2);
06685 }
06686 
06688 inline civector operator&(const scivector_slice& v1, const civector_slice& v2) {
06689   return slf_vv_intersect<scivector_slice,civector_slice,civector>(v1,v2);
06690 }
06691 
06693 inline civector operator&(const sivector_slice& v1, const civector_slice& v2) {
06694   return slf_vv_intersect<sivector_slice,civector_slice,civector>(v1,v2);
06695 }
06696 
06698 inline scivector operator&(const scivector_slice& v1, const sivector_slice& v2) {
06699   return slsl_vv_intersect<scivector_slice,sivector_slice,scivector,cinterval>(v1,v2);
06700 }
06701 
06703 inline scivector operator&(const scivector_slice& v1, const scivector_slice& v2) {
06704   return slsl_vv_intersect<scivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06705 }
06706 
06708 inline scivector operator&(const sivector_slice& v1, const scivector_slice& v2) {
06709   return slsl_vv_intersect<sivector_slice,scivector_slice,scivector,cinterval>(v1,v2);
06710 }
06711 
06713 inline scivector operator&(const scivector& v1, const sivector_slice& v2) {
06714   return spsl_vv_intersect<scivector,sivector_slice,scivector,cinterval>(v1,v2);
06715 }
06716 
06718 inline scivector operator&(const scivector& v1, const scivector_slice& v2) {
06719   return spsl_vv_intersect<scivector,scivector_slice,scivector,cinterval>(v1,v2);
06720 }
06721 
06723 inline scivector operator&(const sivector& v1, const scivector_slice& v2) {
06724   return spsl_vv_intersect<sivector,scivector_slice,scivector,cinterval>(v1,v2);
06725 }
06726 
06728 inline scivector operator&(const scivector_slice& v1, const sivector& v2) {
06729   return slsp_vv_intersect<scivector_slice,sivector,scivector,cinterval>(v1,v2);
06730 }
06731 
06733 inline scivector operator&(const scivector_slice& v1, const scivector& v2) {
06734   return slsp_vv_intersect<scivector_slice,scivector,scivector,cinterval>(v1,v2);
06735 }
06736 
06738 inline scivector operator&(const sivector_slice& v1, const scivector& v2) {
06739   return slsp_vv_intersect<sivector_slice,scivector,scivector,cinterval>(v1,v2);
06740 }
06741 
06742 inline civector& civector::operator+=(const srvector_slice& v2) {
06743   return fsl_vv_addassign(*this,v2);
06744 }
06745 
06746 inline civector& civector::operator+=(const scvector_slice& v2) {
06747   return fsl_vv_addassign(*this,v2);
06748 }
06749 
06750 inline civector& civector::operator+=(const sivector_slice& v2) {
06751   return fsl_vv_addassign(*this,v2);
06752 }
06753 
06754 inline civector& civector::operator+=(const scivector_slice& v2) {
06755   return fsl_vv_addassign(*this,v2);
06756 }
06757 
06758 inline civector_slice& civector_slice::operator+=(const srvector_slice& v2) {
06759   return fsl_vv_addassign(*this,v2);
06760 }
06761 
06762 inline civector_slice& civector_slice::operator+=(const scvector_slice& v2) {
06763   return fsl_vv_addassign(*this,v2);
06764 }
06765 
06766 inline civector_slice& civector_slice::operator+=(const sivector_slice& v2) {
06767   return fsl_vv_addassign(*this,v2);
06768 }
06769 
06770 inline civector_slice& civector_slice::operator+=(const scivector_slice& v2) {
06771   return fsl_vv_addassign(*this,v2);
06772 }
06773 
06774 inline scivector& scivector::operator+=(const srvector_slice& v2) {
06775   return spsl_vv_addassign(*this,v2);
06776 }
06777 
06778 inline scivector& scivector::operator+=(const scvector_slice& v2) {
06779   return spsl_vv_addassign(*this,v2);
06780 }
06781 
06782 inline scivector& scivector::operator+=(const sivector_slice& v2) {
06783   return spsl_vv_addassign(*this,v2);
06784 }
06785 
06786 inline scivector& scivector::operator+=(const scivector_slice& v2) {
06787   return spsl_vv_addassign(*this,v2);
06788 }
06789 
06790 inline civector& civector::operator-=(const srvector_slice& v2) {
06791   return fsl_vv_subassign(*this,v2);
06792 }
06793 
06794 inline civector& civector::operator-=(const scvector_slice& v2) {
06795   return fsl_vv_subassign(*this,v2);
06796 }
06797 
06798 inline civector& civector::operator-=(const sivector_slice& v2) {
06799   return fsl_vv_subassign(*this,v2);
06800 }
06801 
06802 inline civector& civector::operator-=(const scivector_slice& v2) {
06803   return fsl_vv_subassign(*this,v2);
06804 }
06805 
06806 inline civector_slice& civector_slice::operator-=(const srvector_slice& v2) {
06807   return fsl_vv_subassign(*this,v2);
06808 }
06809 
06810 inline civector_slice& civector_slice::operator-=(const scvector_slice& v2) {
06811   return fsl_vv_subassign(*this,v2);
06812 }
06813 
06814 inline civector_slice& civector_slice::operator-=(const sivector_slice& v2) {
06815   return fsl_vv_subassign(*this,v2);
06816 }
06817 
06818 inline civector_slice& civector_slice::operator-=(const scivector_slice& v2) {
06819   return fsl_vv_subassign(*this,v2);
06820 }
06821 
06822 inline scivector& scivector::operator-=(const srvector_slice& v2) {
06823   return spsl_vv_subassign(*this,v2);
06824 }
06825 
06826 inline scivector& scivector::operator-=(const scvector_slice& v2) {
06827   return spsl_vv_subassign(*this,v2);
06828 }
06829 
06830 inline scivector& scivector::operator-=(const sivector_slice& v2) {
06831   return spsl_vv_subassign(*this,v2);
06832 }
06833 
06834 inline scivector& scivector::operator-=(const scivector_slice& v2) {
06835   return spsl_vv_subassign(*this,v2);
06836 }
06837 
06838 inline civector& civector::operator|=(const srvector_slice& v2) {
06839   return fsl_vv_hullassign(*this,v2);
06840 }
06841 
06842 inline civector& civector::operator|=(const scvector_slice& v2) {
06843   return fsl_vv_hullassign(*this,v2);
06844 }
06845 
06846 inline civector& civector::operator|=(const sivector_slice& v2) {
06847   return fsl_vv_hullassign(*this,v2);
06848 }
06849 
06850 inline civector& civector::operator|=(const scivector_slice& v2) {
06851   return fsl_vv_hullassign(*this,v2);
06852 }
06853 
06854 inline civector_slice& civector_slice::operator|=(const srvector_slice& v2) {
06855   return fsl_vv_hullassign(*this,v2);
06856 }
06857 
06858 inline civector_slice& civector_slice::operator|=(const scvector_slice& v2) {
06859   return fsl_vv_hullassign(*this,v2);
06860 }
06861 
06862 inline civector_slice& civector_slice::operator|=(const sivector_slice& v2) {
06863   return fsl_vv_hullassign(*this,v2);
06864 }
06865 
06866 inline civector_slice& civector_slice::operator|=(const scivector_slice& v2) {
06867   return fsl_vv_hullassign(*this,v2);
06868 }
06869 
06870 inline scivector& scivector::operator|=(const srvector_slice& v2) {
06871   return spsl_vv_hullassign(*this,v2);
06872 }
06873 
06874 inline scivector& scivector::operator|=(const scvector_slice& v2) {
06875   return spsl_vv_hullassign(*this,v2);
06876 }
06877 
06878 inline scivector& scivector::operator|=(const sivector_slice& v2) {
06879   return spsl_vv_hullassign(*this,v2);
06880 }
06881 
06882 inline scivector& scivector::operator|=(const scivector_slice& v2) {
06883   return spsl_vv_hullassign(*this,v2);
06884 }
06885 
06886 inline civector& civector::operator&=(const sivector_slice& v2) {
06887   return fsl_vv_intersectassign(*this,v2);
06888 }
06889 
06890 inline civector& civector::operator&=(const scivector_slice& v2) {
06891   return fsl_vv_intersectassign(*this,v2);
06892 }
06893 
06894 inline civector_slice& civector_slice::operator&=(const sivector_slice& v2) {
06895   return fsl_vv_intersectassign(*this,v2);
06896 }
06897 
06898 inline civector_slice& civector_slice::operator&=(const scivector_slice& v2) {
06899   return fsl_vv_intersectassign(*this,v2);
06900 }
06901 
06902 inline scivector& scivector::operator&=(const sivector_slice& v2) {
06903   return spsl_vv_intersectassign(*this,v2);
06904 }
06905 
06906 inline scivector& scivector::operator&=(const scivector_slice& v2) {
06907   return spsl_vv_intersectassign(*this,v2);
06908 }
06909 
06911 
06914 inline bool operator==(const scivector_slice& v1, const srvector_slice& v2) {
06915   return slsl_vv_comp(v1,v2);
06916 }
06917 
06919 
06922 inline bool operator==(const scivector_slice& v1, const scvector_slice& v2) {
06923   return slsl_vv_comp(v1,v2);
06924 }
06925 
06927 
06930 inline bool operator==(const scivector_slice& v1, const sivector_slice& v2) {
06931   return slsl_vv_comp(v1,v2);
06932 }
06933 
06935 
06938 inline bool operator==(const scivector_slice& v1, const scivector_slice& v2) {
06939   return slsl_vv_comp(v1,v2);
06940 }
06941 
06943 
06946 inline bool operator==(const srvector_slice& v1, const scivector_slice& v2) {
06947   return slsl_vv_comp(v1,v2);
06948 }
06949 
06951 
06954 inline bool operator==(const scvector_slice& v1, const scivector_slice& v2) {
06955   return slsl_vv_comp(v1,v2);
06956 }
06957 
06959 
06962 inline bool operator==(const sivector_slice& v1, const scivector_slice& v2) {
06963   return slsl_vv_comp(v1,v2);
06964 }
06965 
06967 
06970 inline bool operator==(const scivector_slice& v1, const srvector& v2) {
06971   return slsp_vv_comp(v1,v2);
06972 }
06973 
06975 
06978 inline bool operator==(const scivector_slice& v1, const scvector& v2) {
06979   return slsp_vv_comp(v1,v2);
06980 }
06981 
06983 
06986 inline bool operator==(const scivector_slice& v1, const sivector& v2) {
06987   return slsp_vv_comp(v1,v2);
06988 }
06989 
06991 
06994 inline bool operator==(const scivector_slice& v1, const scivector& v2) {
06995   return slsp_vv_comp(v1,v2);
06996 }
06997 
06999 
07002 inline bool operator==(const srvector_slice& v1, const scivector& v2) {
07003   return slsp_vv_comp(v1,v2);
07004 }
07005 
07007 
07010 inline bool operator==(const scvector_slice& v1, const scivector& v2) {
07011   return slsp_vv_comp(v1,v2);
07012 }
07013 
07015 
07018 inline bool operator==(const sivector_slice& v1, const scivector& v2) {
07019   return slsp_vv_comp(v1,v2);
07020 }
07021 
07023 
07026 inline bool operator==(const scivector& v1, const srvector_slice& v2) {
07027   return spsl_vv_comp(v1,v2);
07028 }
07029 
07031 
07034 inline bool operator==(const scivector& v1, const scvector_slice& v2) {
07035   return spsl_vv_comp(v1,v2);
07036 }
07037 
07039 
07042 inline bool operator==(const scivector& v1, const sivector_slice& v2) {
07043   return spsl_vv_comp(v1,v2);
07044 }
07045 
07047 
07050 inline bool operator==(const scivector& v1, const scivector_slice& v2) {
07051   return spsl_vv_comp(v1,v2);
07052 }
07053 
07055 
07058 inline bool operator==(const srvector& v1, const scivector_slice& v2) {
07059   return spsl_vv_comp(v1,v2);
07060 }
07061 
07063 
07066 inline bool operator==(const scvector& v1, const scivector_slice& v2) {
07067   return spsl_vv_comp(v1,v2);
07068 }
07069 
07071 
07074 inline bool operator==(const sivector& v1, const scivector_slice& v2) {
07075   return spsl_vv_comp(v1,v2);
07076 }
07077 
07079 
07082 inline bool operator==(const scivector_slice& v1, const rvector& v2) {
07083   return slf_vv_comp(v1,v2);
07084 }
07085 
07087 
07090 inline bool operator==(const scivector_slice& v1, const cvector& v2) {
07091   return slf_vv_comp(v1,v2);
07092 }
07093 
07095 
07098 inline bool operator==(const scivector_slice& v1, const ivector& v2) {
07099   return slf_vv_comp(v1,v2);
07100 }
07101 
07103 
07106 inline bool operator==(const scivector_slice& v1, const civector& v2) {
07107   return slf_vv_comp(v1,v2);
07108 }
07109 
07111 
07114 inline bool operator==(const srvector_slice& v1, const civector& v2) {
07115   return slf_vv_comp(v1,v2);
07116 }
07117 
07119 
07122 inline bool operator==(const sivector_slice& v1, const civector& v2) {
07123   return slf_vv_comp(v1,v2);
07124 }
07125 
07127 
07130 inline bool operator==(const scvector_slice& v1, const civector& v2) {
07131   return slf_vv_comp(v1,v2);
07132 }
07133 
07135 
07138 inline bool operator==(const civector& v1, const srvector_slice& v2) {
07139   return fsl_vv_comp(v1,v2);
07140 }
07141 
07143 
07146 inline bool operator==(const civector& v1, const scvector_slice& v2) {
07147   return fsl_vv_comp(v1,v2);
07148 }
07149 
07151 
07154 inline bool operator==(const civector& v1, const sivector_slice& v2) {
07155   return fsl_vv_comp(v1,v2);
07156 }
07157 
07159 
07162 inline bool operator==(const civector& v1, const scivector_slice& v2) {
07163   return fsl_vv_comp(v1,v2);
07164 }
07165 
07167 
07170 inline bool operator==(const rvector& v1, const scivector_slice& v2) {
07171   return fsl_vv_comp(v1,v2);
07172 }
07173 
07175 
07178 inline bool operator==(const cvector& v1, const scivector_slice& v2) {
07179   return fsl_vv_comp(v1,v2);
07180 }
07181 
07183 
07186 inline bool operator==(const ivector& v1, const scivector_slice& v2) {
07187   return fsl_vv_comp(v1,v2);
07188 }
07189 
07191 
07194 inline bool operator==(const scivector_slice& v1, const rvector_slice& v2) {
07195   return slf_vv_comp(v1,v2);
07196 }
07197 
07199 
07202 inline bool operator==(const scivector_slice& v1, const ivector_slice& v2) {
07203   return slf_vv_comp(v1,v2);
07204 }
07205 
07207 
07210 inline bool operator==(const scivector_slice& v1, const cvector_slice& v2) {
07211   return slf_vv_comp(v1,v2);
07212 }
07213 
07215 
07218 inline bool operator==(const scivector_slice& v1, const civector_slice& v2) {
07219   return slf_vv_comp(v1,v2);
07220 }
07221 
07223 
07226 inline bool operator==(const srvector_slice& v1, const civector_slice& v2) {
07227   return slf_vv_comp(v1,v2);
07228 }
07229 
07231 
07234 inline bool operator==(const sivector_slice& v1, const civector_slice& v2) {
07235   return slf_vv_comp(v1,v2);
07236 }
07237 
07239 
07242 inline bool operator==(const scvector_slice& v1, const civector_slice& v2) {
07243   return slf_vv_comp(v1,v2);
07244 }
07245 
07247 
07250 inline bool operator==(const civector_slice& v1, const srvector_slice& v2) {
07251   return fsl_vv_comp(v1,v2);
07252 }
07253 
07255 
07258 inline bool operator==(const civector_slice& v1, const scvector_slice& v2) {
07259   return fsl_vv_comp(v1,v2);
07260 }
07261 
07263 
07266 inline bool operator==(const civector_slice& v1, const sivector_slice& v2) {
07267   return fsl_vv_comp(v1,v2);
07268 }
07269 
07271 
07274 inline bool operator==(const civector_slice& v1, const scivector_slice& v2) {
07275   return fsl_vv_comp(v1,v2);
07276 }
07277 
07279 
07282 inline bool operator==(const rvector_slice& v1, const scivector_slice& v2) {
07283   return fsl_vv_comp(v1,v2);
07284 }
07285 
07287 
07290 inline bool operator==(const cvector_slice& v1, const scivector_slice& v2) {
07291   return fsl_vv_comp(v1,v2);
07292 }
07293 
07295 
07298 inline bool operator==(const ivector_slice& v1, const scivector_slice& v2) {
07299   return fsl_vv_comp(v1,v2);
07300 }
07301 
07303 
07306 inline bool operator!=(const scivector_slice& v1, const srvector_slice& v2) {
07307   return !slsl_vv_comp(v1,v2);
07308 }
07309 
07311 
07314 inline bool operator!=(const scivector_slice& v1, const scvector_slice& v2) {
07315   return !slsl_vv_comp(v1,v2);
07316 }
07317 
07319 
07322 inline bool operator!=(const scivector_slice& v1, const sivector_slice& v2) {
07323   return !slsl_vv_comp(v1,v2);
07324 }
07325 
07327 
07330 inline bool operator!=(const scivector_slice& v1, const scivector_slice& v2) {
07331   return !slsl_vv_comp(v1,v2);
07332 }
07333 
07335 
07338 inline bool operator!=(const srvector_slice& v1, const scivector_slice& v2) {
07339   return !slsl_vv_comp(v1,v2);
07340 }
07341 
07343 
07346 inline bool operator!=(const scvector_slice& v1, const scivector_slice& v2) {
07347   return !slsl_vv_comp(v1,v2);
07348 }
07349 
07351 
07354 inline bool operator!=(const sivector_slice& v1, const scivector_slice& v2) {
07355   return !slsl_vv_comp(v1,v2);
07356 }
07357 
07359 
07362 inline bool operator!=(const scivector_slice& v1, const srvector& v2) {
07363   return !slsp_vv_comp(v1,v2);
07364 }
07365 
07367 
07370 inline bool operator!=(const scivector_slice& v1, const scvector& v2) {
07371   return !slsp_vv_comp(v1,v2);
07372 }
07373 
07375 
07378 inline bool operator!=(const scivector_slice& v1, const sivector& v2) {
07379   return !slsp_vv_comp(v1,v2);
07380 }
07381 
07383 
07386 inline bool operator!=(const scivector_slice& v1, const scivector& v2) {
07387   return !slsp_vv_comp(v1,v2);
07388 }
07389 
07391 
07394 inline bool operator!=(const srvector_slice& v1, const scivector& v2) {
07395   return !slsp_vv_comp(v1,v2);
07396 }
07397 
07399 
07402 inline bool operator!=(const scvector_slice& v1, const scivector& v2) {
07403   return !slsp_vv_comp(v1,v2);
07404 }
07405 
07407 
07410 inline bool operator!=(const sivector_slice& v1, const scivector& v2) {
07411   return !slsp_vv_comp(v1,v2);
07412 }
07413 
07415 
07418 inline bool operator!=(const scivector& v1, const srvector_slice& v2) {
07419   return !spsl_vv_comp(v1,v2);
07420 }
07421 
07423 
07426 inline bool operator!=(const scivector& v1, const scvector_slice& v2) {
07427   return !spsl_vv_comp(v1,v2);
07428 }
07429 
07431 
07434 inline bool operator!=(const scivector& v1, const sivector_slice& v2) {
07435   return !spsl_vv_comp(v1,v2);
07436 }
07437 
07439 
07442 inline bool operator!=(const scivector& v1, const scivector_slice& v2) {
07443   return !spsl_vv_comp(v1,v2);
07444 }
07445 
07447 
07450 inline bool operator!=(const srvector& v1, const scivector_slice& v2) {
07451   return !spsl_vv_comp(v1,v2);
07452 }
07453 
07455 
07458 inline bool operator!=(const scvector& v1, const scivector_slice& v2) {
07459   return !spsl_vv_comp(v1,v2);
07460 }
07461 
07463 
07466 inline bool operator!=(const sivector& v1, const scivector_slice& v2) {
07467   return !spsl_vv_comp(v1,v2);
07468 }
07469 
07471 
07474 inline bool operator!=(const scivector_slice& v1, const rvector& v2) {
07475   return !slf_vv_comp(v1,v2);
07476 }
07477 
07479 
07482 inline bool operator!=(const scivector_slice& v1, const cvector& v2) {
07483   return !slf_vv_comp(v1,v2);
07484 }
07485 
07487 
07490 inline bool operator!=(const scivector_slice& v1, const ivector& v2) {
07491   return !slf_vv_comp(v1,v2);
07492 }
07493 
07495 
07498 inline bool operator!=(const scivector_slice& v1, const civector& v2) {
07499   return !slf_vv_comp(v1,v2);
07500 }
07501 
07503 
07506 inline bool operator!=(const srvector_slice& v1, const civector& v2) {
07507   return !slf_vv_comp(v1,v2);
07508 }
07509 
07511 
07514 inline bool operator!=(const sivector_slice& v1, const civector& v2) {
07515   return !slf_vv_comp(v1,v2);
07516 }
07517 
07519 
07522 inline bool operator!=(const scvector_slice& v1, const civector& v2) {
07523   return !slf_vv_comp(v1,v2);
07524 }
07525 
07527 
07530 inline bool operator!=(const civector& v1, const srvector_slice& v2) {
07531   return !fsl_vv_comp(v1,v2);
07532 }
07533 
07535 
07538 inline bool operator!=(const civector& v1, const scvector_slice& v2) {
07539   return !fsl_vv_comp(v1,v2);
07540 }
07541 
07543 
07546 inline bool operator!=(const civector& v1, const sivector_slice& v2) {
07547   return !fsl_vv_comp(v1,v2);
07548 }
07549 
07551 
07554 inline bool operator!=(const civector& v1, const scivector_slice& v2) {
07555   return !fsl_vv_comp(v1,v2);
07556 }
07557 
07559 
07562 inline bool operator!=(const rvector& v1, const scivector_slice& v2) {
07563   return !fsl_vv_comp(v1,v2);
07564 }
07565 
07567 
07570 inline bool operator!=(const cvector& v1, const scivector_slice& v2) {
07571   return !fsl_vv_comp(v1,v2);
07572 }
07573 
07575 
07578 inline bool operator!=(const ivector& v1, const scivector_slice& v2) {
07579   return !fsl_vv_comp(v1,v2);
07580 }
07581 
07583 
07586 inline bool operator!=(const scivector_slice& v1, const rvector_slice& v2) {
07587   return !slf_vv_comp(v1,v2);
07588 }
07589 
07591 
07594 inline bool operator!=(const scivector_slice& v1, const ivector_slice& v2) {
07595   return !slf_vv_comp(v1,v2);
07596 }
07597 
07599 
07602 inline bool operator!=(const scivector_slice& v1, const cvector_slice& v2) {
07603   return !slf_vv_comp(v1,v2);
07604 }
07605 
07607 
07610 inline bool operator!=(const scivector_slice& v1, const civector_slice& v2) {
07611   return !slf_vv_comp(v1,v2);
07612 }
07613 
07615 
07618 inline bool operator!=(const srvector_slice& v1, const civector_slice& v2) {
07619   return !slf_vv_comp(v1,v2);
07620 }
07621 
07623 
07626 inline bool operator!=(const sivector_slice& v1, const civector_slice& v2) {
07627   return !slf_vv_comp(v1,v2);
07628 }
07629 
07631 
07634 inline bool operator!=(const scvector_slice& v1, const civector_slice& v2) {
07635   return !slf_vv_comp(v1,v2);
07636 }
07637 
07639 
07642 inline bool operator!=(const civector_slice& v1, const srvector_slice& v2) {
07643   return !fsl_vv_comp(v1,v2);
07644 }
07645 
07647 
07650 inline bool operator!=(const civector_slice& v1, const scvector_slice& v2) {
07651   return !fsl_vv_comp(v1,v2);
07652 }
07653 
07655 
07658 inline bool operator!=(const civector_slice& v1, const sivector_slice& v2) {
07659   return !fsl_vv_comp(v1,v2);
07660 }
07661 
07663 
07666 inline bool operator!=(const civector_slice& v1, const scivector_slice& v2) {
07667   return !fsl_vv_comp(v1,v2);
07668 }
07669 
07671 
07674 inline bool operator!=(const rvector_slice& v1, const scivector_slice& v2) {
07675   return !fsl_vv_comp(v1,v2);
07676 }
07677 
07679 
07682 inline bool operator!=(const cvector_slice& v1, const scivector_slice& v2) {
07683   return !fsl_vv_comp(v1,v2);
07684 }
07685 
07687 
07690 inline bool operator!=(const ivector_slice& v1, const scivector_slice& v2) {
07691   return !fsl_vv_comp(v1,v2);
07692 }
07693 
07695 
07698 inline bool operator<(const scivector_slice& v1, const sivector_slice& v2) {
07699   return slsl_vv_less<scivector_slice,sivector_slice,cinterval>(v1,v2);
07700 }
07701 
07703 
07706 inline bool operator<(const scivector_slice& v1, const scivector_slice& v2) {
07707   return slsl_vv_less<scivector_slice,scivector_slice,cinterval>(v1,v2);
07708 }
07709 
07711 
07714 inline bool operator<(const srvector_slice& v1, const scivector_slice& v2) {
07715   return slsl_vv_less<srvector_slice,scivector_slice,cinterval>(v1,v2);
07716 }
07717 
07719 
07722 inline bool operator<(const scvector_slice& v1, const scivector_slice& v2) {
07723   return slsl_vv_less<scvector_slice,scivector_slice,cinterval>(v1,v2);
07724 }
07725 
07727 
07730 inline bool operator<(const sivector_slice& v1, const scivector_slice& v2) {
07731   return slsl_vv_less<sivector_slice,scivector_slice,cinterval>(v1,v2);
07732 }
07733 
07735 
07738 inline bool operator<(const scivector_slice& v1, const sivector& v2) {
07739   return slsp_vv_less<scivector_slice,sivector,cinterval>(v1,v2);
07740 }
07741 
07743 
07746 inline bool operator<(const scivector_slice& v1, const scivector& v2) {
07747   return slsp_vv_less<scivector_slice,scivector,cinterval>(v1,v2);
07748 }
07749 
07751 
07754 inline bool operator<(const srvector_slice& v1, const scivector& v2) {
07755   return slsp_vv_less<srvector_slice,scivector,cinterval>(v1,v2);
07756 }
07757 
07759 
07762 inline bool operator<(const scvector_slice& v1, const scivector& v2) {
07763   return slsp_vv_less<scvector_slice,scivector,cinterval>(v1,v2);
07764 }
07765 
07767 
07770 inline bool operator<(const sivector_slice& v1, const scivector& v2) {
07771   return slsp_vv_less<sivector_slice,scivector,cinterval>(v1,v2);
07772 }
07773 
07775 
07778 inline bool operator<(const scivector& v1, const sivector_slice& v2) {
07779   return spsl_vv_less<scivector,sivector_slice,cinterval>(v1,v2);
07780 }
07781 
07783 
07786 inline bool operator<(const scivector& v1, const scivector_slice& v2) {
07787   return spsl_vv_less<scivector,scivector_slice,cinterval>(v1,v2);
07788 }
07789 
07791 
07794 inline bool operator<(const srvector& v1, const scivector_slice& v2) {
07795   return spsl_vv_less<srvector,scivector_slice,cinterval>(v1,v2);
07796 }
07797 
07799 
07802 inline bool operator<(const scvector& v1, const scivector_slice& v2) {
07803   return spsl_vv_less<scvector,scivector_slice,cinterval>(v1,v2);
07804 }
07805 
07807 
07810 inline bool operator<(const sivector& v1, const scivector_slice& v2) {
07811   return spsl_vv_less<sivector,scivector_slice,cinterval>(v1,v2);
07812 }
07813 
07815 
07818 inline bool operator<(const scivector_slice& v1, const ivector& v2) {
07819   return slf_vv_less<scivector_slice,ivector,cinterval>(v1,v2);
07820 }
07821 
07823 
07826 inline bool operator<(const scivector_slice& v1, const civector& v2) {
07827   return slf_vv_less<scivector_slice,civector,cinterval>(v1,v2);
07828 }
07829 
07831 
07834 inline bool operator<(const srvector_slice& v1, const civector& v2) {
07835   return slf_vv_less<srvector_slice,civector,cinterval>(v1,v2);
07836 }
07837 
07839 
07842 inline bool operator<(const sivector_slice& v1, const civector& v2) {
07843   return slf_vv_less<sivector_slice,civector,cinterval>(v1,v2);
07844 }
07845 
07847 
07850 inline bool operator<(const scvector_slice& v1, const civector& v2) {
07851   return slf_vv_less<scvector_slice,civector,cinterval>(v1,v2);
07852 }
07853 
07855 
07858 inline bool operator<(const civector& v1, const sivector_slice& v2) {
07859   return fsl_vv_less<civector,sivector_slice,cinterval>(v1,v2);
07860 }
07861 
07863 
07866 inline bool operator<(const civector& v1, const scivector_slice& v2) {
07867   return fsl_vv_less<civector,scivector_slice,cinterval>(v1,v2);
07868 }
07869 
07871 
07874 inline bool operator<(const rvector& v1, const scivector_slice& v2) {
07875   return fsl_vv_less<rvector,scivector_slice,cinterval>(v1,v2);
07876 }
07877 
07879 
07882 inline bool operator<(const cvector& v1, const scivector_slice& v2) {
07883   return fsl_vv_less<cvector,scivector_slice,cinterval>(v1,v2);
07884 }
07885 
07887 
07890 inline bool operator<(const ivector& v1, const scivector_slice& v2) {
07891   return fsl_vv_less<ivector,scivector_slice,cinterval>(v1,v2);
07892 }
07893 
07895 
07898 inline bool operator<=(const scivector_slice& v1, const sivector_slice& v2) {
07899   return slsl_vv_leq<scivector_slice,sivector_slice,cinterval>(v1,v2);
07900 }
07901 
07903 
07906 inline bool operator<=(const scivector_slice& v1, const scivector_slice& v2) {
07907   return slsl_vv_leq<scivector_slice,scivector_slice,cinterval>(v1,v2);
07908 }
07909 
07911 
07914 inline bool operator<=(const srvector_slice& v1, const scivector_slice& v2) {
07915   return slsl_vv_leq<srvector_slice,scivector_slice,cinterval>(v1,v2);
07916 }
07917 
07919 
07922 inline bool operator<=(const scvector_slice& v1, const scivector_slice& v2) {
07923   return slsl_vv_leq<scvector_slice,scivector_slice,cinterval>(v1,v2);
07924 }
07925 
07927 
07930 inline bool operator<=(const sivector_slice& v1, const scivector_slice& v2) {
07931   return slsl_vv_leq<sivector_slice,scivector_slice,cinterval>(v1,v2);
07932 }
07933 
07935 
07938 inline bool operator<=(const scivector_slice& v1, const sivector& v2) {
07939   return slsp_vv_leq<scivector_slice,sivector,cinterval>(v1,v2);
07940 }
07941 
07943 
07946 inline bool operator<=(const scivector_slice& v1, const scivector& v2) {
07947   return slsp_vv_leq<scivector_slice,scivector,cinterval>(v1,v2);
07948 }
07949 
07951 
07954 inline bool operator<=(const srvector_slice& v1, const scivector& v2) {
07955   return slsp_vv_leq<srvector_slice,scivector,cinterval>(v1,v2);
07956 }
07957 
07959 
07962 inline bool operator<=(const scvector_slice& v1, const scivector& v2) {
07963   return slsp_vv_leq<scvector_slice,scivector,cinterval>(v1,v2);
07964 }
07965 
07967 
07970 inline bool operator<=(const sivector_slice& v1, const scivector& v2) {
07971   return slsp_vv_leq<sivector_slice,scivector,cinterval>(v1,v2);
07972 }
07973 
07975 
07978 inline bool operator<=(const scivector& v1, const sivector_slice& v2) {
07979   return spsl_vv_leq<scivector,sivector_slice,cinterval>(v1,v2);
07980 }
07981 
07983 
07986 inline bool operator<=(const scivector& v1, const scivector_slice& v2) {
07987   return spsl_vv_leq<scivector,scivector_slice,cinterval>(v1,v2);
07988 }
07989 
07991 
07994 inline bool operator<=(const srvector& v1, const scivector_slice& v2) {
07995   return spsl_vv_leq<srvector,scivector_slice,cinterval>(v1,v2);
07996 }
07997 
07999 
08002 inline bool operator<=(const scvector& v1, const scivector_slice& v2) {
08003   return spsl_vv_leq<scvector,scivector_slice,cinterval>(v1,v2);
08004 }
08005 
08007 
08010 inline bool operator<=(const sivector& v1, const scivector_slice& v2) {
08011   return spsl_vv_leq<sivector,scivector_slice,cinterval>(v1,v2);
08012 }
08013 
08015 
08018 inline bool operator<=(const scivector_slice& v1, const ivector& v2) {
08019   return slf_vv_leq<scivector_slice,ivector,cinterval>(v1,v2);
08020 }
08021 
08023 
08026 inline bool operator<=(const scivector_slice& v1, const civector& v2) {
08027   return slf_vv_leq<scivector_slice,civector,cinterval>(v1,v2);
08028 }
08029 
08031 
08034 inline bool operator<=(const srvector_slice& v1, const civector& v2) {
08035   return slf_vv_leq<srvector_slice,civector,cinterval>(v1,v2);
08036 }
08037 
08039 
08042 inline bool operator<=(const sivector_slice& v1, const civector& v2) {
08043   return slf_vv_leq<sivector_slice,civector,cinterval>(v1,v2);
08044 }
08045 
08047 
08050 inline bool operator<=(const scvector_slice& v1, const civector& v2) {
08051   return slf_vv_leq<scvector_slice,civector,cinterval>(v1,v2);
08052 }
08053 
08055 
08058 inline bool operator<=(const civector& v1, const sivector_slice& v2) {
08059   return fsl_vv_leq<civector,sivector_slice,cinterval>(v1,v2);
08060 }
08061 
08063 
08066 inline bool operator<=(const civector& v1, const scivector_slice& v2) {
08067   return fsl_vv_leq<civector,scivector_slice,cinterval>(v1,v2);
08068 }
08069 
08071 
08074 inline bool operator<=(const rvector& v1, const scivector_slice& v2) {
08075   return fsl_vv_leq<rvector,scivector_slice,cinterval>(v1,v2);
08076 }
08077 
08079 
08082 inline bool operator<=(const cvector& v1, const scivector_slice& v2) {
08083   return fsl_vv_leq<cvector,scivector_slice,cinterval>(v1,v2);
08084 }
08085 
08087 
08090 inline bool operator<=(const ivector& v1, const scivector_slice& v2) {
08091   return fsl_vv_leq<ivector,scivector_slice,cinterval>(v1,v2);
08092 }
08093 
08095 
08098 inline bool operator>(const scivector_slice& v1, const srvector_slice& v2) {
08099   return slsl_vv_greater<scivector_slice,srvector_slice,cinterval>(v1,v2);
08100 }
08101 
08103 
08106 inline bool operator>(const scivector_slice& v1, const scvector_slice& v2) {
08107   return slsl_vv_greater<scivector_slice,scvector_slice,cinterval>(v1,v2);
08108 }
08109 
08111 
08114 inline bool operator>(const scivector_slice& v1, const sivector_slice& v2) {
08115   return slsl_vv_greater<scivector_slice,sivector_slice,cinterval>(v1,v2);
08116 }
08117 
08119 
08122 inline bool operator>(const scivector_slice& v1, const scivector_slice& v2) {
08123   return slsl_vv_greater<scivector_slice,scivector_slice,cinterval>(v1,v2);
08124 }
08125 
08127 
08130 inline bool operator>(const sivector_slice& v1, const scivector_slice& v2) {
08131   return slsl_vv_greater<sivector_slice,scivector_slice,cinterval>(v1,v2);
08132 }
08133 
08135 
08138 inline bool operator>(const scivector_slice& v1, const srvector& v2) {
08139   return slsp_vv_greater<scivector_slice,srvector,cinterval>(v1,v2);
08140 }
08141 
08143 
08146 inline bool operator>(const scivector_slice& v1, const scvector& v2) {
08147   return slsp_vv_greater<scivector_slice,scvector,cinterval>(v1,v2);
08148 }
08149 
08151 
08154 inline bool operator>(const scivector_slice& v1, const sivector& v2) {
08155   return slsp_vv_greater<scivector_slice,sivector,cinterval>(v1,v2);
08156 }
08157 
08159 
08162 inline bool operator>(const scivector_slice& v1, const scivector& v2) {
08163   return slsp_vv_greater<scivector_slice,scivector,cinterval>(v1,v2);
08164 }
08165 
08167 
08170 inline bool operator>(const sivector_slice& v1, const scivector& v2) {
08171   return slsp_vv_greater<sivector_slice,scivector,cinterval>(v1,v2);
08172 }
08173 
08175 
08178 inline bool operator>(const scivector& v1, const srvector_slice& v2) {
08179   return spsl_vv_greater<scivector,srvector_slice,cinterval>(v1,v2);
08180 }
08181 
08183 
08186 inline bool operator>(const scivector& v1, const scvector_slice& v2) {
08187   return spsl_vv_greater<scivector,scvector_slice,cinterval>(v1,v2);
08188 }
08189 
08191 
08194 inline bool operator>(const scivector& v1, const sivector_slice& v2) {
08195   return spsl_vv_greater<scivector,sivector_slice,cinterval>(v1,v2);
08196 }
08197 
08199 
08202 inline bool operator>(const scivector& v1, const scivector_slice& v2) {
08203   return spsl_vv_greater<scivector,scivector_slice,cinterval>(v1,v2);
08204 }
08205 
08207 
08210 inline bool operator>(const sivector& v1, const scivector_slice& v2) {
08211   return spsl_vv_greater<sivector,scivector_slice,cinterval>(v1,v2);
08212 }
08213 
08215 
08218 inline bool operator>(const scivector_slice& v1, const rvector& v2) {
08219   return slf_vv_greater<scivector_slice,rvector,cinterval>(v1,v2);
08220 }
08221 
08223 
08226 inline bool operator>(const scivector_slice& v1, const cvector& v2) {
08227   return slf_vv_greater<scivector_slice,cvector,cinterval>(v1,v2);
08228 }
08229 
08231 
08234 inline bool operator>(const scivector_slice& v1, const ivector& v2) {
08235   return slf_vv_greater<scivector_slice,ivector,cinterval>(v1,v2);
08236 }
08237 
08239 
08242 inline bool operator>(const scivector_slice& v1, const civector& v2) {
08243   return slf_vv_greater<scivector_slice,civector,cinterval>(v1,v2);
08244 }
08245 
08247 
08250 inline bool operator>(const sivector_slice& v1, const civector& v2) {
08251   return slf_vv_greater<sivector_slice,civector,cinterval>(v1,v2);
08252 }
08253 
08255 
08258 inline bool operator>(const civector& v1, const srvector_slice& v2) {
08259   return fsl_vv_greater<civector,srvector_slice,cinterval>(v1,v2);
08260 }
08261 
08263 
08266 inline bool operator>(const civector& v1, const scvector_slice& v2) {
08267   return fsl_vv_greater<civector,scvector_slice,cinterval>(v1,v2);
08268 }
08269 
08271 
08274 inline bool operator>(const civector& v1, const sivector_slice& v2) {
08275   return fsl_vv_greater<civector,sivector_slice,cinterval>(v1,v2);
08276 }
08277 
08279 
08282 inline bool operator>(const civector& v1, const scivector_slice& v2) {
08283   return fsl_vv_greater<civector,scivector_slice,cinterval>(v1,v2);
08284 }
08285 
08287 
08290 inline bool operator>(const ivector& v1, const scivector_slice& v2) {
08291   return fsl_vv_greater<ivector,scivector_slice,cinterval>(v1,v2);
08292 }
08293 
08295 
08298 inline bool operator>(const scivector_slice& v1, const rvector_slice& v2) {
08299   return slf_vv_greater<scivector_slice,rvector_slice,cinterval>(v1,v2);
08300 }
08301 
08303 
08306 inline bool operator>(const scivector_slice& v1, const ivector_slice& v2) {
08307   return slf_vv_greater<scivector_slice,ivector_slice,cinterval>(v1,v2);
08308 }
08309 
08311 
08314 inline bool operator>(const scivector_slice& v1, const cvector_slice& v2) {
08315   return slf_vv_greater<scivector_slice,cvector_slice,cinterval>(v1,v2);
08316 }
08317 
08319 
08322 inline bool operator>(const scivector_slice& v1, const civector_slice& v2) {
08323   return slf_vv_greater<scivector_slice,civector_slice,cinterval>(v1,v2);
08324 }
08325 
08327 
08330 inline bool operator>(const sivector_slice& v1, const civector_slice& v2) {
08331   return slf_vv_greater<sivector_slice,civector_slice,cinterval>(v1,v2);
08332 }
08333 
08335 
08338 inline bool operator>(const civector_slice& v1, const srvector_slice& v2) {
08339   return fsl_vv_greater<civector_slice,srvector_slice,cinterval>(v1,v2);
08340 }
08341 
08343 
08346 inline bool operator>(const civector_slice& v1, const scvector_slice& v2) {
08347   return fsl_vv_greater<civector_slice,scvector_slice,cinterval>(v1,v2);
08348 }
08349 
08351 
08354 inline bool operator>(const civector_slice& v1, const sivector_slice& v2) {
08355   return fsl_vv_greater<civector_slice,sivector_slice,cinterval>(v1,v2);
08356 }
08357 
08359 
08362 inline bool operator>(const civector_slice& v1, const scivector_slice& v2) {
08363   return fsl_vv_greater<civector_slice,scivector_slice,cinterval>(v1,v2);
08364 }
08365 
08367 
08370 inline bool operator>(const ivector_slice& v1, const scivector_slice& v2) {
08371   return fsl_vv_greater<ivector_slice,scivector_slice,cinterval>(v1,v2);
08372 }
08373 
08375 
08378 inline bool operator>=(const scivector_slice& v1, const srvector_slice& v2) {
08379   return slsl_vv_geq<scivector_slice,srvector_slice,cinterval>(v1,v2);
08380 }
08381 
08383 
08386 inline bool operator>=(const scivector_slice& v1, const scvector_slice& v2) {
08387   return slsl_vv_geq<scivector_slice,scvector_slice,cinterval>(v1,v2);
08388 }
08389 
08391 
08394 inline bool operator>=(const scivector_slice& v1, const sivector_slice& v2) {
08395   return slsl_vv_geq<scivector_slice,sivector_slice,cinterval>(v1,v2);
08396 }
08397 
08399 
08402 inline bool operator>=(const scivector_slice& v1, const scivector_slice& v2) {
08403   return slsl_vv_geq<scivector_slice,scivector_slice,cinterval>(v1,v2);
08404 }
08405 
08407 
08410 inline bool operator>=(const sivector_slice& v1, const scivector_slice& v2) {
08411   return slsl_vv_geq<sivector_slice,scivector_slice,cinterval>(v1,v2);
08412 }
08413 
08415 
08418 inline bool operator>=(const scivector_slice& v1, const srvector& v2) {
08419   return slsp_vv_geq<scivector_slice,srvector,cinterval>(v1,v2);
08420 }
08421 
08423 
08426 inline bool operator>=(const scivector_slice& v1, const scvector& v2) {
08427   return slsp_vv_geq<scivector_slice,scvector,cinterval>(v1,v2);
08428 }
08429 
08431 
08434 inline bool operator>=(const scivector_slice& v1, const sivector& v2) {
08435   return slsp_vv_geq<scivector_slice,sivector,cinterval>(v1,v2);
08436 }
08437 
08439 
08442 inline bool operator>=(const scivector_slice& v1, const scivector& v2) {
08443   return slsp_vv_geq<scivector_slice,scivector,cinterval>(v1,v2);
08444 }
08445 
08447 
08450 inline bool operator>=(const sivector_slice& v1, const scivector& v2) {
08451   return slsp_vv_geq<sivector_slice,scivector,cinterval>(v1,v2);
08452 }
08453 
08455 
08458 inline bool operator>=(const scivector& v1, const srvector_slice& v2) {
08459   return spsl_vv_geq<scivector,srvector_slice,cinterval>(v1,v2);
08460 }
08461 
08463 
08466 inline bool operator>=(const scivector& v1, const scvector_slice& v2) {
08467   return spsl_vv_geq<scivector,scvector_slice,cinterval>(v1,v2);
08468 }
08469 
08471 
08474 inline bool operator>=(const scivector& v1, const sivector_slice& v2) {
08475   return spsl_vv_geq<scivector,sivector_slice,cinterval>(v1,v2);
08476 }
08477 
08479 
08482 inline bool operator>=(const scivector& v1, const scivector_slice& v2) {
08483   return spsl_vv_geq<scivector,scivector_slice,cinterval>(v1,v2);
08484 }
08485 
08487 
08490 inline bool operator>=(const sivector& v1, const scivector_slice& v2) {
08491   return spsl_vv_geq<sivector,scivector_slice,cinterval>(v1,v2);
08492 }
08493 
08495 
08498 inline bool operator>=(const scivector_slice& v1, const rvector& v2) {
08499   return slf_vv_geq<scivector_slice,rvector,cinterval>(v1,v2);
08500 }
08501 
08503 
08506 inline bool operator>=(const scivector_slice& v1, const cvector& v2) {
08507   return slf_vv_geq<scivector_slice,cvector,cinterval>(v1,v2);
08508 }
08509 
08511 
08514 inline bool operator>=(const scivector_slice& v1, const ivector& v2) {
08515   return slf_vv_geq<scivector_slice,ivector,cinterval>(v1,v2);
08516 }
08517 
08519 
08522 inline bool operator>=(const scivector_slice& v1, const civector& v2) {
08523   return slf_vv_geq<scivector_slice,civector,cinterval>(v1,v2);
08524 }
08525 
08527 
08530 inline bool operator>=(const sivector_slice& v1, const civector& v2) {
08531   return slf_vv_geq<sivector_slice,civector,cinterval>(v1,v2);
08532 }
08533 
08535 
08538 inline bool operator>=(const civector& v1, const srvector_slice& v2) {
08539   return fsl_vv_geq<civector,srvector_slice,cinterval>(v1,v2);
08540 }
08541 
08543 
08546 inline bool operator>=(const civector& v1, const scvector_slice& v2) {
08547   return fsl_vv_geq<civector,scvector_slice,cinterval>(v1,v2);
08548 }
08549 
08551 
08554 inline bool operator>=(const civector& v1, const sivector_slice& v2) {
08555   return fsl_vv_geq<civector,sivector_slice,cinterval>(v1,v2);
08556 }
08557 
08559 
08562 inline bool operator>=(const civector& v1, const scivector_slice& v2) {
08563   return fsl_vv_geq<civector,scivector_slice,cinterval>(v1,v2);
08564 }
08565 
08567 
08570 inline bool operator>=(const ivector& v1, const scivector_slice& v2) {
08571   return fsl_vv_geq<ivector,scivector_slice,cinterval>(v1,v2);
08572 }
08573 
08575 
08578 inline bool operator>=(const scivector_slice& v1, const rvector_slice& v2) {
08579   return slf_vv_geq<scivector_slice,rvector_slice,cinterval>(v1,v2);
08580 }
08581 
08583 
08586 inline bool operator>=(const scivector_slice& v1, const ivector_slice& v2) {
08587   return slf_vv_geq<scivector_slice,ivector_slice,cinterval>(v1,v2);
08588 }
08589 
08591 
08594 inline bool operator>=(const scivector_slice& v1, const cvector_slice& v2) {
08595   return slf_vv_geq<scivector_slice,cvector_slice,cinterval>(v1,v2);
08596 }
08597 
08599 
08602 inline bool operator>=(const scivector_slice& v1, const civector_slice& v2) {
08603   return slf_vv_geq<scivector_slice,civector_slice,cinterval>(v1,v2);
08604 }
08605 
08607 
08610 inline bool operator>=(const sivector_slice& v1, const civector_slice& v2) {
08611   return slf_vv_geq<sivector_slice,civector_slice,cinterval>(v1,v2);
08612 }
08613 
08615 
08618 inline bool operator>=(const civector_slice& v1, const srvector_slice& v2) {
08619   return fsl_vv_geq<civector_slice,srvector_slice,cinterval>(v1,v2);
08620 }
08621 
08623 
08626 inline bool operator>=(const civector_slice& v1, const scvector_slice& v2) {
08627   return fsl_vv_geq<civector_slice,scvector_slice,cinterval>(v1,v2);
08628 }
08629 
08631 
08634 inline bool operator>=(const civector_slice& v1, const sivector_slice& v2) {
08635   return fsl_vv_geq<civector_slice,sivector_slice,cinterval>(v1,v2);
08636 }
08637 
08639 
08642 inline bool operator>=(const civector_slice& v1, const scivector_slice& v2) {
08643   return fsl_vv_geq<civector_slice,scivector_slice,cinterval>(v1,v2);
08644 }
08645 
08647 
08650 inline bool operator>=(const ivector_slice& v1, const scivector_slice& v2) {
08651   return fsl_vv_geq<ivector_slice,scivector_slice,cinterval>(v1,v2);
08652 }
08653 
08655 
08660 inline std::ostream& operator<<(std::ostream& os, const scivector_slice& v) {
08661   return sl_v_output<scivector_slice,cinterval>(os,v);
08662 }
08663 
08665 
08670 inline std::istream& operator>>(std::istream& is, scivector_slice& v) {
08671   return sl_v_input<scivector_slice,cinterval>(is,v);
08672 }
08673 
08675 
08678 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const rvector& v2) {
08679   slf_vv_accu<cidotprecision,scivector_slice,rvector,sparse_cidot>(dot,v1,v2);
08680 }
08681 
08683 
08686 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const cvector& v2) {
08687   slf_vv_accu<cidotprecision,scivector_slice,cvector,sparse_cidot>(dot,v1,v2);
08688 }
08689 
08691 
08694 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const ivector& v2) {
08695   slf_vv_accu<cidotprecision,scivector_slice,ivector,sparse_cidot>(dot,v1,v2);
08696 }
08697 
08699 
08702 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const civector& v2) {
08703   slf_vv_accu<cidotprecision,scivector_slice,civector,sparse_cidot>(dot,v1,v2);
08704 }
08705 
08707 
08710 inline void accumulate(cidotprecision& dot, const srvector_slice& v1, const civector& v2) {
08711   slf_vv_accu<cidotprecision,srvector_slice,civector,sparse_cidot>(dot,v1,v2);
08712 }
08713 
08715 
08718 inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const civector& v2) {
08719   slf_vv_accu<cidotprecision,sivector_slice,civector,sparse_cidot>(dot,v1,v2);
08720 }
08721 
08723 
08726 inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const civector& v2) {
08727   slf_vv_accu<cidotprecision,scvector_slice,civector,sparse_cidot>(dot,v1,v2);
08728 }
08729 
08731 
08734 inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const ivector& v2) {
08735   slf_vv_accu<cidotprecision,scvector_slice,ivector,sparse_cidot>(dot,v1,v2);
08736 }
08737 
08739 
08742 inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const cvector& v2) {
08743   slf_vv_accu<cidotprecision,sivector_slice,cvector,sparse_cidot>(dot,v1,v2);
08744 }
08745 
08747 
08750 inline void accumulate(cidotprecision& dot, const civector& v1, const srvector_slice& v2) {
08751   fsl_vv_accu<cidotprecision,civector,srvector_slice,sparse_cidot>(dot,v1,v2);
08752 }
08753 
08755 
08758 inline void accumulate(cidotprecision& dot, const civector& v1, const scvector_slice& v2) {
08759   fsl_vv_accu<cidotprecision,civector,scvector_slice,sparse_cidot>(dot,v1,v2);
08760 }
08761 
08763 
08766 inline void accumulate(cidotprecision& dot, const civector& v1, const sivector_slice& v2) {
08767   fsl_vv_accu<cidotprecision,civector,sivector_slice,sparse_cidot>(dot,v1,v2);
08768 }
08769 
08771 
08774 inline void accumulate(cidotprecision& dot, const civector& v1, const scivector_slice& v2) {
08775   fsl_vv_accu<cidotprecision,civector,scivector_slice,sparse_cidot>(dot,v1,v2);
08776 }
08777 
08779 
08782 inline void accumulate(cidotprecision& dot, const rvector& v1, const scivector_slice& v2) {
08783   fsl_vv_accu<cidotprecision,rvector,scivector_slice,sparse_cidot>(dot,v1,v2);
08784 }
08785 
08787 
08790 inline void accumulate(cidotprecision& dot, const cvector& v1, const scivector_slice& v2) {
08791   fsl_vv_accu<cidotprecision,cvector,scivector_slice,sparse_cidot>(dot,v1,v2);
08792 }
08793 
08795 
08798 inline void accumulate(cidotprecision& dot, const ivector& v1, const scivector_slice& v2) {
08799   fsl_vv_accu<cidotprecision,ivector,scivector_slice,sparse_cidot>(dot,v1,v2);
08800 }
08801 
08803 
08806 inline void accumulate(cidotprecision& dot, const cvector& v1, const sivector_slice& v2) {
08807   fsl_vv_accu<cidotprecision,cvector,sivector_slice,sparse_cidot>(dot,v1,v2);
08808 }
08809 
08811 
08814 inline void accumulate(cidotprecision& dot, const ivector& v1, const scvector_slice& v2) {
08815   fsl_vv_accu<cidotprecision,ivector,scvector_slice,sparse_cidot>(dot,v1,v2);
08816 }
08817 
08819 
08822 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const rvector_slice& v2) {
08823   slf_vv_accu<cidotprecision,scivector_slice,rvector_slice,sparse_cidot>(dot,v1,v2);
08824 }
08825 
08827 
08830 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const ivector_slice& v2) {
08831   slf_vv_accu<cidotprecision,scivector_slice,ivector_slice,sparse_cidot>(dot,v1,v2);
08832 }
08833 
08835 
08838 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const cvector_slice& v2) {
08839   slf_vv_accu<cidotprecision,scivector_slice,cvector_slice,sparse_cidot>(dot,v1,v2);
08840 }
08841 
08843 
08846 inline void accumulate(cidotprecision& dot, const scivector_slice& v1, const civector_slice& v2) {
08847   slf_vv_accu<cidotprecision,scivector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
08848 }
08849 
08851 
08854 inline void accumulate(cidotprecision& dot, const srvector_slice& v1, const civector_slice& v2) {
08855   slf_vv_accu<cidotprecision,srvector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
08856 }
08857 
08859 
08862 inline void accumulate(cidotprecision& dot, const scvector_slice& v1, const civector_slice& v2) {
08863   slf_vv_accu<cidotprecision,scvector_slice,civector_slice,sparse_cidot>(dot,v1,v2);
08864 }
08865 
08867 
08870 inline void accumulate(cidotprecision& dot, const sivector_slice& v1, const