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