- Generated by
1.7.5.1
|
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: ivector.hpp,v 1.36 2014/01/30 17:23:45 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_IVECTOR_HPP_INCLUDED 00027 #define _CXSC_IVECTOR_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "except.hpp" 00031 #include "idot.hpp" 00032 #include "cidot.hpp" 00033 #include "interval.hpp" // used for declaration of Inf, Sup,... 00034 #include "rvector.hpp" 00035 #include "vector.hpp" 00036 00037 00038 #include <iostream> 00039 00040 namespace cxsc { 00041 00042 class srvector; 00043 class srvector_slice; 00044 class sivector; 00045 class sivector_slice; 00046 class ivector_slice; 00047 00049 00054 class ivector 00055 { 00056 friend class ivector_slice; 00057 friend class imatrix; 00058 friend class imatrix_subv; 00059 friend class civector; 00060 friend class cimatrix; 00061 friend class l_ivector; 00062 friend class l_imatrix; 00063 private: 00064 interval *dat; 00065 int l,u,size; 00066 00067 public: 00068 //#if(CXSC_INDEX_CHECK) 00069 #ifdef _CXSC_FRIEND_TPL 00070 //------------ Templates -------------------------------------------------- 00071 // Interval 00072 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 00073 #if(CXSC_INDEX_CHECK) 00074 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 00075 #else 00076 throw(); 00077 #endif 00078 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00079 #if(CXSC_INDEX_CHECK) 00080 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00081 #else 00082 throw(); 00083 #endif 00084 template <class V> friend void _vresize(V &rv) throw(); 00085 template <class V,class S> friend void _vresize(V &rv, const int &len) 00086 #if(CXSC_INDEX_CHECK) 00087 throw(ERROR__WRONG_BOUNDARIES<V>); 00088 #else 00089 throw(); 00090 #endif 00091 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub) 00092 #if(CXSC_INDEX_CHECK) 00093 throw(ERROR__WRONG_BOUNDARIES<V>); 00094 #else 00095 throw(); 00096 #endif 00097 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 00098 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 00099 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00100 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00101 #if(CXSC_INDEX_CHECK) 00102 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00103 #else 00104 throw(); 00105 #endif 00106 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00107 #if(CXSC_INDEX_CHECK) 00108 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00109 #else 00110 throw(); 00111 #endif 00112 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00113 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2) 00114 #if(CXSC_INDEX_CHECK) 00115 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00116 #else 00117 throw(); 00118 #endif 00119 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2) 00120 #if(CXSC_INDEX_CHECK) 00121 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00122 #else 00123 throw(); 00124 #endif 00125 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl) 00126 #if(CXSC_INDEX_CHECK) 00127 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00128 #else 00129 throw(); 00130 #endif 00131 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl) 00132 #if(CXSC_INDEX_CHECK) 00133 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00134 #else 00135 throw(); 00136 #endif 00137 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v) 00138 #if(CXSC_INDEX_CHECK) 00139 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00140 #else 00141 throw(); 00142 #endif 00143 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v) 00144 #if(CXSC_INDEX_CHECK) 00145 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00146 #else 00147 throw(); 00148 #endif 00149 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2) 00150 #if(CXSC_INDEX_CHECK) 00151 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00152 #else 00153 throw(); 00154 #endif 00155 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2) 00156 #if(CXSC_INDEX_CHECK) 00157 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00158 #else 00159 throw(); 00160 #endif 00161 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl) 00162 #if(CXSC_INDEX_CHECK) 00163 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00164 #else 00165 throw(); 00166 #endif 00167 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl) 00168 #if(CXSC_INDEX_CHECK) 00169 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00170 #else 00171 throw(); 00172 #endif 00173 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v) 00174 #if(CXSC_INDEX_CHECK) 00175 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00176 #else 00177 throw(); 00178 #endif 00179 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v) 00180 #if(CXSC_INDEX_CHECK) 00181 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00182 #else 00183 throw(); 00184 #endif 00185 template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw(); 00186 template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw(); 00187 template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw(); 00188 template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw(); 00189 template <class V,class E> friend E _vabs(const V &rv) throw(); 00190 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00191 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00192 template <class V,class E> friend E _vdiam(const V &rv) throw(); 00193 template <class V,class E> friend E _vmid(const V &rv) throw(); 00194 template <class V,class E> friend E _vinf(const V &rv) throw(); 00195 template <class V,class E> friend E _vsup(const V &rv) throw(); 00196 00197 //-------- vector-vector ----------------------- 00198 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 00199 #if(CXSC_INDEX_CHECK) 00200 throw(OP_WITH_WRONG_DIM); 00201 #else 00202 throw(); 00203 #endif 00204 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00205 #if(CXSC_INDEX_CHECK) 00206 throw(OP_WITH_WRONG_DIM); 00207 #else 00208 throw(); 00209 #endif 00210 template <class V1,class V2,class E> friend E _vvimult(const V1 & rv1, const V2 &rv2) 00211 #if(CXSC_INDEX_CHECK) 00212 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00213 #else 00214 throw(); 00215 #endif 00216 template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv) 00217 #if(CXSC_INDEX_CHECK) 00218 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00219 #else 00220 throw(); 00221 #endif 00222 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 00223 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 00224 #if(CXSC_INDEX_CHECK) 00225 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00226 #else 00227 throw(); 00228 #endif 00229 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00230 #if(CXSC_INDEX_CHECK) 00231 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00232 #else 00233 throw(); 00234 #endif 00235 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00236 #if(CXSC_INDEX_CHECK) 00237 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00238 #else 00239 throw(); 00240 #endif 00241 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00242 #if(CXSC_INDEX_CHECK) 00243 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00244 #else 00245 throw(); 00246 #endif 00247 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 00248 #if(CXSC_INDEX_CHECK) 00249 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00250 #else 00251 throw(); 00252 #endif 00253 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 00254 #if(CXSC_INDEX_CHECK) 00255 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00256 #else 00257 throw(); 00258 #endif 00259 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 00260 #if(CXSC_INDEX_CHECK) 00261 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00262 #else 00263 throw(); 00264 #endif 00265 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00266 #if(CXSC_INDEX_CHECK) 00267 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00268 #else 00269 throw(); 00270 #endif 00271 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00272 #if(CXSC_INDEX_CHECK) 00273 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00274 #else 00275 throw(); 00276 #endif 00277 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 00278 #if(CXSC_INDEX_CHECK) 00279 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00280 #else 00281 throw(); 00282 #endif 00283 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 00284 #if(CXSC_INDEX_CHECK) 00285 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00286 #else 00287 throw(); 00288 #endif 00289 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 00290 #if(CXSC_INDEX_CHECK) 00291 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00292 #else 00293 throw(); 00294 #endif 00295 template <class V> friend V _vminus(const V &rv) throw(); 00296 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 00297 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 00298 #if(CXSC_INDEX_CHECK) 00299 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00300 #else 00301 throw(); 00302 #endif 00303 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 00304 #if(CXSC_INDEX_CHECK) 00305 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00306 #else 00307 throw(); 00308 #endif 00309 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 00310 #if(CXSC_INDEX_CHECK) 00311 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00312 #else 00313 throw(); 00314 #endif 00315 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 00316 #if(CXSC_INDEX_CHECK) 00317 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00318 #else 00319 throw(); 00320 #endif 00321 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 00322 #if(CXSC_INDEX_CHECK) 00323 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00324 #else 00325 throw(); 00326 #endif 00327 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 00328 #if(CXSC_INDEX_CHECK) 00329 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00330 #else 00331 throw(); 00332 #endif 00333 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 00334 #if(CXSC_INDEX_CHECK) 00335 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00336 #else 00337 throw(); 00338 #endif 00339 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 00340 #if(CXSC_INDEX_CHECK) 00341 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00342 #else 00343 throw(); 00344 #endif 00345 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 00346 #if(CXSC_INDEX_CHECK) 00347 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00348 #else 00349 throw(); 00350 #endif 00351 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 00352 #if(CXSC_INDEX_CHECK) 00353 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00354 #else 00355 throw(); 00356 #endif 00357 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 00358 #if(CXSC_INDEX_CHECK) 00359 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00360 #else 00361 throw(); 00362 #endif 00363 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 00364 #if(CXSC_INDEX_CHECK) 00365 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00366 #else 00367 throw(); 00368 #endif 00369 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 00370 #if(CXSC_INDEX_CHECK) 00371 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00372 #else 00373 throw(); 00374 #endif 00375 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 00376 #if(CXSC_INDEX_CHECK) 00377 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00378 #else 00379 throw(); 00380 #endif 00381 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 00382 #if(CXSC_INDEX_CHECK) 00383 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00384 #else 00385 throw(); 00386 #endif 00387 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 00388 #if(CXSC_INDEX_CHECK) 00389 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00390 #else 00391 throw(); 00392 #endif 00393 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 00394 #if(CXSC_INDEX_CHECK) 00395 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00396 #else 00397 throw(); 00398 #endif 00399 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2) 00400 #if(CXSC_INDEX_CHECK) 00401 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00402 #else 00403 throw(); 00404 #endif 00405 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2) 00406 #if(CXSC_INDEX_CHECK) 00407 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00408 #else 00409 throw(); 00410 #endif 00411 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv) 00412 #if(CXSC_INDEX_CHECK) 00413 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00414 #else 00415 throw(); 00416 #endif 00417 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v) 00418 #if(CXSC_INDEX_CHECK) 00419 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00420 #else 00421 throw(); 00422 #endif 00423 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2) 00424 #if(CXSC_INDEX_CHECK) 00425 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00426 #else 00427 throw(); 00428 #endif 00429 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2) 00430 #if(CXSC_INDEX_CHECK) 00431 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00432 #else 00433 throw(); 00434 #endif 00435 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv) 00436 #if(CXSC_INDEX_CHECK) 00437 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00438 #else 00439 throw(); 00440 #endif 00441 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v) 00442 #if(CXSC_INDEX_CHECK) 00443 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00444 #else 00445 throw(); 00446 #endif 00447 template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2) 00448 #if(CXSC_INDEX_CHECK) 00449 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00450 #else 00451 throw(); 00452 #endif 00453 //--------- vector-scalar ----------------- 00454 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 00455 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 00456 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00457 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 00458 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00459 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00460 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00461 #if(CXSC_INDEX_CHECK) 00462 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00463 #else 00464 throw(); 00465 #endif 00466 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00467 #if(CXSC_INDEX_CHECK) 00468 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00469 #else 00470 throw(); 00471 #endif 00472 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00473 #if(CXSC_INDEX_CHECK) 00474 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00475 #else 00476 throw(); 00477 #endif 00478 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00479 #if(CXSC_INDEX_CHECK) 00480 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00481 #else 00482 throw(); 00483 #endif 00484 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00485 #if(CXSC_INDEX_CHECK) 00486 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00487 #else 00488 throw(); 00489 #endif 00490 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00491 #if(CXSC_INDEX_CHECK) 00492 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00493 #else 00494 throw(); 00495 #endif 00496 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00497 #if(CXSC_INDEX_CHECK) 00498 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00499 #else 00500 throw(); 00501 #endif 00502 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00503 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00504 #if(CXSC_INDEX_CHECK) 00505 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00506 #else 00507 throw(); 00508 #endif 00509 00510 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw(); 00511 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 00512 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw(); 00513 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 00514 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw(); 00515 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 00516 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw(); 00517 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 00518 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 00519 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 00520 template <class V> friend bool _vnot(const V &rv) throw(); 00521 template <class V> friend void *_vvoid(const V &rv) throw(); 00522 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00523 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00524 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00525 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00526 template <class VS> friend bool _vsnot(const VS &sl) throw(); 00527 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 00528 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw(); 00529 template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw(); 00530 00531 //------------- vector-matrix --------------- 00532 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00533 #if(CXSC_INDEX_CHECK) 00534 throw(OP_WITH_WRONG_DIM); 00535 #else 00536 throw(); 00537 #endif 00538 00539 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00540 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v) 00541 #if(CXSC_INDEX_CHECK) 00542 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00543 #else 00544 throw(); 00545 #endif 00546 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m) 00547 #if(CXSC_INDEX_CHECK) 00548 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00549 #else 00550 throw(); 00551 #endif 00552 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m) 00553 #if(CXSC_INDEX_CHECK) 00554 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00555 #else 00556 throw(); 00557 #endif 00558 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v) 00559 #if(CXSC_INDEX_CHECK) 00560 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00561 #else 00562 throw(); 00563 #endif 00564 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms) 00565 #if(CXSC_INDEX_CHECK) 00566 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00567 #else 00568 throw(); 00569 #endif 00570 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms) 00571 #if(CXSC_INDEX_CHECK) 00572 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00573 #else 00574 throw(); 00575 #endif 00576 00577 // Real 00578 //--Real -------- vector-scalar ------------ 00579 //--Real--------- Vector-vector--------- 00580 //-- Real -------- Vector-matrix ---------- 00581 // complex 00582 //--complex -------- vector-scalar ------------ 00583 //--complex--------- Vector-vector--------- 00584 00585 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2) 00586 #if(CXSC_INDEX_CHECK) 00587 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00588 #else 00589 throw(); 00590 #endif 00591 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv) 00592 #if(CXSC_INDEX_CHECK) 00593 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00594 #else 00595 throw(); 00596 #endif 00597 00598 //-- complex -------- Vector-matrix ---------- 00599 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v) 00600 #if(CXSC_INDEX_CHECK) 00601 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00602 #else 00603 throw(); 00604 #endif 00605 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 00606 #if(CXSC_INDEX_CHECK) 00607 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00608 #else 00609 throw(); 00610 #endif 00611 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m) 00612 #if(CXSC_INDEX_CHECK) 00613 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00614 #else 00615 throw(); 00616 #endif 00617 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 00618 #if(CXSC_INDEX_CHECK) 00619 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00620 #else 00621 throw(); 00622 #endif 00623 00624 // civector --------------------- 00625 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2) 00626 #if(CXSC_INDEX_CHECK) 00627 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00628 #else 00629 throw(); 00630 #endif 00631 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2) 00632 #if(CXSC_INDEX_CHECK) 00633 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00634 #else 00635 throw(); 00636 #endif 00637 template <class V,class E> friend E _vim(const V &rv) throw(); 00638 template <class V,class E> friend E _vre(const V &rv) throw(); 00639 00640 template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv) 00641 #if(CXSC_INDEX_CHECK) 00642 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00643 #else 00644 throw(); 00645 #endif 00646 template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv) 00647 #if(CXSC_INDEX_CHECK) 00648 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00649 #else 00650 throw(); 00651 #endif 00652 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv) 00653 #if(CXSC_INDEX_CHECK) 00654 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00655 #else 00656 throw(); 00657 #endif 00658 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv) 00659 #if(CXSC_INDEX_CHECK) 00660 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00661 #else 00662 throw(); 00663 #endif 00664 template <class MV,class V> friend V _mvim(const MV &mv) throw(); 00665 template <class MV,class V> friend V _mvre(const MV &mv) throw(); 00666 00667 // vector-scalar 00668 // vector-vector 00669 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2) 00670 #if(CXSC_INDEX_CHECK) 00671 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00672 #else 00673 throw(); 00674 #endif 00675 00676 // vector-matrix 00677 // l_real 00678 //--l_real -------- vector-scalar ------------ 00679 //--l_real--------- Vector-vector--------- 00680 00681 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2) 00682 #if(CXSC_INDEX_CHECK) 00683 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00684 #else 00685 throw(); 00686 #endif 00687 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 00688 #if(CXSC_INDEX_CHECK) 00689 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00690 #else 00691 throw(); 00692 #endif 00693 00694 //-- l_real -------- Vector-matrix ---------- 00695 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 00696 #if(CXSC_INDEX_CHECK) 00697 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00698 #else 00699 throw(); 00700 #endif 00701 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 00702 #if(CXSC_INDEX_CHECK) 00703 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00704 #else 00705 throw(); 00706 #endif 00707 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 00708 #if(CXSC_INDEX_CHECK) 00709 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00710 #else 00711 throw(); 00712 #endif 00713 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 00714 #if(CXSC_INDEX_CHECK) 00715 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00716 #else 00717 throw(); 00718 #endif 00719 00720 // l_ivector --------------------- 00721 // vector-scalar 00722 // vector-vector 00723 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 00724 #if(CXSC_INDEX_CHECK) 00725 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00726 #else 00727 throw(); 00728 #endif 00729 // vector-matrix 00730 00731 #endif 00732 00733 //------ Konstruktoren ---------------------------------------------------- 00735 INLINE ivector () throw(); 00737 explicit INLINE ivector(const int &i) throw(); 00738 #ifdef OLD_CXSC 00739 00740 explicit INLINE ivector(const class index &i) throw(); // for backwards compatibility 00741 #endif 00742 00743 explicit INLINE ivector(const int &i1,const int &i2) 00744 #if(CXSC_INDEX_CHECK) 00745 throw(ERROR_IVECTOR_WRONG_BOUNDARIES,ERROR_IVECTOR_NO_MORE_MEMORY); 00746 #else 00747 throw(); 00748 #endif 00749 00750 INLINE ivector(const imatrix_subv &) throw(); 00752 explicit INLINE ivector(const interval &) throw(); 00754 // explicit INLINE ivector(const imatrix &) 00755 explicit ivector(const imatrix &) 00756 #if(CXSC_INDEX_CHECK) 00757 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00758 #else 00759 throw(); 00760 #endif 00761 00762 explicit INLINE ivector(const imatrix_slice &sl) 00763 #if(CXSC_INDEX_CHECK) 00764 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00765 #else 00766 throw(); 00767 #endif 00768 00769 INLINE ivector(const ivector_slice &rs) throw(); 00771 INLINE ivector(const ivector &v) throw(); 00773 INLINE ivector(const sivector &rs); 00775 INLINE ivector(const sivector_slice &rs); 00776 00777 // Real 00779 explicit INLINE ivector(const real &) throw(); 00781 explicit INLINE ivector(const rvector_slice &rs) throw(); 00783 explicit INLINE ivector(const srvector &rs); 00785 explicit INLINE ivector(const srvector_slice &rs); 00786 00788 explicit INLINE ivector(const rvector &v) throw(); 00790 explicit INLINE ivector(const rmatrix &) 00791 #if(CXSC_INDEX_CHECK) 00792 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00793 #else 00794 throw(); 00795 #endif 00796 00797 explicit INLINE ivector(const rmatrix_slice &sl) 00798 #if(CXSC_INDEX_CHECK) 00799 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00800 #else 00801 throw(); 00802 #endif 00803 00804 // explicit INLINE ivector(const rmatrix_subv &) throw(); 00805 explicit ivector(const rmatrix_subv &) throw(); 00806 00807 // Interval 00809 INLINE ivector &operator =(const ivector &rv) throw(); 00811 INLINE ivector &operator =(const ivector_slice &sl) throw(); 00813 INLINE ivector &operator =(const sivector &rv); 00815 INLINE ivector &operator =(const sivector_slice &sl); 00817 INLINE ivector &operator =(const srvector &rv); 00819 INLINE ivector &operator =(const srvector_slice &sl); 00821 INLINE ivector &operator =(const interval &r) throw(); 00823 INLINE ivector &operator =(const imatrix &m) 00824 #if(CXSC_INDEX_CHECK) 00825 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00826 #else 00827 throw(); 00828 #endif 00829 00830 INLINE ivector &operator =(const imatrix_slice &) 00831 #if(CXSC_INDEX_CHECK) 00832 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00833 #else 00834 throw(); 00835 #endif 00836 00837 INLINE ivector &operator =(const imatrix_subv &) throw(); 00838 // Real 00840 INLINE ivector &operator =(const rvector &rv) throw(); 00842 INLINE ivector &operator =(const rvector_slice &sl) throw(); 00844 INLINE ivector &operator =(const real &r) throw(); 00846 INLINE ivector &operator =(const rmatrix &m) 00847 #if(CXSC_INDEX_CHECK) 00848 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00849 #else 00850 throw(); 00851 #endif 00852 00853 INLINE ivector &operator =(const rmatrix_slice &) 00854 #if(CXSC_INDEX_CHECK) 00855 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00856 #else 00857 throw(); 00858 #endif 00859 00860 INLINE ivector &operator =(const rmatrix_subv &) throw(); 00861 00863 INLINE ivector &operator+=(const srvector&); 00865 INLINE ivector &operator+=(const sivector&); 00867 INLINE ivector &operator+=(const srvector_slice&); 00869 INLINE ivector &operator+=(const sivector_slice&); 00871 INLINE ivector &operator-=(const srvector&); 00873 INLINE ivector &operator-=(const sivector&); 00875 INLINE ivector &operator-=(const srvector_slice&); 00877 INLINE ivector &operator-=(const sivector_slice&); 00879 INLINE ivector &operator|=(const srvector&); 00881 INLINE ivector &operator|=(const sivector&); 00883 INLINE ivector &operator|=(const srvector_slice&); 00885 INLINE ivector &operator|=(const sivector_slice&); 00887 INLINE ivector &operator&=(const sivector&); 00889 INLINE ivector &operator&=(const sivector_slice&); 00890 00892 INLINE ivector operator()(const intvector& p); 00894 INLINE ivector operator()(const intmatrix& P); 00895 00896 //--------- Destruktor ---------------------------------------------------- 00897 INLINE ~ivector() { delete [] dat; } 00898 00899 //------ Standardfunktionen ----------------------------------------------- 00900 00901 friend INLINE interval::interval(const ivector &) 00902 #if(CXSC_INDEX_CHECK) 00903 throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ); 00904 #else 00905 throw(); 00906 #endif 00907 00908 friend INLINE int Lb(const ivector &rv) throw() { return rv.l; } 00910 friend INLINE int Ub(const ivector &rv) throw() { return rv.u; } 00912 friend INLINE int VecLen(const ivector &rv) throw() { return rv.size; } 00914 friend INLINE ivector &SetLb(ivector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv; } 00916 friend INLINE ivector &SetUb(ivector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv; } 00918 INLINE interval & operator [](const int &i) const 00919 #if(CXSC_INDEX_CHECK) 00920 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC); 00921 #else 00922 throw(); 00923 #endif 00924 00926 INLINE interval & operator [](const int &i) 00927 #if(CXSC_INDEX_CHECK) 00928 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC); 00929 #else 00930 throw(); 00931 #endif 00932 00934 INLINE ivector & operator ()() throw() { return *this; } 00936 INLINE ivector_slice operator ()(const int &i) 00937 #if(CXSC_INDEX_CHECK) 00938 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG); 00939 #else 00940 throw(); 00941 #endif 00942 00943 INLINE ivector_slice operator ()(const int &i1,const int &i2) 00944 #if(CXSC_INDEX_CHECK) 00945 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG); 00946 #else 00947 throw(); 00948 #endif 00949 00950 INLINE operator void*() throw(); 00951 //#else 00952 //#endif 00953 }; 00954 00955 00957 00962 class ivector_slice 00963 { 00964 friend class ivector; 00965 friend class imatrix; 00966 friend class civector; 00967 friend class cimatrix; 00968 friend class l_ivector; 00969 friend class l_imatrix; 00970 private: 00971 interval *dat; 00972 int l,u,size; 00973 int start,end; 00974 00975 public: 00976 //#if(CXSC_INDEX_CHECK) 00977 #ifdef _CXSC_FRIEND_TPL 00978 //------------------------- Templates ------------------------------------------- 00979 // Interval / Interval 00980 00981 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2) 00982 #if(CXSC_INDEX_CHECK) 00983 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00984 #else 00985 throw(); 00986 #endif 00987 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00988 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00989 #if(CXSC_INDEX_CHECK) 00990 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00991 #else 00992 throw(); 00993 #endif 00994 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw(); 00995 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv) 00996 #if(CXSC_INDEX_CHECK) 00997 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00998 #else 00999 throw(); 01000 #endif 01001 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv) 01002 #if(CXSC_INDEX_CHECK) 01003 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01004 #else 01005 throw(); 01006 #endif 01007 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2) 01008 #if(CXSC_INDEX_CHECK) 01009 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01010 #else 01011 throw(); 01012 #endif 01013 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2) 01014 #if(CXSC_INDEX_CHECK) 01015 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01016 #else 01017 throw(); 01018 #endif 01019 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv) 01020 #if(CXSC_INDEX_CHECK) 01021 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01022 #else 01023 throw(); 01024 #endif 01025 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv) 01026 #if(CXSC_INDEX_CHECK) 01027 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01028 #else 01029 throw(); 01030 #endif 01031 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2) 01032 #if(CXSC_INDEX_CHECK) 01033 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01034 #else 01035 throw(); 01036 #endif 01037 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2) 01038 #if(CXSC_INDEX_CHECK) 01039 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01040 #else 01041 throw(); 01042 #endif 01043 template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw(); 01044 template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw(); 01045 template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw(); 01046 template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw(); 01047 01048 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 01049 #if(CXSC_INDEX_CHECK) 01050 throw(OP_WITH_WRONG_DIM); 01051 #else 01052 throw(); 01053 #endif 01054 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 01055 #if(CXSC_INDEX_CHECK) 01056 throw(OP_WITH_WRONG_DIM); 01057 #else 01058 throw(); 01059 #endif 01060 01061 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 01062 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 01063 01064 template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv) 01065 #if(CXSC_INDEX_CHECK) 01066 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01067 #else 01068 throw(); 01069 #endif 01070 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw(); 01071 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw(); 01072 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 01073 #if(CXSC_INDEX_CHECK) 01074 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01075 #else 01076 throw(); 01077 #endif 01078 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 01079 #if(CXSC_INDEX_CHECK) 01080 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01081 #else 01082 throw(); 01083 #endif 01084 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 01085 #if(CXSC_INDEX_CHECK) 01086 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01087 #else 01088 throw(); 01089 #endif 01090 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 01091 #if(CXSC_INDEX_CHECK) 01092 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01093 #else 01094 throw(); 01095 #endif 01096 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 01097 #if(CXSC_INDEX_CHECK) 01098 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01099 #else 01100 throw(); 01101 #endif 01102 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 01103 #if(CXSC_INDEX_CHECK) 01104 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01105 #else 01106 throw(); 01107 #endif 01108 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 01109 #if(CXSC_INDEX_CHECK) 01110 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01111 #else 01112 throw(); 01113 #endif 01114 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 01115 #if(CXSC_INDEX_CHECK) 01116 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01117 #else 01118 throw(); 01119 #endif 01120 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 01121 #if(CXSC_INDEX_CHECK) 01122 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01123 #else 01124 throw(); 01125 #endif 01126 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 01127 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 01128 #if(CXSC_INDEX_CHECK) 01129 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01130 #else 01131 throw(); 01132 #endif 01133 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 01134 #if(CXSC_INDEX_CHECK) 01135 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01136 #else 01137 throw(); 01138 #endif 01139 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 01140 #if(CXSC_INDEX_CHECK) 01141 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01142 #else 01143 throw(); 01144 #endif 01145 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 01146 #if(CXSC_INDEX_CHECK) 01147 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01148 #else 01149 throw(); 01150 #endif 01151 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 01152 #if(CXSC_INDEX_CHECK) 01153 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01154 #else 01155 throw(); 01156 #endif 01157 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 01158 #if(CXSC_INDEX_CHECK) 01159 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01160 #else 01161 throw(); 01162 #endif 01163 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 01164 #if(CXSC_INDEX_CHECK) 01165 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01166 #else 01167 throw(); 01168 #endif 01169 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 01170 #if(CXSC_INDEX_CHECK) 01171 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01172 #else 01173 throw(); 01174 #endif 01175 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 01176 #if(CXSC_INDEX_CHECK) 01177 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01178 #else 01179 throw(); 01180 #endif 01181 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 01182 #if(CXSC_INDEX_CHECK) 01183 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01184 #else 01185 throw(); 01186 #endif 01187 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 01188 #if(CXSC_INDEX_CHECK) 01189 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01190 #else 01191 throw(); 01192 #endif 01193 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 01194 #if(CXSC_INDEX_CHECK) 01195 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01196 #else 01197 throw(); 01198 #endif 01199 template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m) 01200 #if(CXSC_INDEX_CHECK) 01201 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01202 #else 01203 throw(); 01204 #endif 01205 01206 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 01207 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 01208 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 01209 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 01210 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 01211 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 01212 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 01213 template <class VS,class E> friend E _vsdiam(const VS &sl) throw(); 01214 template <class VS,class E> friend E _vsmid(const VS &sl) throw(); 01215 template <class VS,class E> friend E _vsinf(const VS &sl) throw(); 01216 template <class VS,class E> friend E _vssup(const VS &sl) throw(); 01217 template <class VS1,class VS2,class E> friend E _vsvsimult(const VS1 & sl1, const VS2 &sl2) 01218 #if(CXSC_INDEX_CHECK) 01219 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01220 #else 01221 throw(); 01222 #endif 01223 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 01224 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 01225 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 01226 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 01227 template <class VS> friend bool _vsnot(const VS &sl) throw(); 01228 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 01229 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw(); 01230 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw(); 01231 01232 // Interval / Real 01233 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms) 01234 #if(CXSC_INDEX_CHECK) 01235 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01236 #else 01237 throw(); 01238 #endif 01239 01240 // complex 01241 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv) 01242 #if(CXSC_INDEX_CHECK) 01243 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01244 #else 01245 throw(); 01246 #endif 01247 template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl) 01248 #if(CXSC_INDEX_CHECK) 01249 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01250 #else 01251 throw(); 01252 #endif 01253 template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl) 01254 #if(CXSC_INDEX_CHECK) 01255 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01256 #else 01257 throw(); 01258 #endif 01259 template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2) 01260 #if(CXSC_INDEX_CHECK) 01261 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01262 #else 01263 throw(); 01264 #endif 01265 template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2) 01266 #if(CXSC_INDEX_CHECK) 01267 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01268 #else 01269 throw(); 01270 #endif 01271 01272 // cinterval-- vector-scalar 01273 // cinterval -- vector-vector 01274 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2) 01275 #if(CXSC_INDEX_CHECK) 01276 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01277 #else 01278 throw(); 01279 #endif 01280 01281 // cinterval -- vector-matrix 01282 // l_real 01283 01284 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 01285 #if(CXSC_INDEX_CHECK) 01286 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01287 #else 01288 throw(); 01289 #endif 01290 01291 // l_interval ---------- 01292 // l_interval-- vector-scalar 01293 // l_interval -- vector-vector 01294 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 01295 #if(CXSC_INDEX_CHECK) 01296 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01297 #else 01298 throw(); 01299 #endif 01300 01301 01302 #endif 01303 01304 //--------------------- Konstruktoren ----------------------------------- 01306 explicit INLINE ivector_slice(ivector &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { } 01308 explicit INLINE ivector_slice(ivector_slice &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { } 01309 public: 01311 INLINE ivector_slice(const ivector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { } 01312 public: 01313 // Interval 01315 INLINE ivector_slice & operator =(const sivector &sl); 01317 INLINE ivector_slice & operator =(const sivector_slice &sl); 01319 INLINE ivector_slice & operator =(const srvector &sl); 01321 INLINE ivector_slice & operator =(const srvector_slice &sl); 01322 01324 INLINE ivector_slice & operator =(const ivector_slice &sl) 01325 #if(CXSC_INDEX_CHECK) 01326 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01327 #else 01328 throw(); 01329 #endif 01330 01331 INLINE ivector_slice & operator =(const ivector &rv) 01332 #if(CXSC_INDEX_CHECK) 01333 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01334 #else 01335 throw(); 01336 #endif 01337 01338 INLINE ivector_slice & operator =(const interval &r) throw(); 01340 INLINE ivector_slice & operator =(const imatrix &m) 01341 #if(CXSC_INDEX_CHECK) 01342 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01343 #else 01344 throw(); 01345 #endif 01346 01347 INLINE ivector_slice & operator =(const imatrix_slice &m) 01348 #if(CXSC_INDEX_CHECK) 01349 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01350 #else 01351 throw(); 01352 #endif 01353 01354 INLINE ivector_slice &operator =(const imatrix_subv &) throw(); 01355 // Real 01357 INLINE ivector_slice & operator =(const rvector_slice &sl) 01358 #if(CXSC_INDEX_CHECK) 01359 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01360 #else 01361 throw(); 01362 #endif 01363 01364 INLINE ivector_slice & operator =(const rvector &rv) 01365 #if(CXSC_INDEX_CHECK) 01366 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01367 #else 01368 throw(); 01369 #endif 01370 01371 INLINE ivector_slice & operator =(const real &r) throw(); 01373 INLINE ivector_slice & operator =(const rmatrix &m) 01374 #if(CXSC_INDEX_CHECK) 01375 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01376 #else 01377 throw(); 01378 #endif 01379 01380 INLINE ivector_slice & operator =(const rmatrix_slice &m) 01381 #if(CXSC_INDEX_CHECK) 01382 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01383 #else 01384 throw(); 01385 #endif 01386 01387 INLINE ivector_slice &operator =(const rmatrix_subv &mv) throw(); 01388 01389 //--------------------- Standardfunktionen ------------------------------ 01390 01391 friend INLINE interval::interval(const ivector_slice &sl) 01392 #if(CXSC_INDEX_CHECK) 01393 throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ); 01394 #else 01395 throw(); 01396 #endif 01397 01398 friend INLINE int Lb(const ivector_slice &sl) throw() { return sl.start; } 01400 friend INLINE int Ub(const ivector_slice &sl) throw() { return sl.end; } 01402 friend INLINE int VecLen(const ivector_slice &sl) throw() { return sl.end-sl.start+1; } 01404 INLINE interval & operator [](const int &i) const 01405 #if(CXSC_INDEX_CHECK) 01406 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC); 01407 #else 01408 throw(); 01409 #endif 01410 01412 INLINE interval & operator [](const int &i) 01413 #if(CXSC_INDEX_CHECK) 01414 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC); 01415 #else 01416 throw(); 01417 #endif 01418 01420 INLINE ivector_slice & operator ()() throw() { return *this; } 01422 INLINE ivector_slice operator ()(const int &i) 01423 #if(CXSC_INDEX_CHECK) 01424 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG); 01425 #else 01426 throw(); 01427 #endif 01428 01429 INLINE ivector_slice operator ()(const int &i1,const int &i2) 01430 #if(CXSC_INDEX_CHECK) 01431 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG); 01432 #else 01433 throw(); 01434 #endif 01435 01437 INLINE ivector_slice &operator /=(const interval &r) throw(); 01439 INLINE ivector_slice &operator /=(const real &r) throw(); 01441 INLINE ivector_slice &operator *=(const interval &r) throw(); 01443 INLINE ivector_slice &operator *=(const imatrix &m) 01444 #if(CXSC_INDEX_CHECK) 01445 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01446 #else 01447 throw(); 01448 #endif 01449 01450 INLINE ivector_slice &operator *=(const rmatrix &m) 01451 #if(CXSC_INDEX_CHECK) 01452 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01453 #else 01454 throw(); 01455 #endif 01456 01457 INLINE ivector_slice &operator *=(const real &r) throw(); 01459 INLINE ivector_slice &operator +=(const ivector &rv) 01460 #if(CXSC_INDEX_CHECK) 01461 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01462 #else 01463 throw(); 01464 #endif 01465 01466 INLINE ivector_slice &operator +=(const ivector_slice &sl2) 01467 #if(CXSC_INDEX_CHECK) 01468 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01469 #else 01470 throw(); 01471 #endif 01472 01473 INLINE ivector_slice &operator -=(const ivector &rv) 01474 #if(CXSC_INDEX_CHECK) 01475 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01476 #else 01477 throw(); 01478 #endif 01479 01480 INLINE ivector_slice &operator -=(const ivector_slice &sl2) 01481 #if(CXSC_INDEX_CHECK) 01482 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01483 #else 01484 throw(); 01485 #endif 01486 01487 INLINE ivector_slice &operator |=(const ivector &rv) 01488 #if(CXSC_INDEX_CHECK) 01489 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01490 #else 01491 throw(); 01492 #endif 01493 01494 INLINE ivector_slice &operator |=(const ivector_slice &sl2) 01495 #if(CXSC_INDEX_CHECK) 01496 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01497 #else 01498 throw(); 01499 #endif 01500 01501 INLINE ivector_slice &operator &=(const ivector &rv) 01502 #if(CXSC_INDEX_CHECK) 01503 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01504 #else 01505 throw(); 01506 #endif 01507 01508 INLINE ivector_slice &operator &=(const ivector_slice &sl2) 01509 #if(CXSC_INDEX_CHECK) 01510 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01511 #else 01512 throw(); 01513 #endif 01514 01516 INLINE ivector_slice &operator +=(const rvector &rv) 01517 #if(CXSC_INDEX_CHECK) 01518 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01519 #else 01520 throw(); 01521 #endif 01522 01523 INLINE ivector_slice &operator +=(const rvector_slice &sl2) 01524 #if(CXSC_INDEX_CHECK) 01525 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01526 #else 01527 throw(); 01528 #endif 01529 01530 INLINE ivector_slice &operator -=(const rvector &rv) 01531 #if(CXSC_INDEX_CHECK) 01532 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01533 #else 01534 throw(); 01535 #endif 01536 01537 INLINE ivector_slice &operator -=(const rvector_slice &sl2) 01538 #if(CXSC_INDEX_CHECK) 01539 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01540 #else 01541 throw(); 01542 #endif 01543 01544 INLINE ivector_slice &operator |=(const rvector &rv) 01545 #if(CXSC_INDEX_CHECK) 01546 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01547 #else 01548 throw(); 01549 #endif 01550 01551 INLINE ivector_slice &operator |=(const rvector_slice &sl2) 01552 #if(CXSC_INDEX_CHECK) 01553 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01554 #else 01555 throw(); 01556 #endif 01557 01558 INLINE ivector_slice &operator &=(const rvector &rv) 01559 #if(CXSC_INDEX_CHECK) 01560 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01561 #else 01562 throw(); 01563 #endif 01564 01565 INLINE ivector_slice &operator &=(const rvector_slice &sl2) 01566 #if(CXSC_INDEX_CHECK) 01567 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01568 #else 01569 throw(); 01570 #endif 01571 INLINE operator void*() throw(); 01572 //#else 01573 //#endif 01574 01576 INLINE ivector_slice &operator+=(const srvector&); 01578 INLINE ivector_slice &operator+=(const sivector&); 01580 INLINE ivector_slice &operator+=(const srvector_slice&); 01582 INLINE ivector_slice &operator+=(const sivector_slice&); 01584 INLINE ivector_slice &operator-=(const srvector&); 01586 INLINE ivector_slice &operator-=(const sivector&); 01588 INLINE ivector_slice &operator-=(const srvector_slice&); 01590 INLINE ivector_slice &operator-=(const sivector_slice&); 01592 INLINE ivector_slice &operator|=(const srvector&); 01594 INLINE ivector_slice &operator|=(const sivector&); 01596 INLINE ivector_slice &operator|=(const srvector_slice&); 01598 INLINE ivector_slice &operator|=(const sivector_slice&); 01600 INLINE ivector_slice &operator&=(const sivector&); 01602 INLINE ivector_slice &operator&=(const sivector_slice&); 01603 01604 }; 01605 01606 //======================================================================= 01607 //======================== Vector Functions ============================= 01608 01610 INLINE ivector _ivector(const interval &r) throw(); 01611 // INLINE ivector _ivector(const imatrix &m) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01612 // INLINE ivector _ivector(const imatrix_slice &sl) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01614 INLINE ivector _ivector(const real &r) throw(); 01616 INLINE ivector _ivector(const rvector_slice &rs) throw(); 01618 INLINE ivector _ivector(const rvector &rs) throw(); 01619 // INLINE ivector _ivector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01620 // INLINE ivector _ivector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01622 INLINE ivector _ivector(const rmatrix_subv &rs) throw(); 01623 01625 INLINE ivector &SetInf(ivector &iv,const rvector &rv) 01626 #if(CXSC_INDEX_CHECK) 01627 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01628 #else 01629 throw(); 01630 #endif 01631 01632 INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector &rv) 01633 #if(CXSC_INDEX_CHECK) 01634 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01635 #else 01636 throw(); 01637 #endif 01638 01639 INLINE ivector &SetInf(ivector &iv,const rvector_slice &rv) 01640 #if(CXSC_INDEX_CHECK) 01641 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01642 #else 01643 throw(); 01644 #endif 01645 01646 INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector_slice &rv) 01647 #if(CXSC_INDEX_CHECK) 01648 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01649 #else 01650 throw(); 01651 #endif 01652 01653 INLINE ivector &UncheckedSetInf(ivector &iv,const rvector &rv) 01654 #if(CXSC_INDEX_CHECK) 01655 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01656 #else 01657 throw(); 01658 #endif 01659 01660 INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector &rv) 01661 #if(CXSC_INDEX_CHECK) 01662 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01663 #else 01664 throw(); 01665 #endif 01666 01667 INLINE ivector &UncheckedSetInf(ivector &iv,const rvector_slice &rv) 01668 #if(CXSC_INDEX_CHECK) 01669 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01670 #else 01671 throw(); 01672 #endif 01673 01674 INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector_slice &rv) 01675 #if(CXSC_INDEX_CHECK) 01676 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01677 #else 01678 throw(); 01679 #endif 01680 01682 INLINE ivector &SetSup(ivector &iv,const rvector &rv) 01683 #if(CXSC_INDEX_CHECK) 01684 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01685 #else 01686 throw(); 01687 #endif 01688 01689 INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector &rv) 01690 #if(CXSC_INDEX_CHECK) 01691 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01692 #else 01693 throw(); 01694 #endif 01695 01696 INLINE ivector &SetSup(ivector &iv,const rvector_slice &rv) 01697 #if(CXSC_INDEX_CHECK) 01698 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01699 #else 01700 throw(); 01701 #endif 01702 01703 INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector_slice &rv) 01704 #if(CXSC_INDEX_CHECK) 01705 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01706 #else 01707 throw(); 01708 #endif 01709 01710 INLINE ivector &UncheckedSetSup(ivector &iv,const rvector &rv) 01711 #if(CXSC_INDEX_CHECK) 01712 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01713 #else 01714 throw(); 01715 #endif 01716 01717 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector &rv) 01718 #if(CXSC_INDEX_CHECK) 01719 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01720 #else 01721 throw(); 01722 #endif 01723 01724 INLINE ivector &UncheckedSetSup(ivector &iv,const rvector_slice &rv) 01725 #if(CXSC_INDEX_CHECK) 01726 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01727 #else 01728 throw(); 01729 #endif 01730 01731 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector_slice &rv) 01732 #if(CXSC_INDEX_CHECK) 01733 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01734 #else 01735 throw(); 01736 #endif 01737 01739 INLINE ivector &SetSup(ivector &iv,const real &r) throw(); 01741 INLINE ivector &SetInf(ivector &iv,const real &r) throw(); 01743 INLINE ivector &UncheckedSetSup(ivector &iv,const real &r) throw(); 01745 INLINE ivector &SetUncheckedInf(ivector &iv,const real &r) throw(); 01747 INLINE ivector_slice &SetSup(ivector_slice &iv,const real &r) throw(); 01749 INLINE ivector_slice &SetInf(ivector_slice &iv,const real &r) throw(); 01751 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const real &r) throw(); 01753 INLINE ivector_slice &SetUncheckedInf(ivector_slice &iv,const real &r) throw(); 01754 01756 INLINE void Resize(ivector &rv) throw(); 01758 INLINE void Resize(ivector &rv, const int &len) 01759 #if(CXSC_INDEX_CHECK) 01760 throw(ERROR__WRONG_BOUNDARIES<ivector>); 01761 #else 01762 throw(); 01763 #endif 01764 01765 INLINE void Resize(ivector &rv, const int &lb, const int &ub) 01766 #if(CXSC_INDEX_CHECK) 01767 throw(ERROR__WRONG_BOUNDARIES<ivector>); 01768 #else 01769 throw(); 01770 #endif 01771 01773 INLINE ivector abs(const ivector &rv) throw(); 01775 INLINE ivector abs(const ivector_slice &sl) throw(); 01777 INLINE rvector absmin(const ivector &rv) throw(); 01779 INLINE rvector absmax(const ivector_slice &sl) throw(); 01781 INLINE rvector absmin(const ivector &rv) throw(); 01783 INLINE rvector absmax(const ivector_slice &sl) throw(); 01785 INLINE rvector diam(const ivector &v) throw(); 01787 INLINE rvector diam(const ivector_slice &v) throw(); 01789 INLINE rvector mid(const ivector &v) throw(); 01791 INLINE rvector mid(const ivector_slice &v) throw(); 01793 INLINE rvector Inf(const ivector &v) throw(); 01795 INLINE rvector Inf(const ivector_slice &v) throw(); 01797 INLINE rvector Sup(const ivector &v) throw(); 01799 INLINE rvector Sup(const ivector_slice &v) throw(); 01801 INLINE bool operator !(const ivector &rv) throw(); 01803 INLINE bool operator !(const ivector_slice &sl) throw(); 01804 01805 //======================= Vector / Scalar =============================== 01806 01807 //----------------------------- Interval --------------------------- 01808 01810 INLINE ivector operator *(const ivector &rv, const interval &s) throw(); 01812 INLINE ivector operator *(const ivector_slice &sl, const interval &s) throw(); 01814 INLINE ivector operator *(const interval &s, const ivector &rv) throw(); 01816 INLINE ivector operator *(const interval &s, const ivector_slice &sl) throw(); 01818 INLINE ivector &operator *=(ivector &rv,const interval &r) throw(); 01819 01821 INLINE ivector operator /(const ivector &rv, const interval &s) throw(); 01823 INLINE ivector operator /(const ivector_slice &sl, const interval &s) throw(); 01825 INLINE ivector &operator /=(ivector &rv,const interval &r) throw(); 01826 01827 //---------------------------- Real -------------------------------------- 01828 01830 INLINE ivector operator *(const ivector &rv, const real &s) throw(); 01832 INLINE ivector operator *(const ivector_slice &sl, const real &s) throw(); 01834 INLINE ivector operator *(const real &s, const ivector &rv) throw(); 01836 INLINE ivector operator *(const real &s, const ivector_slice &sl) throw(); 01838 INLINE ivector &operator *=(ivector &rv,const real &r) throw(); 01839 01841 INLINE ivector operator /(const ivector &rv, const real &s) throw(); 01843 INLINE ivector operator /(const ivector_slice &sl, const real &s) throw(); 01845 INLINE ivector &operator /=(ivector &rv,const real &r) throw(); 01846 01848 INLINE ivector operator *(const rvector &rv, const interval &s) throw(); 01850 INLINE ivector operator *(const rvector_slice &sl, const interval &s) throw(); 01852 INLINE ivector operator *(const interval &s, const rvector &rv) throw(); 01854 INLINE ivector operator *(const interval &s, const rvector_slice &sl) throw(); 01855 01857 INLINE ivector operator /(const rvector &rv, const interval &s) throw(); 01859 INLINE ivector operator /(const rvector_slice &sl, const interval &s) throw(); 01860 01861 //======================= Vector / Vector =============================== 01862 01863 01865 INLINE std::ostream &operator <<(std::ostream &s, const ivector &rv) throw(); 01867 INLINE std::ostream &operator <<(std::ostream &o, const ivector_slice &sl) throw(); 01869 INLINE std::istream &operator >>(std::istream &s, ivector &rv) throw(); 01871 INLINE std::istream &operator >>(std::istream &s, ivector_slice &rv) throw(); 01872 01873 //----------------------- Interval / Interval --------------------------- 01874 01876 void accumulate(idotprecision &dp, const ivector &); 01877 01879 void accumulate(idotprecision &dp, const rvector &); 01880 01882 void accumulate(idotprecision &dp, const ivector & rv1, const ivector &rv2) 01883 #if(CXSC_INDEX_CHECK) 01884 throw(OP_WITH_WRONG_DIM); 01885 #else 01886 throw(); 01887 #endif 01888 01889 void accumulate(idotprecision &dp, const ivector_slice & sl, const ivector &rv) 01890 #if(CXSC_INDEX_CHECK) 01891 throw(OP_WITH_WRONG_DIM); 01892 #else 01893 throw(); 01894 #endif 01895 01896 void accumulate(idotprecision &dp, const ivector &rv, const ivector_slice &sl) 01897 #if(CXSC_INDEX_CHECK) 01898 throw(OP_WITH_WRONG_DIM); 01899 #else 01900 throw(); 01901 #endif 01902 01903 void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2) 01904 #if(CXSC_INDEX_CHECK) 01905 throw(OP_WITH_WRONG_DIM); 01906 #else 01907 throw(); 01908 #endif 01909 01910 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2) 01911 #if(CXSC_INDEX_CHECK) 01912 throw(OP_WITH_WRONG_DIM); 01913 #else 01914 throw(); 01915 #endif 01916 01917 void accumulate(idotprecision &dp, const ivector_slice & rv1, const imatrix_subv &rv2) 01918 #if(CXSC_INDEX_CHECK) 01919 throw(OP_WITH_WRONG_DIM); 01920 #else 01921 throw(); 01922 #endif 01923 01924 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &rv2) 01925 #if(CXSC_INDEX_CHECK) 01926 throw(OP_WITH_WRONG_DIM); 01927 #else 01928 throw(); 01929 #endif 01930 01931 void accumulate(idotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2) 01932 #if(CXSC_INDEX_CHECK) 01933 throw(OP_WITH_WRONG_DIM); 01934 #else 01935 throw(); 01936 #endif 01937 01938 void accumulate(cidotprecision &dp, const ivector & rv1, const ivector &rv2) 01939 #if(CXSC_INDEX_CHECK) 01940 throw(OP_WITH_WRONG_DIM); 01941 #else 01942 throw(); 01943 #endif 01944 01945 void accumulate(cidotprecision &dp, const ivector_slice & sl, const ivector &rv) 01946 #if(CXSC_INDEX_CHECK) 01947 throw(OP_WITH_WRONG_DIM); 01948 #else 01949 throw(); 01950 #endif 01951 01952 void accumulate(cidotprecision &dp, const ivector &rv, const ivector_slice &sl) 01953 #if(CXSC_INDEX_CHECK) 01954 throw(OP_WITH_WRONG_DIM); 01955 #else 01956 throw(); 01957 #endif 01958 01959 void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2) 01960 #if(CXSC_INDEX_CHECK) 01961 throw(OP_WITH_WRONG_DIM); 01962 #else 01963 throw(); 01964 #endif 01965 01966 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2) 01967 #if(CXSC_INDEX_CHECK) 01968 throw(OP_WITH_WRONG_DIM); 01969 #else 01970 throw(); 01971 #endif 01972 01973 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2) 01974 #if(CXSC_INDEX_CHECK) 01975 throw(OP_WITH_WRONG_DIM); 01976 #else 01977 throw(); 01978 #endif 01979 01981 INLINE interval operator *(const ivector & rv1, const ivector &rv2) 01982 #if(CXSC_INDEX_CHECK) 01983 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01984 #else 01985 throw(); 01986 #endif 01987 01988 INLINE interval operator *(const ivector_slice &sl, const ivector &rv) 01989 #if(CXSC_INDEX_CHECK) 01990 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01991 #else 01992 throw(); 01993 #endif 01994 01995 INLINE interval operator *(const ivector &rv, const ivector_slice &sl) 01996 #if(CXSC_INDEX_CHECK) 01997 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 01998 #else 01999 throw(); 02000 #endif 02001 02002 INLINE interval operator *(const ivector_slice & sl1, const ivector_slice &sl2) 02003 #if(CXSC_INDEX_CHECK) 02004 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02005 #else 02006 throw(); 02007 #endif 02008 02010 INLINE const ivector &operator +(const ivector &rv) throw(); 02012 INLINE ivector operator +(const ivector_slice &sl) throw(); 02013 02015 INLINE ivector operator +(const ivector &rv1, const ivector &rv2) 02016 #if(CXSC_INDEX_CHECK) 02017 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02018 #else 02019 throw(); 02020 #endif 02021 02022 INLINE ivector operator +(const ivector &rv, const ivector_slice &sl) 02023 #if(CXSC_INDEX_CHECK) 02024 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02025 #else 02026 throw(); 02027 #endif 02028 02029 INLINE ivector operator +(const ivector_slice &sl, const ivector &rv) 02030 #if(CXSC_INDEX_CHECK) 02031 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02032 #else 02033 throw(); 02034 #endif 02035 02036 INLINE ivector operator +(const ivector_slice &sl1, const ivector_slice &sl2) 02037 #if(CXSC_INDEX_CHECK) 02038 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02039 #else 02040 throw(); 02041 #endif 02042 02043 INLINE ivector & operator +=(ivector &rv1, const ivector &rv2) 02044 #if(CXSC_INDEX_CHECK) 02045 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02046 #else 02047 throw(); 02048 #endif 02049 02050 INLINE ivector &operator +=(ivector &rv, const ivector_slice &sl) 02051 #if(CXSC_INDEX_CHECK) 02052 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02053 #else 02054 throw(); 02055 #endif 02056 02058 INLINE ivector operator -(const ivector &rv) throw(); 02060 INLINE ivector operator -(const ivector_slice &sl) throw(); 02062 INLINE ivector operator -(const ivector &rv1, const ivector &rv2) 02063 #if(CXSC_INDEX_CHECK) 02064 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02065 #else 02066 throw(); 02067 #endif 02068 02069 INLINE ivector operator -(const ivector &rv, const ivector_slice &sl) 02070 #if(CXSC_INDEX_CHECK) 02071 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02072 #else 02073 throw(); 02074 #endif 02075 02076 INLINE ivector operator -(const ivector_slice &sl, const ivector &rv) 02077 #if(CXSC_INDEX_CHECK) 02078 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02079 #else 02080 throw(); 02081 #endif 02082 02083 INLINE ivector operator -(const ivector_slice &sl1, const ivector_slice &sl2) 02084 #if(CXSC_INDEX_CHECK) 02085 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02086 #else 02087 throw(); 02088 #endif 02089 02090 INLINE ivector & operator -=(ivector &rv1, const ivector &rv2) 02091 #if(CXSC_INDEX_CHECK) 02092 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02093 #else 02094 throw(); 02095 #endif 02096 02097 INLINE ivector &operator -=(ivector &rv, const ivector_slice &sl) 02098 #if(CXSC_INDEX_CHECK) 02099 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02100 #else 02101 throw(); 02102 #endif 02103 02105 INLINE ivector operator |(const ivector &rv1, const ivector &rv2) 02106 #if(CXSC_INDEX_CHECK) 02107 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02108 #else 02109 throw(); 02110 #endif 02111 02112 INLINE ivector operator |(const ivector &rv, const ivector_slice &sl) 02113 #if(CXSC_INDEX_CHECK) 02114 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02115 #else 02116 throw(); 02117 #endif 02118 02119 INLINE ivector operator |(const ivector_slice &sl, const ivector &rv) 02120 #if(CXSC_INDEX_CHECK) 02121 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02122 #else 02123 throw(); 02124 #endif 02125 02126 INLINE ivector operator |(const ivector_slice &sl1, const ivector_slice &sl2) 02127 #if(CXSC_INDEX_CHECK) 02128 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02129 #else 02130 throw(); 02131 #endif 02132 02133 INLINE ivector & operator |=(ivector &rv1, const ivector &rv2) 02134 #if(CXSC_INDEX_CHECK) 02135 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02136 #else 02137 throw(); 02138 #endif 02139 02140 INLINE ivector &operator |=(ivector &rv, const ivector_slice &sl) 02141 #if(CXSC_INDEX_CHECK) 02142 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02143 #else 02144 throw(); 02145 #endif 02146 02148 INLINE ivector operator &(const ivector &rv1, const ivector &rv2) 02149 #if(CXSC_INDEX_CHECK) 02150 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02151 #else 02152 throw(); 02153 #endif 02154 02155 INLINE ivector operator &(const ivector &rv, const ivector_slice &sl) 02156 #if(CXSC_INDEX_CHECK) 02157 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02158 #else 02159 throw(); 02160 #endif 02161 02162 INLINE ivector operator &(const ivector_slice &sl, const ivector &rv) 02163 #if(CXSC_INDEX_CHECK) 02164 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02165 #else 02166 throw(); 02167 #endif 02168 02169 INLINE ivector operator &(const ivector_slice &sl1, const ivector_slice &sl2) 02170 #if(CXSC_INDEX_CHECK) 02171 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02172 #else 02173 throw(); 02174 #endif 02175 02176 INLINE ivector & operator &=(ivector &rv1, const ivector &rv2) 02177 #if(CXSC_INDEX_CHECK) 02178 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02179 #else 02180 throw(); 02181 #endif 02182 02183 INLINE ivector &operator &=(ivector &rv, const ivector_slice &sl) 02184 #if(CXSC_INDEX_CHECK) 02185 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02186 #else 02187 throw(); 02188 #endif 02189 02191 INLINE bool operator ==(const ivector &rv1, const ivector &rv2) throw(); 02193 INLINE bool operator ==(const ivector_slice &sl1, const ivector_slice &sl2) throw(); 02195 INLINE bool operator ==(const ivector_slice &sl, const ivector &rv) throw(); 02197 INLINE bool operator ==(const ivector &rv, const ivector_slice &sl) throw(); 02199 INLINE bool operator !=(const ivector &rv1, const ivector &rv2) throw(); 02201 INLINE bool operator !=(const ivector_slice &sl1, const ivector_slice &sl2) throw(); 02203 INLINE bool operator !=(const ivector_slice &sl, const ivector &rv) throw(); 02205 INLINE bool operator !=(const ivector &rv, const ivector_slice &sl) throw(); 02207 INLINE bool operator <(const ivector &rv1, const ivector &rv2) throw(); 02209 INLINE bool operator <(const ivector_slice &sl1, const ivector_slice &sl2) throw(); 02211 INLINE bool operator < (const ivector_slice &sl, const ivector &rv) throw(); 02213 INLINE bool operator < (const ivector &rv, const ivector_slice &sl) throw(); 02215 INLINE bool operator <=(const ivector &rv1, const ivector &rv2) throw(); 02217 INLINE bool operator <=(const ivector_slice &sl1, const ivector_slice &sl2) throw(); 02219 INLINE bool operator <=(const ivector_slice &sl, const ivector &rv) throw(); 02221 INLINE bool operator <=(const ivector &rv, const ivector_slice &sl) throw(); 02223 INLINE bool operator >(const ivector &rv1, const ivector &rv2) throw(); 02225 INLINE bool operator >(const ivector_slice &sl1, const ivector_slice &sl2) throw(); 02227 INLINE bool operator >(const ivector_slice &sl, const ivector &rv) throw(); 02229 INLINE bool operator >(const ivector &rv, const ivector_slice &sl) throw(); 02231 INLINE bool operator >=(const ivector &rv1, const ivector &rv2) throw(); 02233 INLINE bool operator >=(const ivector_slice &sl1, const ivector_slice &sl2) throw(); 02235 INLINE bool operator >=(const ivector_slice &sl, const ivector &rv) throw(); 02237 INLINE bool operator >=(const ivector &rv, const ivector_slice &sl) throw(); 02238 02239 //-------------------------------- Interval / Real -------------------------------- 02240 02242 void accumulate(idotprecision &dp, const rvector & rv1, const ivector &rv2) 02243 #if(CXSC_INDEX_CHECK) 02244 throw(OP_WITH_WRONG_DIM); 02245 #else 02246 throw(); 02247 #endif 02248 02249 void accumulate(idotprecision &dp, const ivector & rv1, const rvector &rv2) 02250 #if(CXSC_INDEX_CHECK) 02251 throw(OP_WITH_WRONG_DIM); 02252 #else 02253 throw(); 02254 #endif 02255 02256 void accumulate(idotprecision &dp, const rvector_slice & sl, const ivector &rv) 02257 #if(CXSC_INDEX_CHECK) 02258 throw(OP_WITH_WRONG_DIM); 02259 #else 02260 throw(); 02261 #endif 02262 02263 void accumulate(idotprecision &dp,const ivector_slice &sl,const rvector &rv) 02264 #if(CXSC_INDEX_CHECK) 02265 throw(OP_WITH_WRONG_DIM); 02266 #else 02267 throw(); 02268 #endif 02269 02270 void accumulate(idotprecision &dp, const rvector &rv, const ivector_slice &sl) 02271 #if(CXSC_INDEX_CHECK) 02272 throw(OP_WITH_WRONG_DIM); 02273 #else 02274 throw(); 02275 #endif 02276 02277 void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2) 02278 #if(CXSC_INDEX_CHECK) 02279 throw(OP_WITH_WRONG_DIM); 02280 #else 02281 throw(); 02282 #endif 02283 02284 void accumulate(idotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2) 02285 #if(CXSC_INDEX_CHECK) 02286 throw(OP_WITH_WRONG_DIM); 02287 #else 02288 throw(); 02289 #endif 02290 02291 void accumulate(idotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2) 02292 #if(CXSC_INDEX_CHECK) 02293 throw(OP_WITH_WRONG_DIM); 02294 #else 02295 throw(); 02296 #endif 02297 02298 void accumulate(idotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2) 02299 #if(CXSC_INDEX_CHECK) 02300 throw(OP_WITH_WRONG_DIM); 02301 #else 02302 throw(); 02303 #endif 02304 02305 void accumulate(idotprecision &dp,const ivector &rv,const rvector_slice &sl) 02306 #if(CXSC_INDEX_CHECK) 02307 throw(OP_WITH_WRONG_DIM); 02308 #else 02309 throw(); 02310 #endif 02311 02312 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2) 02313 #if(CXSC_INDEX_CHECK) 02314 throw(OP_WITH_WRONG_DIM); 02315 #else 02316 throw(); 02317 #endif 02318 02319 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2) 02320 #if(CXSC_INDEX_CHECK) 02321 throw(OP_WITH_WRONG_DIM); 02322 #else 02323 throw(); 02324 #endif 02325 02326 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2) 02327 #if(CXSC_INDEX_CHECK) 02328 throw(OP_WITH_WRONG_DIM); 02329 #else 02330 throw(); 02331 #endif 02332 02333 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2) 02334 #if(CXSC_INDEX_CHECK) 02335 throw(OP_WITH_WRONG_DIM); 02336 #else 02337 throw(); 02338 #endif 02339 02340 void accumulate(idotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2) 02341 #if(CXSC_INDEX_CHECK) 02342 throw(OP_WITH_WRONG_DIM); 02343 #else 02344 throw(); 02345 #endif 02346 02347 void accumulate(idotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2) 02348 #if(CXSC_INDEX_CHECK) 02349 throw(OP_WITH_WRONG_DIM); 02350 #else 02351 throw(); 02352 #endif 02353 02354 void accumulate(cidotprecision &dp, const rvector & rv1, const ivector &rv2) 02355 #if(CXSC_INDEX_CHECK) 02356 throw(OP_WITH_WRONG_DIM); 02357 #else 02358 throw(); 02359 #endif 02360 02361 void accumulate(cidotprecision &dp, const ivector & rv1, const rvector &rv2) 02362 #if(CXSC_INDEX_CHECK) 02363 throw(OP_WITH_WRONG_DIM); 02364 #else 02365 throw(); 02366 #endif 02367 02368 void accumulate(cidotprecision &dp, const rvector_slice & sl, const ivector &rv) 02369 #if(CXSC_INDEX_CHECK) 02370 throw(OP_WITH_WRONG_DIM); 02371 #else 02372 throw(); 02373 #endif 02374 02375 void accumulate(cidotprecision &dp,const ivector_slice &sl,const rvector &rv) 02376 #if(CXSC_INDEX_CHECK) 02377 throw(OP_WITH_WRONG_DIM); 02378 #else 02379 throw(); 02380 #endif 02381 02382 void accumulate(cidotprecision &dp, const rvector &rv, const ivector_slice &sl) 02383 #if(CXSC_INDEX_CHECK) 02384 throw(OP_WITH_WRONG_DIM); 02385 #else 02386 throw(); 02387 #endif 02388 02389 void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2) 02390 #if(CXSC_INDEX_CHECK) 02391 throw(OP_WITH_WRONG_DIM); 02392 #else 02393 throw(); 02394 #endif 02395 02396 void accumulate(cidotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2) 02397 #if(CXSC_INDEX_CHECK) 02398 throw(OP_WITH_WRONG_DIM); 02399 #else 02400 throw(); 02401 #endif 02402 02403 void accumulate(cidotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2) 02404 #if(CXSC_INDEX_CHECK) 02405 throw(OP_WITH_WRONG_DIM); 02406 #else 02407 throw(); 02408 #endif 02409 02410 void accumulate(cidotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2) 02411 #if(CXSC_INDEX_CHECK) 02412 throw(OP_WITH_WRONG_DIM); 02413 #else 02414 throw(); 02415 #endif 02416 02417 void accumulate(cidotprecision &dp,const ivector &rv,const rvector_slice &sl) 02418 #if(CXSC_INDEX_CHECK) 02419 throw(OP_WITH_WRONG_DIM); 02420 #else 02421 throw(); 02422 #endif 02423 02424 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2) 02425 #if(CXSC_INDEX_CHECK) 02426 throw(OP_WITH_WRONG_DIM); 02427 #else 02428 throw(); 02429 #endif 02430 02431 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2) 02432 #if(CXSC_INDEX_CHECK) 02433 throw(OP_WITH_WRONG_DIM); 02434 #else 02435 throw(); 02436 #endif 02437 02438 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2) 02439 #if(CXSC_INDEX_CHECK) 02440 throw(OP_WITH_WRONG_DIM); 02441 #else 02442 throw(); 02443 #endif 02444 02445 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2) 02446 #if(CXSC_INDEX_CHECK) 02447 throw(OP_WITH_WRONG_DIM); 02448 #else 02449 throw(); 02450 #endif 02451 02452 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2) 02453 #if(CXSC_INDEX_CHECK) 02454 throw(OP_WITH_WRONG_DIM); 02455 #else 02456 throw(); 02457 #endif 02458 02459 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2) 02460 #if(CXSC_INDEX_CHECK) 02461 throw(OP_WITH_WRONG_DIM); 02462 #else 02463 throw(); 02464 #endif 02465 02467 INLINE interval operator *(const rvector & rv1, const ivector &rv2) 02468 #if(CXSC_INDEX_CHECK) 02469 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02470 #else 02471 throw(); 02472 #endif 02473 02474 INLINE interval operator *(const rvector_slice &sl, const ivector &rv) 02475 #if(CXSC_INDEX_CHECK) 02476 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02477 #else 02478 throw(); 02479 #endif 02480 02481 INLINE interval operator *(const rvector &rv, const ivector_slice &sl) 02482 #if(CXSC_INDEX_CHECK) 02483 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02484 #else 02485 throw(); 02486 #endif 02487 02488 INLINE interval operator *(const rvector_slice & sl1, const ivector_slice &sl2) 02489 #if(CXSC_INDEX_CHECK) 02490 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02491 #else 02492 throw(); 02493 #endif 02494 02496 INLINE interval operator *(const ivector & rv1, const rvector &rv2) 02497 #if(CXSC_INDEX_CHECK) 02498 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02499 #else 02500 throw(); 02501 #endif 02502 02503 INLINE interval operator *(const ivector_slice &sl, const rvector &rv) 02504 #if(CXSC_INDEX_CHECK) 02505 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02506 #else 02507 throw(); 02508 #endif 02509 02510 INLINE interval operator *(const ivector &rv, const rvector_slice &sl) 02511 #if(CXSC_INDEX_CHECK) 02512 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02513 #else 02514 throw(); 02515 #endif 02516 02517 INLINE interval operator *(const ivector_slice & sl1, const rvector_slice &sl2) 02518 #if(CXSC_INDEX_CHECK) 02519 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02520 #else 02521 throw(); 02522 #endif 02523 02525 INLINE ivector operator +(const rvector &rv1, const ivector &rv2) 02526 #if(CXSC_INDEX_CHECK) 02527 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02528 #else 02529 throw(); 02530 #endif 02531 02532 INLINE ivector operator +(const rvector &rv, const ivector_slice &sl) 02533 #if(CXSC_INDEX_CHECK) 02534 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02535 #else 02536 throw(); 02537 #endif 02538 02539 INLINE ivector operator +(const rvector_slice &sl, const ivector &rv) 02540 #if(CXSC_INDEX_CHECK) 02541 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02542 #else 02543 throw(); 02544 #endif 02545 02546 INLINE ivector operator +(const rvector_slice &sl1, const ivector_slice &sl2) 02547 #if(CXSC_INDEX_CHECK) 02548 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02549 #else 02550 throw(); 02551 #endif 02552 02554 INLINE ivector operator +(const ivector &rv1, const rvector &rv2) 02555 #if(CXSC_INDEX_CHECK) 02556 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02557 #else 02558 throw(); 02559 #endif 02560 02561 INLINE ivector operator +(const ivector &rv, const rvector_slice &sl) 02562 #if(CXSC_INDEX_CHECK) 02563 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02564 #else 02565 throw(); 02566 #endif 02567 02568 INLINE ivector operator +(const ivector_slice &sl, const rvector &rv) 02569 #if(CXSC_INDEX_CHECK) 02570 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02571 #else 02572 throw(); 02573 #endif 02574 02575 INLINE ivector operator +(const ivector_slice &sl1, const rvector_slice &sl2) 02576 #if(CXSC_INDEX_CHECK) 02577 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02578 #else 02579 throw(); 02580 #endif 02581 02583 INLINE ivector & operator +=(ivector &rv1, const rvector &rv2) 02584 #if(CXSC_INDEX_CHECK) 02585 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02586 #else 02587 throw(); 02588 #endif 02589 02590 INLINE ivector &operator +=(ivector &rv, const rvector_slice &sl) 02591 #if(CXSC_INDEX_CHECK) 02592 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02593 #else 02594 throw(); 02595 #endif 02596 02598 INLINE ivector operator -(const rvector &rv1, const ivector &rv2) 02599 #if(CXSC_INDEX_CHECK) 02600 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02601 #else 02602 throw(); 02603 #endif 02604 02605 INLINE ivector operator -(const rvector &rv, const ivector_slice &sl) 02606 #if(CXSC_INDEX_CHECK) 02607 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02608 #else 02609 throw(); 02610 #endif 02611 02612 INLINE ivector operator -(const rvector_slice &sl, const ivector &rv) 02613 #if(CXSC_INDEX_CHECK) 02614 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02615 #else 02616 throw(); 02617 #endif 02618 02619 INLINE ivector operator -(const rvector_slice &sl1, const ivector_slice &sl2) 02620 #if(CXSC_INDEX_CHECK) 02621 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02622 #else 02623 throw(); 02624 #endif 02625 02627 INLINE ivector operator -(const ivector &rv1, const rvector &rv2) 02628 #if(CXSC_INDEX_CHECK) 02629 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02630 #else 02631 throw(); 02632 #endif 02633 02634 INLINE ivector operator -(const ivector &rv, const rvector_slice &sl) 02635 #if(CXSC_INDEX_CHECK) 02636 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02637 #else 02638 throw(); 02639 #endif 02640 02641 INLINE ivector operator -(const ivector_slice &sl, const rvector &rv) 02642 #if(CXSC_INDEX_CHECK) 02643 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02644 #else 02645 throw(); 02646 #endif 02647 02648 INLINE ivector operator -(const ivector_slice &sl1, const rvector_slice &sl2) 02649 #if(CXSC_INDEX_CHECK) 02650 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02651 #else 02652 throw(); 02653 #endif 02654 02656 INLINE ivector & operator -=(ivector &rv1, const rvector &rv2) 02657 #if(CXSC_INDEX_CHECK) 02658 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02659 #else 02660 throw(); 02661 #endif 02662 02663 INLINE ivector &operator -=(ivector &rv, const rvector_slice &sl) 02664 #if(CXSC_INDEX_CHECK) 02665 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02666 #else 02667 throw(); 02668 #endif 02669 02671 INLINE ivector operator |(const rvector &rv1, const rvector &rv2) 02672 #if(CXSC_INDEX_CHECK) 02673 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 02674 #else 02675 throw(); 02676 #endif 02677 02678 INLINE ivector operator |(const rvector &rv, const rvector_slice &sl) 02679 #if(CXSC_INDEX_CHECK) 02680 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 02681 #else 02682 throw(); 02683 #endif 02684 02685 INLINE ivector operator |(const rvector_slice &sl, const rvector &rv) 02686 #if(CXSC_INDEX_CHECK) 02687 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 02688 #else 02689 throw(); 02690 #endif 02691 02692 INLINE ivector operator |(const rvector_slice &sl1, const rvector_slice &sl2) 02693 #if(CXSC_INDEX_CHECK) 02694 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 02695 #else 02696 throw(); 02697 #endif 02698 02699 INLINE ivector operator |(const rvector &rv1, const ivector &rv2) 02700 #if(CXSC_INDEX_CHECK) 02701 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02702 #else 02703 throw(); 02704 #endif 02705 02706 INLINE ivector operator |(const rvector &rv, const ivector_slice &sl) 02707 #if(CXSC_INDEX_CHECK) 02708 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02709 #else 02710 throw(); 02711 #endif 02712 02713 INLINE ivector operator |(const rvector_slice &sl, const ivector &rv) 02714 #if(CXSC_INDEX_CHECK) 02715 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02716 #else 02717 throw(); 02718 #endif 02719 02720 INLINE ivector operator |(const rvector_slice &sl1, const ivector_slice &sl2) 02721 #if(CXSC_INDEX_CHECK) 02722 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02723 #else 02724 throw(); 02725 #endif 02726 02728 INLINE ivector operator |(const ivector &rv1, const rvector &rv2) 02729 #if(CXSC_INDEX_CHECK) 02730 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02731 #else 02732 throw(); 02733 #endif 02734 02735 INLINE ivector operator |(const ivector &rv, const rvector_slice &sl) 02736 #if(CXSC_INDEX_CHECK) 02737 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02738 #else 02739 throw(); 02740 #endif 02741 02742 INLINE ivector operator |(const ivector_slice &sl, const rvector &rv) 02743 #if(CXSC_INDEX_CHECK) 02744 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02745 #else 02746 throw(); 02747 #endif 02748 02749 INLINE ivector operator |(const ivector_slice &sl1, const rvector_slice &sl2) 02750 #if(CXSC_INDEX_CHECK) 02751 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02752 #else 02753 throw(); 02754 #endif 02755 02757 INLINE ivector & operator |=(ivector &rv1, const rvector &rv2) 02758 #if(CXSC_INDEX_CHECK) 02759 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02760 #else 02761 throw(); 02762 #endif 02763 02764 INLINE ivector &operator |=(ivector &rv, const rvector_slice &sl) 02765 #if(CXSC_INDEX_CHECK) 02766 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02767 #else 02768 throw(); 02769 #endif 02770 02772 INLINE ivector operator &(const rvector &rv1, const ivector &rv2) 02773 #if(CXSC_INDEX_CHECK) 02774 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02775 #else 02776 throw(); 02777 #endif 02778 02779 INLINE ivector operator &(const rvector &rv, const ivector_slice &sl) 02780 #if(CXSC_INDEX_CHECK) 02781 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02782 #else 02783 throw(); 02784 #endif 02785 02786 INLINE ivector operator &(const rvector_slice &sl, const ivector &rv) 02787 #if(CXSC_INDEX_CHECK) 02788 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02789 #else 02790 throw(); 02791 #endif 02792 02793 INLINE ivector operator &(const rvector_slice &sl1, const ivector_slice &sl2) 02794 #if(CXSC_INDEX_CHECK) 02795 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02796 #else 02797 throw(); 02798 #endif 02799 02801 INLINE ivector operator &(const ivector &rv1, const rvector &rv2) 02802 #if(CXSC_INDEX_CHECK) 02803 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02804 #else 02805 throw(); 02806 #endif 02807 02808 INLINE ivector operator &(const ivector &rv, const rvector_slice &sl) 02809 #if(CXSC_INDEX_CHECK) 02810 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02811 #else 02812 throw(); 02813 #endif 02814 02815 INLINE ivector operator &(const ivector_slice &sl, const rvector &rv) 02816 #if(CXSC_INDEX_CHECK) 02817 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02818 #else 02819 throw(); 02820 #endif 02821 02822 INLINE ivector operator &(const ivector_slice &sl1, const rvector_slice &sl2) 02823 #if(CXSC_INDEX_CHECK) 02824 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02825 #else 02826 throw(); 02827 #endif 02828 02830 INLINE ivector & operator &=(ivector &rv1, const rvector &rv2) 02831 #if(CXSC_INDEX_CHECK) 02832 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02833 #else 02834 throw(); 02835 #endif 02836 02837 INLINE ivector &operator &=(ivector &rv, const rvector_slice &sl) 02838 #if(CXSC_INDEX_CHECK) 02839 throw(ERROR__OP_WITH_WRONG_DIM<ivector>); 02840 #else 02841 throw(); 02842 #endif 02843 02845 extern int in ( const ivector&, const ivector& ); 02847 extern int in ( int, ivector& ); 02849 extern ivector Blow ( const ivector&, real ); 02851 extern int Disjoint ( ivector&, ivector& ); 02853 extern int Zero ( ivector& ); 02855 extern rvector mid ( ivector& ); 02857 extern real MaxRelDiam ( const ivector& ); 02859 extern real MaxRelDiam ( const ivector_slice& ); 02861 extern int UlpAcc ( ivector&, int ); 02863 extern void DoubleSize ( ivector& ); 02864 02865 02866 } // namespace cxsc 02867 02868 #ifdef _CXSC_INCL_INL 02869 #include "vector.inl" 02870 #include "ivector.inl" 02871 #endif 02872 02873 #ifdef _CXSC_RMATRIX_HPP_INCLUDED 02874 # ifdef _CXSC_INCL_INL 02875 # include "ivecrmat.inl" 02876 # else 02877 # include "ivecrmat.hpp" 02878 # endif 02879 #endif 02880 02881 #ifdef _CXSC_CMATRIX_HPP_INCLUDED 02882 # ifdef _CXSC_INCL_INL 02883 # include "iveccmat.inl" 02884 # else 02885 # include "iveccmat.hpp" 02886 # endif 02887 #endif 02888 02889 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED 02890 # ifdef _CXSC_INCL_INL 02891 # include "iveclrmat.inl" 02892 # else 02893 # include "iveclrmat.hpp" 02894 # endif 02895 #endif 02896 02897 #ifdef _CXSC_CVECTOR_HPP_INCLUDED 02898 # ifdef _CXSC_INCL_INL 02899 # include "iveccvec.inl" 02900 # else 02901 # include "iveccvec.hpp" 02902 # endif 02903 #endif 02904 02905 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED 02906 # ifdef _CXSC_INCL_INL 02907 # include "lrvecivec.inl" 02908 # else 02909 # include "lrvecivec.hpp" 02910 # endif 02911 #endif 02912 02913 #ifdef CXSC_USE_BLAS 02914 #define _CXSC_BLAS_IVECTOR 02915 #include "cxsc_blas.inl" 02916 #endif 02917 02918 #endif
1.7.5.1