00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
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"
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
00069 #ifdef _CXSC_FRIEND_TPL
00070
00071
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
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
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
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
00578
00579
00580
00581
00582
00583
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
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
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
00668
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
00677
00678
00679
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
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
00721
00722
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
00730
00731 #endif
00732
00733
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();
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
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
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
00805 explicit ivector(const rmatrix_subv &) throw();
00806
00807
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
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
00897 INLINE ~ivector() { delete [] dat; }
00898
00899
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
00952
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
00977 #ifdef _CXSC_FRIEND_TPL
00978
00979
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
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
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
01273
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
01282
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
01292
01293
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
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
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
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
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
01573
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
01608
01610 INLINE ivector _ivector(const interval &r) throw();
01611
01612
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
01620
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
01806
01807
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
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
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
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
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 }
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
