- 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: l_ivector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_LIVECTOR_HPP_INCLUDED 00027 #define _CXSC_LIVECTOR_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "except.hpp" 00031 #include "idot.hpp" 00032 #include "l_interval.hpp" // used for declaration of Inf, Sup,... 00033 //#include "cxscmatr.hpp" 00034 #include "rvector.hpp" 00035 #include "ivector.hpp" 00036 #include "l_rvector.hpp" 00037 #include "vector.hpp" 00038 00039 00040 #include <iostream> 00041 00042 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9 00043 00044 namespace cxsc { 00045 00046 class l_ivector_slice; 00047 00049 00054 class l_ivector 00055 { 00056 friend class l_ivector_slice; 00057 friend class l_imatrix; 00058 friend class l_imatrix_subv; 00059 private: 00060 l_interval *dat; 00061 int l,u,size; 00062 00063 public: 00064 //#if(CXSC_INDEX_CHECK) 00065 #ifdef _CXSC_FRIEND_TPL 00066 //------------ Templates -------------------------------------------------- 00067 // l_interval 00068 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 00069 #if(CXSC_INDEX_CHECK) 00070 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 00071 #else 00072 throw(); 00073 #endif 00074 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00075 #if(CXSC_INDEX_CHECK) 00076 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00077 #else 00078 throw(); 00079 #endif 00080 template <class V> friend void _vresize(V &rv) throw(); 00081 template <class V,class S> friend void _vresize(V &rv, const int &len) 00082 #if(CXSC_INDEX_CHECK) 00083 throw(ERROR__WRONG_BOUNDARIES<V>); 00084 #else 00085 throw(); 00086 #endif 00087 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub) 00088 #if(CXSC_INDEX_CHECK) 00089 throw(ERROR__WRONG_BOUNDARIES<V>); 00090 #else 00091 throw(); 00092 #endif 00093 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 00094 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 00095 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00096 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00097 #if(CXSC_INDEX_CHECK) 00098 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00099 #else 00100 throw(); 00101 #endif 00102 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00103 #if(CXSC_INDEX_CHECK) 00104 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00105 #else 00106 throw(); 00107 #endif 00108 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00109 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2) 00110 #if(CXSC_INDEX_CHECK) 00111 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00112 #else 00113 throw(); 00114 #endif 00115 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2) 00116 #if(CXSC_INDEX_CHECK) 00117 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00118 #else 00119 throw(); 00120 #endif 00121 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl) 00122 #if(CXSC_INDEX_CHECK) 00123 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00124 #else 00125 throw(); 00126 #endif 00127 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl) 00128 #if(CXSC_INDEX_CHECK) 00129 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00130 #else 00131 throw(); 00132 #endif 00133 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v) 00134 #if(CXSC_INDEX_CHECK) 00135 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00136 #else 00137 throw(); 00138 #endif 00139 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v) 00140 #if(CXSC_INDEX_CHECK) 00141 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00142 #else 00143 throw(); 00144 #endif 00145 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2) 00146 #if(CXSC_INDEX_CHECK) 00147 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00148 #else 00149 throw(); 00150 #endif 00151 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2) 00152 #if(CXSC_INDEX_CHECK) 00153 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00154 #else 00155 throw(); 00156 #endif 00157 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl) 00158 #if(CXSC_INDEX_CHECK) 00159 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00160 #else 00161 throw(); 00162 #endif 00163 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl) 00164 #if(CXSC_INDEX_CHECK) 00165 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00166 #else 00167 throw(); 00168 #endif 00169 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v) 00170 #if(CXSC_INDEX_CHECK) 00171 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00172 #else 00173 throw(); 00174 #endif 00175 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v) 00176 #if(CXSC_INDEX_CHECK) 00177 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00178 #else 00179 throw(); 00180 #endif 00181 template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw(); 00182 template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw(); 00183 template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw(); 00184 template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw(); 00185 template <class V,class E> friend E _vabs(const V &rv) throw(); 00186 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00187 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00188 template <class V,class E> friend E _vdiam(const V &rv) throw(); 00189 template <class V,class E> friend E _vmid(const V &rv) throw(); 00190 template <class V,class E> friend E _vinf(const V &rv) throw(); 00191 template <class V,class E> friend E _vsup(const V &rv) throw(); 00192 00193 //-------- vector-vector ----------------------- 00194 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 00195 #if(CXSC_INDEX_CHECK) 00196 throw(OP_WITH_WRONG_DIM); 00197 #else 00198 throw(); 00199 #endif 00200 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00201 #if(CXSC_INDEX_CHECK) 00202 throw(OP_WITH_WRONG_DIM); 00203 #else 00204 throw(); 00205 #endif 00206 00207 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2) 00208 #if(CXSC_INDEX_CHECK) 00209 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00210 #else 00211 throw(); 00212 #endif 00213 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 00214 #if(CXSC_INDEX_CHECK) 00215 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00216 #else 00217 throw(); 00218 #endif 00219 00220 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 00221 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 00222 #if(CXSC_INDEX_CHECK) 00223 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00224 #else 00225 throw(); 00226 #endif 00227 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00228 #if(CXSC_INDEX_CHECK) 00229 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00230 #else 00231 throw(); 00232 #endif 00233 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00234 #if(CXSC_INDEX_CHECK) 00235 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00236 #else 00237 throw(); 00238 #endif 00239 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00240 #if(CXSC_INDEX_CHECK) 00241 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00242 #else 00243 throw(); 00244 #endif 00245 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 00246 #if(CXSC_INDEX_CHECK) 00247 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00248 #else 00249 throw(); 00250 #endif 00251 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 00252 #if(CXSC_INDEX_CHECK) 00253 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00254 #else 00255 throw(); 00256 #endif 00257 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 00258 #if(CXSC_INDEX_CHECK) 00259 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00260 #else 00261 throw(); 00262 #endif 00263 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00264 #if(CXSC_INDEX_CHECK) 00265 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00266 #else 00267 throw(); 00268 #endif 00269 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00270 #if(CXSC_INDEX_CHECK) 00271 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00272 #else 00273 throw(); 00274 #endif 00275 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 00276 #if(CXSC_INDEX_CHECK) 00277 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00278 #else 00279 throw(); 00280 #endif 00281 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 00282 #if(CXSC_INDEX_CHECK) 00283 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00284 #else 00285 throw(); 00286 #endif 00287 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 00288 #if(CXSC_INDEX_CHECK) 00289 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00290 #else 00291 throw(); 00292 #endif 00293 template <class V> friend V _vminus(const V &rv) throw(); 00294 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 00295 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 00296 #if(CXSC_INDEX_CHECK) 00297 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00298 #else 00299 throw(); 00300 #endif 00301 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 00302 #if(CXSC_INDEX_CHECK) 00303 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00304 #else 00305 throw(); 00306 #endif 00307 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 00308 #if(CXSC_INDEX_CHECK) 00309 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00310 #else 00311 throw(); 00312 #endif 00313 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 00314 #if(CXSC_INDEX_CHECK) 00315 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00316 #else 00317 throw(); 00318 #endif 00319 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 00320 #if(CXSC_INDEX_CHECK) 00321 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00322 #else 00323 throw(); 00324 #endif 00325 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 00326 #if(CXSC_INDEX_CHECK) 00327 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00328 #else 00329 throw(); 00330 #endif 00331 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 00332 #if(CXSC_INDEX_CHECK) 00333 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00334 #else 00335 throw(); 00336 #endif 00337 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 00338 #if(CXSC_INDEX_CHECK) 00339 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00340 #else 00341 throw(); 00342 #endif 00343 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 00344 #if(CXSC_INDEX_CHECK) 00345 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00346 #else 00347 throw(); 00348 #endif 00349 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 00350 #if(CXSC_INDEX_CHECK) 00351 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00352 #else 00353 throw(); 00354 #endif 00355 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 00356 #if(CXSC_INDEX_CHECK) 00357 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00358 #else 00359 throw(); 00360 #endif 00361 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 00362 #if(CXSC_INDEX_CHECK) 00363 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00364 #else 00365 throw(); 00366 #endif 00367 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 00368 #if(CXSC_INDEX_CHECK) 00369 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00370 #else 00371 throw(); 00372 #endif 00373 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 00374 #if(CXSC_INDEX_CHECK) 00375 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00376 #else 00377 throw(); 00378 #endif 00379 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 00380 #if(CXSC_INDEX_CHECK) 00381 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00382 #else 00383 throw(); 00384 #endif 00385 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 00386 #if(CXSC_INDEX_CHECK) 00387 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00388 #else 00389 throw(); 00390 #endif 00391 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 00392 #if(CXSC_INDEX_CHECK) 00393 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00394 #else 00395 throw(); 00396 #endif 00397 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2) 00398 #if(CXSC_INDEX_CHECK) 00399 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00400 #else 00401 throw(); 00402 #endif 00403 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2) 00404 #if(CXSC_INDEX_CHECK) 00405 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00406 #else 00407 throw(); 00408 #endif 00409 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv) 00410 #if(CXSC_INDEX_CHECK) 00411 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00412 #else 00413 throw(); 00414 #endif 00415 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v) 00416 #if(CXSC_INDEX_CHECK) 00417 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00418 #else 00419 throw(); 00420 #endif 00421 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2) 00422 #if(CXSC_INDEX_CHECK) 00423 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00424 #else 00425 throw(); 00426 #endif 00427 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2) 00428 #if(CXSC_INDEX_CHECK) 00429 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00430 #else 00431 throw(); 00432 #endif 00433 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv) 00434 #if(CXSC_INDEX_CHECK) 00435 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00436 #else 00437 throw(); 00438 #endif 00439 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v) 00440 #if(CXSC_INDEX_CHECK) 00441 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00442 #else 00443 throw(); 00444 #endif 00445 template <class V,class MV,class S> friend S _vmvlimult(const V &rv1, const MV &rv2) 00446 #if(CXSC_INDEX_CHECK) 00447 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00448 #else 00449 throw(); 00450 #endif 00451 //--------- vector-scalar ----------------- 00452 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 00453 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 00454 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00455 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 00456 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00457 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00458 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00459 #if(CXSC_INDEX_CHECK) 00460 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00461 #else 00462 throw(); 00463 #endif 00464 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00465 #if(CXSC_INDEX_CHECK) 00466 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00467 #else 00468 throw(); 00469 #endif 00470 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00471 #if(CXSC_INDEX_CHECK) 00472 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00473 #else 00474 throw(); 00475 #endif 00476 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00477 #if(CXSC_INDEX_CHECK) 00478 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00479 #else 00480 throw(); 00481 #endif 00482 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00483 #if(CXSC_INDEX_CHECK) 00484 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00485 #else 00486 throw(); 00487 #endif 00488 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00489 #if(CXSC_INDEX_CHECK) 00490 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00491 #else 00492 throw(); 00493 #endif 00494 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00495 #if(CXSC_INDEX_CHECK) 00496 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00497 #else 00498 throw(); 00499 #endif 00500 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00501 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00502 #if(CXSC_INDEX_CHECK) 00503 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00504 #else 00505 throw(); 00506 #endif 00507 00508 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw(); 00509 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 00510 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw(); 00511 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 00512 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw(); 00513 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 00514 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw(); 00515 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 00516 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 00517 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 00518 template <class V> friend bool _vnot(const V &rv) throw(); 00519 template <class V> friend void *_vvoid(const V &rv) throw(); 00520 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00521 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00522 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00523 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00524 template <class VS> friend bool _vsnot(const VS &sl) throw(); 00525 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 00526 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw(); 00527 template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw(); 00528 00529 //------------- vector-matrix --------------- 00530 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00531 #if(CXSC_INDEX_CHECK) 00532 throw(OP_WITH_WRONG_DIM); 00533 #else 00534 throw(); 00535 #endif 00536 00537 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00538 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 00539 #if(CXSC_INDEX_CHECK) 00540 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00541 #else 00542 throw(); 00543 #endif 00544 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 00545 #if(CXSC_INDEX_CHECK) 00546 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00547 #else 00548 throw(); 00549 #endif 00550 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m) 00551 #if(CXSC_INDEX_CHECK) 00552 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00553 #else 00554 throw(); 00555 #endif 00556 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m) 00557 #if(CXSC_INDEX_CHECK) 00558 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00559 #else 00560 throw(); 00561 #endif 00562 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 00563 #if(CXSC_INDEX_CHECK) 00564 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00565 #else 00566 throw(); 00567 #endif 00568 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 00569 #if(CXSC_INDEX_CHECK) 00570 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00571 #else 00572 throw(); 00573 #endif 00574 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms) 00575 #if(CXSC_INDEX_CHECK) 00576 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00577 #else 00578 throw(); 00579 #endif 00580 00581 // Real 00582 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 00583 #if(CXSC_INDEX_CHECK) 00584 throw(OP_WITH_WRONG_DIM); 00585 #else 00586 throw(); 00587 #endif 00588 00589 // l_rvector x ivector ---------------- 00590 // vector - matrix ------------ 00591 /* friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v) 00592 #if(CXSC_INDEX_CHECK) 00593 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 00594 #else 00595 throw(); 00596 #endif */ 00597 /* friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m) 00598 #if(CXSC_INDEX_CHECK) 00599 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 00600 #else 00601 throw(); 00602 #endif */ 00603 00604 00605 #endif 00606 00607 00608 //------ Konstruktoren ---------------------------------------------------- 00610 INLINE l_ivector () throw(); 00612 explicit INLINE l_ivector(const int &i) throw(); 00613 #ifdef OLD_CXSC 00614 00615 explicit INLINE l_ivector(const class index &i) throw(); // for backwards compatibility 00616 #endif 00617 00618 explicit INLINE l_ivector(const int &i1,const int &i2) 00619 #if(CXSC_INDEX_CHECK) 00620 throw(ERROR_LIVECTOR_WRONG_BOUNDARIES,ERROR_LIVECTOR_NO_MORE_MEMORY); 00621 #else 00622 throw(); 00623 #endif 00624 00625 INLINE l_ivector(const l_imatrix_subv &) throw(); 00627 explicit INLINE l_ivector(const l_interval &) throw(); 00629 explicit INLINE l_ivector(const l_imatrix &) 00630 #if(CXSC_INDEX_CHECK) 00631 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00632 #else 00633 throw(); 00634 #endif 00635 00636 explicit INLINE l_ivector(const l_imatrix_slice &sl) 00637 #if(CXSC_INDEX_CHECK) 00638 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00639 #else 00640 throw(); 00641 #endif 00642 00643 INLINE l_ivector(const l_ivector_slice &rs) throw(); 00645 INLINE l_ivector(const l_ivector &v) throw(); 00646 // Real 00648 explicit INLINE l_ivector(const real &) throw(); 00650 explicit INLINE l_ivector(const rvector_slice &rs) throw(); 00652 explicit INLINE l_ivector(const rvector &v) throw(); 00654 explicit INLINE l_ivector(const rmatrix &) 00655 #if(CXSC_INDEX_CHECK) 00656 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00657 #else 00658 throw(); 00659 #endif 00660 00661 explicit INLINE l_ivector(const rmatrix_slice &sl) 00662 #if(CXSC_INDEX_CHECK) 00663 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00664 #else 00665 throw(); 00666 #endif 00667 00668 explicit INLINE l_ivector(const rmatrix_subv &) throw(); 00669 00670 // l_real 00672 explicit INLINE l_ivector(const l_real &) throw(); 00674 explicit INLINE l_ivector(const l_rvector_slice &rs) throw(); 00676 explicit INLINE l_ivector(const l_rvector &v) throw(); 00678 explicit INLINE l_ivector(const l_rmatrix &) 00679 #if(CXSC_INDEX_CHECK) 00680 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00681 #else 00682 throw(); 00683 #endif 00684 00685 explicit INLINE l_ivector(const l_rmatrix_slice &sl) 00686 #if(CXSC_INDEX_CHECK) 00687 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00688 #else 00689 throw(); 00690 #endif 00691 00692 explicit INLINE l_ivector(const l_rmatrix_subv &) throw(); 00693 00694 // interval 00696 explicit INLINE l_ivector(const interval &) throw(); 00698 explicit INLINE l_ivector(const ivector_slice &rs) throw(); 00700 explicit INLINE l_ivector(const ivector &v) throw(); 00702 explicit INLINE l_ivector(const imatrix &) 00703 #if(CXSC_INDEX_CHECK) 00704 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00705 #else 00706 throw(); 00707 #endif 00708 00709 explicit INLINE l_ivector(const imatrix_slice &sl) 00710 #if(CXSC_INDEX_CHECK) 00711 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00712 #else 00713 throw(); 00714 #endif 00715 00716 explicit INLINE l_ivector(const imatrix_subv &) throw(); 00717 00718 // l_interval 00720 INLINE l_ivector &operator =(const l_ivector &rv) throw(); 00722 INLINE l_ivector &operator =(const l_ivector_slice &sl) throw(); 00724 INLINE l_ivector &operator =(const l_interval &r) throw(); 00726 INLINE l_ivector &operator =(const l_imatrix &m) 00727 #if(CXSC_INDEX_CHECK) 00728 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00729 #else 00730 throw(); 00731 #endif 00732 00733 INLINE l_ivector &operator =(const l_imatrix_slice &) 00734 #if(CXSC_INDEX_CHECK) 00735 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00736 #else 00737 throw(); 00738 #endif 00739 00740 INLINE l_ivector &operator =(const l_imatrix_subv &) throw(); 00741 // Real 00743 INLINE l_ivector &operator =(const rvector &rv) throw(); 00745 INLINE l_ivector &operator =(const rvector_slice &sl) throw(); 00747 INLINE l_ivector &operator =(const real &r) throw(); 00749 INLINE l_ivector &operator =(const rmatrix &m) 00750 #if(CXSC_INDEX_CHECK) 00751 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00752 #else 00753 throw(); 00754 #endif 00755 00756 INLINE l_ivector &operator =(const rmatrix_slice &) 00757 #if(CXSC_INDEX_CHECK) 00758 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00759 #else 00760 throw(); 00761 #endif 00762 00763 INLINE l_ivector &operator =(const rmatrix_subv &) throw(); 00764 00765 // l_real 00767 INLINE l_ivector &operator =(const l_rvector &rv) throw(); 00769 INLINE l_ivector &operator =(const l_rvector_slice &sl) throw(); 00771 INLINE l_ivector &operator =(const l_real &r) throw(); 00773 INLINE l_ivector &operator =(const l_rmatrix &m) 00774 #if(CXSC_INDEX_CHECK) 00775 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00776 #else 00777 throw(); 00778 #endif 00779 00780 INLINE l_ivector &operator =(const l_rmatrix_slice &) 00781 #if(CXSC_INDEX_CHECK) 00782 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00783 #else 00784 throw(); 00785 #endif 00786 00787 INLINE l_ivector &operator =(const l_rmatrix_subv &) throw(); 00788 00789 // interval 00791 INLINE l_ivector &operator =(const ivector &rv) throw(); 00793 INLINE l_ivector &operator =(const ivector_slice &sl) throw(); 00795 INLINE l_ivector &operator =(const interval &r) throw(); 00797 INLINE l_ivector &operator =(const imatrix &m) 00798 #if(CXSC_INDEX_CHECK) 00799 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00800 #else 00801 throw(); 00802 #endif 00803 00804 INLINE l_ivector &operator =(const imatrix_slice &) 00805 #if(CXSC_INDEX_CHECK) 00806 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00807 #else 00808 throw(); 00809 #endif 00810 00811 INLINE l_ivector &operator =(const imatrix_subv &) throw(); 00812 00813 //--------- Destruktor ---------------------------------------------------- 00814 INLINE ~l_ivector() { delete [] dat; } 00815 00816 //------ Standardfunktionen ----------------------------------------------- 00817 00818 friend INLINE l_interval::l_interval(const l_ivector &) 00819 #if(CXSC_INDEX_CHECK) 00820 throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ); 00821 #else 00822 throw(); 00823 #endif 00824 00825 friend INLINE int Lb(const l_ivector &rv) throw() { return rv.l; } 00827 friend INLINE int Ub(const l_ivector &rv) throw() { return rv.u; } 00829 friend INLINE int VecLen(const l_ivector &rv) throw() { return rv.size; } 00831 friend INLINE l_ivector & SetLb(l_ivector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;} 00833 friend INLINE l_ivector & SetUb(l_ivector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;} 00835 INLINE l_interval & operator [](const int &i) const 00836 #if(CXSC_INDEX_CHECK) 00837 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC); 00838 #else 00839 throw(); 00840 #endif 00841 00842 INLINE l_ivector & operator ()() throw() { return *this; } 00844 INLINE l_ivector_slice operator ()(const int &i) 00845 #if(CXSC_INDEX_CHECK) 00846 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG); 00847 #else 00848 throw(); 00849 #endif 00850 00851 INLINE l_ivector_slice operator ()(const int &i1,const int &i2) 00852 #if(CXSC_INDEX_CHECK) 00853 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG); 00854 #else 00855 throw(); 00856 #endif 00857 00858 INLINE operator void*() throw(); 00859 //#else 00860 //#endif 00861 }; 00862 00863 00865 00870 class l_ivector_slice 00871 { 00872 friend class l_ivector; 00873 friend class l_imatrix; 00874 private: 00875 l_interval *dat; 00876 int l,u,size; 00877 int start,end; 00878 00879 public: 00880 //#if(CXSC_INDEX_CHECK) 00881 #ifdef _CXSC_FRIEND_TPL 00882 //------------------------- Templates ------------------------------------------- 00883 // l_interval / l_interval 00884 00885 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2) 00886 #if(CXSC_INDEX_CHECK) 00887 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00888 #else 00889 throw(); 00890 #endif 00891 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00892 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00893 #if(CXSC_INDEX_CHECK) 00894 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00895 #else 00896 throw(); 00897 #endif 00898 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw(); 00899 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv) 00900 #if(CXSC_INDEX_CHECK) 00901 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00902 #else 00903 throw(); 00904 #endif 00905 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv) 00906 #if(CXSC_INDEX_CHECK) 00907 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00908 #else 00909 throw(); 00910 #endif 00911 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2) 00912 #if(CXSC_INDEX_CHECK) 00913 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00914 #else 00915 throw(); 00916 #endif 00917 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2) 00918 #if(CXSC_INDEX_CHECK) 00919 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00920 #else 00921 throw(); 00922 #endif 00923 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv) 00924 #if(CXSC_INDEX_CHECK) 00925 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00926 #else 00927 throw(); 00928 #endif 00929 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv) 00930 #if(CXSC_INDEX_CHECK) 00931 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00932 #else 00933 throw(); 00934 #endif 00935 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2) 00936 #if(CXSC_INDEX_CHECK) 00937 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00938 #else 00939 throw(); 00940 #endif 00941 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2) 00942 #if(CXSC_INDEX_CHECK) 00943 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00944 #else 00945 throw(); 00946 #endif 00947 00948 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00949 template <class VS,class E> friend E _vsdiam(const VS &sl) throw(); 00950 template <class VS,class E> friend E _vsmid(const VS &sl) throw(); 00951 template <class VS,class E> friend E _vsinf(const VS &sl) throw(); 00952 template <class VS,class E> friend E _vssup(const VS &sl) throw(); 00953 template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw(); 00954 template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw(); 00955 template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw(); 00956 template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw(); 00957 00958 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00959 #if(CXSC_INDEX_CHECK) 00960 throw(OP_WITH_WRONG_DIM); 00961 #else 00962 throw(); 00963 #endif 00964 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 00965 #if(CXSC_INDEX_CHECK) 00966 throw(OP_WITH_WRONG_DIM); 00967 #else 00968 throw(); 00969 #endif 00970 00971 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00972 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00973 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 00974 #if(CXSC_INDEX_CHECK) 00975 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00976 #else 00977 throw(); 00978 #endif 00979 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw(); 00980 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw(); 00981 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00982 #if(CXSC_INDEX_CHECK) 00983 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00984 #else 00985 throw(); 00986 #endif 00987 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00988 #if(CXSC_INDEX_CHECK) 00989 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00990 #else 00991 throw(); 00992 #endif 00993 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00994 #if(CXSC_INDEX_CHECK) 00995 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00996 #else 00997 throw(); 00998 #endif 00999 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 01000 #if(CXSC_INDEX_CHECK) 01001 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01002 #else 01003 throw(); 01004 #endif 01005 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 01006 #if(CXSC_INDEX_CHECK) 01007 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01008 #else 01009 throw(); 01010 #endif 01011 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 01012 #if(CXSC_INDEX_CHECK) 01013 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01014 #else 01015 throw(); 01016 #endif 01017 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 01018 #if(CXSC_INDEX_CHECK) 01019 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01020 #else 01021 throw(); 01022 #endif 01023 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 01024 #if(CXSC_INDEX_CHECK) 01025 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01026 #else 01027 throw(); 01028 #endif 01029 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 01030 #if(CXSC_INDEX_CHECK) 01031 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01032 #else 01033 throw(); 01034 #endif 01035 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 01036 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 01037 #if(CXSC_INDEX_CHECK) 01038 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01039 #else 01040 throw(); 01041 #endif 01042 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 01043 #if(CXSC_INDEX_CHECK) 01044 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01045 #else 01046 throw(); 01047 #endif 01048 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 01049 #if(CXSC_INDEX_CHECK) 01050 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01051 #else 01052 throw(); 01053 #endif 01054 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 01055 #if(CXSC_INDEX_CHECK) 01056 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01057 #else 01058 throw(); 01059 #endif 01060 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 01061 #if(CXSC_INDEX_CHECK) 01062 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01063 #else 01064 throw(); 01065 #endif 01066 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 01067 #if(CXSC_INDEX_CHECK) 01068 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01069 #else 01070 throw(); 01071 #endif 01072 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 01073 #if(CXSC_INDEX_CHECK) 01074 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01075 #else 01076 throw(); 01077 #endif 01078 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 01079 #if(CXSC_INDEX_CHECK) 01080 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01081 #else 01082 throw(); 01083 #endif 01084 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 01085 #if(CXSC_INDEX_CHECK) 01086 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01087 #else 01088 throw(); 01089 #endif 01090 template <class V,class VS> friend V &_vvsconvassign(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 &_vsvconvassign(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 &_vsvsconvassign(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 VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m) 01109 #if(CXSC_INDEX_CHECK) 01110 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01111 #else 01112 throw(); 01113 #endif 01114 01115 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 01116 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 01117 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 01118 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 01119 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 01120 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 01121 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 01122 #if(CXSC_INDEX_CHECK) 01123 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01124 #else 01125 throw(); 01126 #endif 01127 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 01128 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 01129 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 01130 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 01131 template <class VS> friend bool _vsnot(const VS &sl) throw(); 01132 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 01133 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw(); 01134 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw(); 01135 01136 // l_interval / Real 01137 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 01138 #if(CXSC_INDEX_CHECK) 01139 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01140 #else 01141 throw(); 01142 #endif 01143 // l_interval / l_real 01144 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 01145 #if(CXSC_INDEX_CHECK) 01146 throw(OP_WITH_WRONG_DIM); 01147 #else 01148 throw(); 01149 #endif 01150 01151 // l_real 01152 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 01153 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 01154 01155 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 01156 #if(CXSC_INDEX_CHECK) 01157 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 01158 #else 01159 throw(); 01160 #endif 01161 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 01162 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 01163 01164 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 01165 #if(CXSC_INDEX_CHECK) 01166 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01167 #else 01168 throw(); 01169 #endif 01170 01171 //--l_real -------- vector-scalar ------------ 01172 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 01173 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 01174 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 01175 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 01176 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 01177 01178 //--l_real--------- Vector-vector--------- 01179 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2) 01180 #if(CXSC_INDEX_CHECK) 01181 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01182 #else 01183 throw(); 01184 #endif 01185 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 01186 #if(CXSC_INDEX_CHECK) 01187 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01188 #else 01189 throw(); 01190 #endif 01191 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 01192 #if(CXSC_INDEX_CHECK) 01193 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01194 #else 01195 throw(); 01196 #endif 01197 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 01198 #if(CXSC_INDEX_CHECK) 01199 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01200 #else 01201 throw(); 01202 #endif 01203 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 01204 #if(CXSC_INDEX_CHECK) 01205 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01206 #else 01207 throw(); 01208 #endif 01209 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 01210 #if(CXSC_INDEX_CHECK) 01211 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01212 #else 01213 throw(); 01214 #endif 01215 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 01216 #if(CXSC_INDEX_CHECK) 01217 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01218 #else 01219 throw(); 01220 #endif 01221 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 01222 #if(CXSC_INDEX_CHECK) 01223 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01224 #else 01225 throw(); 01226 #endif 01227 01228 //-- l_real -------- Vector-matrix ---------- 01229 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 01230 #if(CXSC_INDEX_CHECK) 01231 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 01232 #else 01233 throw(); 01234 #endif 01235 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 01236 #if(CXSC_INDEX_CHECK) 01237 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 01238 #else 01239 throw(); 01240 #endif 01241 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 01242 #if(CXSC_INDEX_CHECK) 01243 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01244 #else 01245 throw(); 01246 #endif 01247 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 01248 #if(CXSC_INDEX_CHECK) 01249 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01250 #else 01251 throw(); 01252 #endif 01253 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 01254 #if(CXSC_INDEX_CHECK) 01255 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01256 #else 01257 throw(); 01258 #endif 01259 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms) 01260 #if(CXSC_INDEX_CHECK) 01261 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01262 #else 01263 throw(); 01264 #endif 01265 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m) 01266 #if(CXSC_INDEX_CHECK) 01267 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01268 #else 01269 throw(); 01270 #endif 01271 01272 /* friend TINLINE l_ivector &_vsmassign<l_ivector_slice,imatrix,l_interval>(l_ivector_slice &v,const imatrix &m) 01273 #if(CXSC_INDEX_CHECK) 01274 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01275 #else 01276 throw(); 01277 #endif */ 01278 01279 //-- interval -------- Vector-matrix ---------- 01280 /* friend TINLINE l_ivector _mvslimult<imatrix,l_ivector_slice,l_ivector>(const imatrix &m,const l_ivector_slice &v) 01281 #if(CXSC_INDEX_CHECK) 01282 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01283 #else 01284 throw(); 01285 #endif */ 01286 /* friend TINLINE l_ivector _msvslimult<imatrix_slice,l_ivector_slice,l_ivector>(const imatrix_slice &ms,const l_ivector_slice &v) 01287 #if(CXSC_INDEX_CHECK) 01288 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01289 #else 01290 throw(); 01291 #endif */ 01292 /* friend TINLINE l_ivector _vsmlimult<l_ivector_slice,imatrix,l_ivector>(const l_ivector_slice &v,const imatrix &m) 01293 #if(CXSC_INDEX_CHECK) 01294 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01295 #else 01296 throw(); 01297 #endif */ 01298 /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,imatrix_slice,l_ivector>(const l_ivector_slice &v,const imatrix_slice &ms) 01299 #if(CXSC_INDEX_CHECK) 01300 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01301 #else 01302 throw(); 01303 #endif */ 01304 /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,imatrix_slice,l_interval>(l_ivector_slice &v,const imatrix_slice &m) 01305 #if(CXSC_INDEX_CHECK) 01306 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01307 #else 01308 throw(); 01309 #endif */ 01310 01311 #endif 01312 01313 //--------------------- Konstruktoren ----------------------------------- 01315 explicit INLINE l_ivector_slice(l_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) { } 01317 explicit INLINE l_ivector_slice(l_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) { } 01318 public: 01320 INLINE l_ivector_slice(const l_ivector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { } 01321 public: 01322 // l_interval 01324 INLINE l_ivector_slice & operator =(const l_ivector_slice &sl) 01325 #if(CXSC_INDEX_CHECK) 01326 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01327 #else 01328 throw(); 01329 #endif 01330 01331 INLINE l_ivector_slice & operator =(const l_ivector &rv) 01332 #if(CXSC_INDEX_CHECK) 01333 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01334 #else 01335 throw(); 01336 #endif 01337 01338 INLINE l_ivector_slice & operator =(const l_interval &r) throw(); 01340 INLINE l_ivector_slice & operator =(const l_imatrix &m) 01341 #if(CXSC_INDEX_CHECK) 01342 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01343 #else 01344 throw(); 01345 #endif 01346 01347 INLINE l_ivector_slice & operator =(const l_imatrix_slice &m) 01348 #if(CXSC_INDEX_CHECK) 01349 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01350 #else 01351 throw(); 01352 #endif 01353 01354 INLINE l_ivector_slice &operator =(const l_imatrix_subv &) throw(); 01355 // Real 01357 INLINE l_ivector_slice & operator =(const rvector_slice &sl) 01358 #if(CXSC_INDEX_CHECK) 01359 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01360 #else 01361 throw(); 01362 #endif 01363 01364 INLINE l_ivector_slice & operator =(const rvector &rv) 01365 #if(CXSC_INDEX_CHECK) 01366 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01367 #else 01368 throw(); 01369 #endif 01370 01371 INLINE l_ivector_slice & operator =(const real &r) throw(); 01373 INLINE l_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 l_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 l_ivector_slice &operator =(const rmatrix_subv &mv) throw(); 01388 01389 // l_real 01391 INLINE l_ivector_slice & operator =(const l_rvector_slice &sl) 01392 #if(CXSC_INDEX_CHECK) 01393 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01394 #else 01395 throw(); 01396 #endif 01397 01398 INLINE l_ivector_slice & operator =(const l_rvector &rv) 01399 #if(CXSC_INDEX_CHECK) 01400 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01401 #else 01402 throw(); 01403 #endif 01404 01405 INLINE l_ivector_slice & operator =(const l_real &r) throw(); 01407 INLINE l_ivector_slice & operator =(const l_rmatrix &m) 01408 #if(CXSC_INDEX_CHECK) 01409 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01410 #else 01411 throw(); 01412 #endif 01413 01414 INLINE l_ivector_slice & operator =(const l_rmatrix_slice &m) 01415 #if(CXSC_INDEX_CHECK) 01416 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01417 #else 01418 throw(); 01419 #endif 01420 01421 INLINE l_ivector_slice &operator =(const l_rmatrix_subv &mv) throw(); 01422 01423 // interval 01425 INLINE l_ivector_slice & operator =(const ivector_slice &sl) 01426 #if(CXSC_INDEX_CHECK) 01427 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01428 #else 01429 throw(); 01430 #endif 01431 01432 INLINE l_ivector_slice & operator =(const ivector &rv) 01433 #if(CXSC_INDEX_CHECK) 01434 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01435 #else 01436 throw(); 01437 #endif 01438 01439 INLINE l_ivector_slice & operator =(const interval &r) throw(); 01441 INLINE l_ivector_slice & operator =(const imatrix &m) 01442 #if(CXSC_INDEX_CHECK) 01443 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01444 #else 01445 throw(); 01446 #endif 01447 01448 INLINE l_ivector_slice & operator =(const imatrix_slice &m) 01449 #if(CXSC_INDEX_CHECK) 01450 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01451 #else 01452 throw(); 01453 #endif 01454 01455 INLINE l_ivector_slice &operator =(const imatrix_subv &mv) throw(); 01456 01457 //--------------------- Standardfunktionen ------------------------------ 01458 01459 friend INLINE l_interval::l_interval(const l_ivector_slice &sl) 01460 #if(CXSC_INDEX_CHECK) 01461 throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ); 01462 #else 01463 throw(); 01464 #endif 01465 01466 friend INLINE int Lb(const l_ivector_slice &sl) throw() { return sl.start; } 01468 friend INLINE int Ub(const l_ivector_slice &sl) throw() { return sl.end; } 01470 friend INLINE int VecLen(const l_ivector_slice &sl) throw() { return sl.end-sl.start+1; } 01472 INLINE l_interval & operator [](const int &i) const 01473 #if(CXSC_INDEX_CHECK) 01474 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC); 01475 #else 01476 throw(); 01477 #endif 01478 01479 INLINE l_ivector_slice & operator ()() throw() { return *this; } 01481 INLINE l_ivector_slice operator ()(const int &i) 01482 #if(CXSC_INDEX_CHECK) 01483 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG); 01484 #else 01485 throw(); 01486 #endif 01487 01488 INLINE l_ivector_slice operator ()(const int &i1,const int &i2) 01489 #if(CXSC_INDEX_CHECK) 01490 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG); 01491 #else 01492 throw(); 01493 #endif 01494 INLINE operator void*() throw(); 01495 01497 INLINE l_ivector_slice &operator *=(const l_interval &r) throw(); 01499 INLINE l_ivector_slice &operator /=(const l_interval &r) throw(); 01501 INLINE l_ivector_slice &operator *=(const l_imatrix &m) 01502 #if(CXSC_INDEX_CHECK) 01503 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01504 #else 01505 throw(); 01506 #endif 01507 01508 INLINE l_ivector_slice &operator *=(const l_imatrix_slice &m) 01509 #if(CXSC_INDEX_CHECK) 01510 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01511 #else 01512 throw(); 01513 #endif 01514 01515 INLINE l_ivector_slice &operator +=(const l_ivector &rv) 01516 #if(CXSC_INDEX_CHECK) 01517 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01518 #else 01519 throw(); 01520 #endif 01521 01522 INLINE l_ivector_slice &operator +=(const l_ivector_slice &sl2) 01523 #if(CXSC_INDEX_CHECK) 01524 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01525 #else 01526 throw(); 01527 #endif 01528 01529 INLINE l_ivector_slice &operator -=(const l_ivector &rv) 01530 #if(CXSC_INDEX_CHECK) 01531 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01532 #else 01533 throw(); 01534 #endif 01535 01536 INLINE l_ivector_slice &operator -=(const l_ivector_slice &sl2) 01537 #if(CXSC_INDEX_CHECK) 01538 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01539 #else 01540 throw(); 01541 #endif 01542 01543 INLINE l_ivector_slice &operator |=(const l_ivector &rv) 01544 #if(CXSC_INDEX_CHECK) 01545 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01546 #else 01547 throw(); 01548 #endif 01549 01550 INLINE l_ivector_slice &operator |=(const l_ivector_slice &sl2) 01551 #if(CXSC_INDEX_CHECK) 01552 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01553 #else 01554 throw(); 01555 #endif 01556 01557 INLINE l_ivector_slice &operator &=(const l_ivector &rv) 01558 #if(CXSC_INDEX_CHECK) 01559 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01560 #else 01561 throw(); 01562 #endif 01563 01564 INLINE l_ivector_slice &operator &=(const l_ivector_slice &sl2) 01565 #if(CXSC_INDEX_CHECK) 01566 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01567 #else 01568 throw(); 01569 #endif 01570 01572 INLINE l_ivector_slice &operator *=(const real &r) throw(); 01574 INLINE l_ivector_slice &operator /=(const real &r) throw(); 01576 INLINE l_ivector_slice &operator +=(const rvector &rv) 01577 #if(CXSC_INDEX_CHECK) 01578 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01579 #else 01580 throw(); 01581 #endif 01582 01583 INLINE l_ivector_slice &operator +=(const rvector_slice &sl2) 01584 #if(CXSC_INDEX_CHECK) 01585 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01586 #else 01587 throw(); 01588 #endif 01589 01590 INLINE l_ivector_slice &operator -=(const rvector &rv) 01591 #if(CXSC_INDEX_CHECK) 01592 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01593 #else 01594 throw(); 01595 #endif 01596 01597 INLINE l_ivector_slice &operator -=(const rvector_slice &sl2) 01598 #if(CXSC_INDEX_CHECK) 01599 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01600 #else 01601 throw(); 01602 #endif 01603 01604 INLINE l_ivector_slice &operator |=(const rvector &rv) 01605 #if(CXSC_INDEX_CHECK) 01606 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01607 #else 01608 throw(); 01609 #endif 01610 01611 INLINE l_ivector_slice &operator |=(const rvector_slice &sl2) 01612 #if(CXSC_INDEX_CHECK) 01613 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01614 #else 01615 throw(); 01616 #endif 01617 01618 INLINE l_ivector_slice &operator &=(const rvector &rv) 01619 #if(CXSC_INDEX_CHECK) 01620 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01621 #else 01622 throw(); 01623 #endif 01624 01625 INLINE l_ivector_slice &operator &=(const rvector_slice &sl2) 01626 #if(CXSC_INDEX_CHECK) 01627 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01628 #else 01629 throw(); 01630 #endif 01631 01632 INLINE l_ivector_slice &operator *=(const rmatrix &m) 01633 #if(CXSC_INDEX_CHECK) 01634 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01635 #else 01636 throw(); 01637 #endif 01638 01639 INLINE l_ivector_slice &operator *=(const rmatrix_slice &m) 01640 #if(CXSC_INDEX_CHECK) 01641 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01642 #else 01643 throw(); 01644 #endif 01645 01647 INLINE l_ivector_slice &operator *=(const l_real &r) throw(); 01649 INLINE l_ivector_slice &operator /=(const l_real &r) throw(); 01651 INLINE l_ivector_slice &operator +=(const l_rvector &rv) 01652 #if(CXSC_INDEX_CHECK) 01653 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01654 #else 01655 throw(); 01656 #endif 01657 01658 INLINE l_ivector_slice &operator +=(const l_rvector_slice &sl2) 01659 #if(CXSC_INDEX_CHECK) 01660 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01661 #else 01662 throw(); 01663 #endif 01664 01665 INLINE l_ivector_slice &operator -=(const l_rvector &rv) 01666 #if(CXSC_INDEX_CHECK) 01667 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01668 #else 01669 throw(); 01670 #endif 01671 01672 INLINE l_ivector_slice &operator -=(const l_rvector_slice &sl2) 01673 #if(CXSC_INDEX_CHECK) 01674 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01675 #else 01676 throw(); 01677 #endif 01678 01679 INLINE l_ivector_slice &operator |=(const l_rvector &rv) 01680 #if(CXSC_INDEX_CHECK) 01681 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01682 #else 01683 throw(); 01684 #endif 01685 01686 INLINE l_ivector_slice &operator |=(const l_rvector_slice &sl2) 01687 #if(CXSC_INDEX_CHECK) 01688 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01689 #else 01690 throw(); 01691 #endif 01692 01693 INLINE l_ivector_slice &operator &=(const l_rvector &rv) 01694 #if(CXSC_INDEX_CHECK) 01695 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01696 #else 01697 throw(); 01698 #endif 01699 01700 INLINE l_ivector_slice &operator &=(const l_rvector_slice &sl2) 01701 #if(CXSC_INDEX_CHECK) 01702 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01703 #else 01704 throw(); 01705 #endif 01706 01707 INLINE l_ivector_slice &operator *=(const l_rmatrix &m) 01708 #if(CXSC_INDEX_CHECK) 01709 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01710 #else 01711 throw(); 01712 #endif 01713 01714 INLINE l_ivector_slice &operator *=(const l_rmatrix_slice &m) 01715 #if(CXSC_INDEX_CHECK) 01716 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01717 #else 01718 throw(); 01719 #endif 01720 01722 INLINE l_ivector_slice &operator *=(const interval &r) throw(); 01724 INLINE l_ivector_slice &operator /=(const interval &r) throw(); 01726 INLINE l_ivector_slice &operator +=(const ivector &rv) 01727 #if(CXSC_INDEX_CHECK) 01728 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01729 #else 01730 throw(); 01731 #endif 01732 01733 INLINE l_ivector_slice &operator +=(const ivector_slice &sl2) 01734 #if(CXSC_INDEX_CHECK) 01735 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01736 #else 01737 throw(); 01738 #endif 01739 01740 INLINE l_ivector_slice &operator -=(const ivector &rv) 01741 #if(CXSC_INDEX_CHECK) 01742 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01743 #else 01744 throw(); 01745 #endif 01746 01747 INLINE l_ivector_slice &operator -=(const ivector_slice &sl2) 01748 #if(CXSC_INDEX_CHECK) 01749 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01750 #else 01751 throw(); 01752 #endif 01753 01754 INLINE l_ivector_slice &operator |=(const ivector &rv) 01755 #if(CXSC_INDEX_CHECK) 01756 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01757 #else 01758 throw(); 01759 #endif 01760 01761 INLINE l_ivector_slice &operator |=(const ivector_slice &sl2) 01762 #if(CXSC_INDEX_CHECK) 01763 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01764 #else 01765 throw(); 01766 #endif 01767 01768 INLINE l_ivector_slice &operator &=(const ivector &rv) 01769 #if(CXSC_INDEX_CHECK) 01770 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01771 #else 01772 throw(); 01773 #endif 01774 01775 INLINE l_ivector_slice &operator &=(const ivector_slice &sl2) 01776 #if(CXSC_INDEX_CHECK) 01777 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 01778 #else 01779 throw(); 01780 #endif 01781 01782 INLINE l_ivector_slice &operator *=(const imatrix &m) 01783 #if(CXSC_INDEX_CHECK) 01784 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01785 #else 01786 throw(); 01787 #endif 01788 01789 INLINE l_ivector_slice &operator *=(const imatrix_slice &m) 01790 #if(CXSC_INDEX_CHECK) 01791 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01792 #else 01793 throw(); 01794 #endif 01795 //#else 01796 //#endif 01797 }; 01798 01799 //======================================================================= 01800 //======================== Vector Functions ============================= 01801 01803 INLINE l_ivector _l_ivector(const l_interval &r) throw(); 01804 // INLINE l_ivector _l_ivector(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01805 // INLINE l_ivector _l_ivector(const l_imatrix_slice &sl) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01807 INLINE l_ivector _l_ivector(const real &r) throw(); 01809 INLINE l_ivector _l_ivector(const rvector_slice &rs) throw(); 01811 INLINE l_ivector _l_ivector(const rvector &rs) throw(); 01812 // INLINE l_ivector _l_ivector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01813 // INLINE l_ivector _l_ivector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01815 INLINE l_ivector _l_ivector(const rmatrix_subv &rs) throw(); 01816 01818 INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector &rv) 01819 #if(CXSC_INDEX_CHECK) 01820 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01821 #else 01822 throw(); 01823 #endif 01824 01825 INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector &rv) 01826 #if(CXSC_INDEX_CHECK) 01827 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01828 #else 01829 throw(); 01830 #endif 01831 01832 INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv) 01833 #if(CXSC_INDEX_CHECK) 01834 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01835 #else 01836 throw(); 01837 #endif 01838 01839 INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector_slice &rv) 01840 #if(CXSC_INDEX_CHECK) 01841 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01842 #else 01843 throw(); 01844 #endif 01845 01846 INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv) 01847 #if(CXSC_INDEX_CHECK) 01848 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01849 #else 01850 throw(); 01851 #endif 01852 01853 INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector &rv) 01854 #if(CXSC_INDEX_CHECK) 01855 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01856 #else 01857 throw(); 01858 #endif 01859 01860 INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv) 01861 #if(CXSC_INDEX_CHECK) 01862 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01863 #else 01864 throw(); 01865 #endif 01866 01867 INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector_slice &rv) 01868 #if(CXSC_INDEX_CHECK) 01869 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01870 #else 01871 throw(); 01872 #endif 01873 01875 INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector &rv) 01876 #if(CXSC_INDEX_CHECK) 01877 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01878 #else 01879 throw(); 01880 #endif 01881 01882 INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector &rv) 01883 #if(CXSC_INDEX_CHECK) 01884 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01885 #else 01886 throw(); 01887 #endif 01888 01889 INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv) 01890 #if(CXSC_INDEX_CHECK) 01891 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01892 #else 01893 throw(); 01894 #endif 01895 01896 INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector_slice &rv) 01897 #if(CXSC_INDEX_CHECK) 01898 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01899 #else 01900 throw(); 01901 #endif 01902 01903 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv) 01904 #if(CXSC_INDEX_CHECK) 01905 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01906 #else 01907 throw(); 01908 #endif 01909 01910 INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector &rv) 01911 #if(CXSC_INDEX_CHECK) 01912 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01913 #else 01914 throw(); 01915 #endif 01916 01917 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv) 01918 #if(CXSC_INDEX_CHECK) 01919 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01920 #else 01921 throw(); 01922 #endif 01923 01924 INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector_slice &rv) 01925 #if(CXSC_INDEX_CHECK) 01926 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM); 01927 #else 01928 throw(); 01929 #endif 01930 01932 INLINE l_ivector &SetSup(l_ivector &iv,const l_real &r) throw(); 01934 INLINE l_ivector &SetInf(l_ivector &iv,const l_real &r) throw(); 01936 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_real &r) throw(); 01938 INLINE l_ivector &SetUncheckedInf(l_ivector &iv,const l_real &r) throw(); 01939 01941 INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_real &r) throw(); 01943 INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_real &r) throw(); 01945 INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_real &r) throw(); 01947 INLINE l_ivector_slice &SetUncheckedInf(l_ivector_slice &iv,const l_real &r) throw(); 01948 01950 INLINE void Resize(l_ivector &rv) throw(); 01952 INLINE void Resize(l_ivector &rv, const int &len) 01953 #if(CXSC_INDEX_CHECK) 01954 throw(ERROR__WRONG_BOUNDARIES<l_ivector>); 01955 #else 01956 throw(); 01957 #endif 01958 01959 INLINE void Resize(l_ivector &rv, const int &lb, const int &ub) 01960 #if(CXSC_INDEX_CHECK) 01961 throw(ERROR__WRONG_BOUNDARIES<l_ivector>); 01962 #else 01963 throw(); 01964 #endif 01965 01967 INLINE l_ivector abs(const l_ivector &rv) throw(); 01969 INLINE l_ivector abs(const l_ivector_slice &sl) throw(); 01971 INLINE l_rvector diam(const l_ivector &v) throw(); 01973 INLINE l_rvector diam(const l_ivector_slice &v) throw(); 01975 INLINE l_rvector mid(const l_ivector &v) throw(); 01977 INLINE l_rvector mid(const l_ivector_slice &v) throw(); 01979 INLINE l_rvector Inf(const l_ivector &v) throw(); 01981 INLINE l_rvector Inf(const l_ivector_slice &v) throw(); 01983 INLINE l_rvector Sup(const l_ivector &v) throw(); 01985 INLINE l_rvector Sup(const l_ivector_slice &v) throw(); 01987 INLINE bool operator !(const l_ivector &rv) throw(); 01989 INLINE bool operator !(const l_ivector_slice &sl) throw(); 01990 01991 //======================= Vector / Scalar =============================== 01992 01993 //----------------------------- l_interval --------------------------- 01994 01996 INLINE l_ivector operator *(const l_ivector &rv, const l_interval &s) throw(); 01998 INLINE l_ivector operator *(const l_ivector_slice &sl, const l_interval &s) throw(); 02000 INLINE l_ivector operator *(const l_interval &s, const l_ivector &rv) throw(); 02002 INLINE l_ivector operator *(const l_interval &s, const l_ivector_slice &sl) throw(); 02004 INLINE l_ivector &operator *=(l_ivector &rv,const l_interval &r) throw(); 02005 02007 INLINE l_ivector operator /(const l_ivector &rv, const l_interval &s) throw(); 02009 INLINE l_ivector operator /(const l_ivector_slice &sl, const l_interval &s) throw(); 02011 INLINE l_ivector &operator /=(l_ivector &rv,const l_interval &r) throw(); 02012 02013 //---------------------------- Real -------------------------------------- 02014 02016 INLINE l_ivector operator *(const l_ivector &rv, const real &s) throw(); 02018 INLINE l_ivector operator *(const l_ivector_slice &sl, const real &s) throw(); 02020 INLINE l_ivector operator *(const real &s, const l_ivector &rv) throw(); 02022 INLINE l_ivector operator *(const real &s, const l_ivector_slice &sl) throw(); 02024 INLINE l_ivector &operator *=(l_ivector &rv,const real &r) throw(); 02025 02027 INLINE l_ivector operator /(const l_ivector &rv, const real &s) throw(); 02029 INLINE l_ivector operator /(const l_ivector_slice &sl, const real &s) throw(); 02031 INLINE l_ivector &operator /=(l_ivector &rv,const real &r) throw(); 02032 02034 INLINE l_ivector operator *(const rvector &rv, const l_interval &s) throw(); 02036 INLINE l_ivector operator *(const rvector_slice &sl, const l_interval &s) throw(); 02038 INLINE l_ivector operator *(const l_interval &s, const rvector &rv) throw(); 02040 INLINE l_ivector operator *(const l_interval &s, const rvector_slice &sl) throw(); 02041 02043 INLINE l_ivector operator /(const rvector &rv, const l_interval &s) throw(); 02045 INLINE l_ivector operator /(const rvector_slice &sl, const l_interval &s) throw(); 02046 02047 //---------------------------- Complex -------------------------------------- 02048 02050 INLINE l_ivector operator *(const l_ivector &rv, const l_real &s) throw(); 02052 INLINE l_ivector operator *(const l_ivector_slice &sl, const l_real &s) throw(); 02054 INLINE l_ivector operator *(const l_real &s, const l_ivector &rv) throw(); 02056 INLINE l_ivector operator *(const l_real &s, const l_ivector_slice &sl) throw(); 02058 INLINE l_ivector &operator *=(l_ivector &rv,const l_real &r) throw(); 02059 02061 INLINE l_ivector operator /(const l_ivector &rv, const l_real &s) throw(); 02063 INLINE l_ivector operator /(const l_ivector_slice &sl, const l_real &s) throw(); 02065 INLINE l_ivector &operator /=(l_ivector &rv,const l_real &r) throw(); 02066 02068 INLINE l_ivector operator *(const l_rvector &rv, const l_interval &s) throw(); 02070 INLINE l_ivector operator *(const l_rvector_slice &sl, const l_interval &s) throw(); 02072 INLINE l_ivector operator *(const l_interval &s, const l_rvector &rv) throw(); 02074 INLINE l_ivector operator *(const l_interval &s, const l_rvector_slice &sl) throw(); 02075 02077 INLINE l_ivector operator /(const l_rvector &rv, const l_interval &s) throw(); 02079 INLINE l_ivector operator /(const l_rvector_slice &sl, const l_interval &s) throw(); 02080 02081 //---------------------------- interval -------------------------------------- 02082 02084 INLINE l_ivector operator *(const l_ivector &rv, const interval &s) throw(); 02086 INLINE l_ivector operator *(const l_ivector_slice &sl, const interval &s) throw(); 02088 INLINE l_ivector operator *(const interval &s, const l_ivector &rv) throw(); 02090 INLINE l_ivector operator *(const interval &s, const l_ivector_slice &sl) throw(); 02092 INLINE l_ivector &operator *=(l_ivector &rv,const interval &r) throw(); 02093 02095 INLINE l_ivector operator /(const l_ivector &rv, const interval &s) throw(); 02097 INLINE l_ivector operator /(const l_ivector_slice &sl, const interval &s) throw(); 02099 INLINE l_ivector &operator /=(l_ivector &rv,const interval &r) throw(); 02100 02102 INLINE l_ivector operator *(const ivector &rv, const l_interval &s) throw(); 02104 INLINE l_ivector operator *(const ivector_slice &sl, const l_interval &s) throw(); 02106 INLINE l_ivector operator *(const l_interval &s, const ivector &rv) throw(); 02108 INLINE l_ivector operator *(const l_interval &s, const ivector_slice &sl) throw(); 02109 02111 INLINE l_ivector operator /(const ivector &rv, const l_interval &s) throw(); 02113 INLINE l_ivector operator /(const ivector_slice &sl, const l_interval &s) throw(); 02114 02115 //======================= Vector / Vector =============================== 02116 02117 02119 INLINE std::ostream &operator <<(std::ostream &s, const l_ivector &rv) throw(); 02121 INLINE std::ostream &operator <<(std::ostream &o, const l_ivector_slice &sl) throw(); 02123 INLINE std::istream &operator >>(std::istream &s, l_ivector &rv) throw(); 02125 INLINE std::istream &operator >>(std::istream &s, l_ivector_slice &rv) throw(); 02126 02127 //----------------------- l_interval / l_interval --------------------------- 02128 02130 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_ivector &rv2) 02131 #if(CXSC_INDEX_CHECK) 02132 throw(OP_WITH_WRONG_DIM); 02133 #else 02134 throw(); 02135 #endif 02136 02137 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl, const l_ivector &rv) 02138 #if(CXSC_INDEX_CHECK) 02139 throw(OP_WITH_WRONG_DIM); 02140 #else 02141 throw(); 02142 #endif 02143 02144 INLINE void accumulate(idotprecision &dp, const l_ivector &rv, const l_ivector_slice &sl) 02145 #if(CXSC_INDEX_CHECK) 02146 throw(OP_WITH_WRONG_DIM); 02147 #else 02148 throw(); 02149 #endif 02150 02151 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2) 02152 #if(CXSC_INDEX_CHECK) 02153 throw(OP_WITH_WRONG_DIM); 02154 #else 02155 throw(); 02156 #endif 02157 02158 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2) 02159 #if(CXSC_INDEX_CHECK) 02160 throw(OP_WITH_WRONG_DIM); 02161 #else 02162 throw(); 02163 #endif 02164 02165 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_ivector_slice &sl2) 02166 #if(CXSC_INDEX_CHECK) 02167 throw(OP_WITH_WRONG_DIM); 02168 #else 02169 throw(); 02170 #endif 02171 02173 INLINE l_interval operator *(const l_ivector & rv1, const l_ivector &rv2) 02174 #if(CXSC_INDEX_CHECK) 02175 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02176 #else 02177 throw(); 02178 #endif 02179 02180 INLINE l_interval operator *(const l_ivector_slice &sl, const l_ivector &rv) 02181 #if(CXSC_INDEX_CHECK) 02182 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02183 #else 02184 throw(); 02185 #endif 02186 02187 INLINE l_interval operator *(const l_ivector &rv, const l_ivector_slice &sl) 02188 #if(CXSC_INDEX_CHECK) 02189 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02190 #else 02191 throw(); 02192 #endif 02193 02194 INLINE l_interval operator *(const l_ivector_slice & sl1, const l_ivector_slice &sl2) 02195 #if(CXSC_INDEX_CHECK) 02196 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02197 #else 02198 throw(); 02199 #endif 02200 02202 INLINE const l_ivector &operator +(const l_ivector &rv) throw(); 02204 INLINE l_ivector operator +(const l_ivector_slice &sl) throw(); 02205 02207 INLINE l_ivector operator +(const l_ivector &rv1, const l_ivector &rv2) 02208 #if(CXSC_INDEX_CHECK) 02209 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02210 #else 02211 throw(); 02212 #endif 02213 02214 INLINE l_ivector operator +(const l_ivector &rv, const l_ivector_slice &sl) 02215 #if(CXSC_INDEX_CHECK) 02216 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02217 #else 02218 throw(); 02219 #endif 02220 02221 INLINE l_ivector operator +(const l_ivector_slice &sl, const l_ivector &rv) 02222 #if(CXSC_INDEX_CHECK) 02223 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02224 #else 02225 throw(); 02226 #endif 02227 02228 INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_ivector_slice &sl2) 02229 #if(CXSC_INDEX_CHECK) 02230 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02231 #else 02232 throw(); 02233 #endif 02234 02235 INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2) 02236 #if(CXSC_INDEX_CHECK) 02237 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02238 #else 02239 throw(); 02240 #endif 02241 02242 INLINE l_ivector &operator +=(l_ivector &rv, const l_ivector_slice &sl) 02243 #if(CXSC_INDEX_CHECK) 02244 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02245 #else 02246 throw(); 02247 #endif 02248 02250 INLINE l_ivector operator -(const l_ivector &rv) throw(); 02252 INLINE l_ivector operator -(const l_ivector_slice &sl) throw(); 02254 INLINE l_ivector operator -(const l_ivector &rv1, const l_ivector &rv2) 02255 #if(CXSC_INDEX_CHECK) 02256 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02257 #else 02258 throw(); 02259 #endif 02260 02261 INLINE l_ivector operator -(const l_ivector &rv, const l_ivector_slice &sl) 02262 #if(CXSC_INDEX_CHECK) 02263 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02264 #else 02265 throw(); 02266 #endif 02267 02268 INLINE l_ivector operator -(const l_ivector_slice &sl, const l_ivector &rv) 02269 #if(CXSC_INDEX_CHECK) 02270 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02271 #else 02272 throw(); 02273 #endif 02274 02275 INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_ivector_slice &sl2) 02276 #if(CXSC_INDEX_CHECK) 02277 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02278 #else 02279 throw(); 02280 #endif 02281 02282 INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2) 02283 #if(CXSC_INDEX_CHECK) 02284 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02285 #else 02286 throw(); 02287 #endif 02288 02289 INLINE l_ivector &operator -=(l_ivector &rv, const l_ivector_slice &sl) 02290 #if(CXSC_INDEX_CHECK) 02291 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02292 #else 02293 throw(); 02294 #endif 02295 02297 INLINE l_ivector operator |(const l_ivector &rv1, const l_ivector &rv2) 02298 #if(CXSC_INDEX_CHECK) 02299 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02300 #else 02301 throw(); 02302 #endif 02303 02304 INLINE l_ivector operator |(const l_ivector &rv, const l_ivector_slice &sl) 02305 #if(CXSC_INDEX_CHECK) 02306 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02307 #else 02308 throw(); 02309 #endif 02310 02311 INLINE l_ivector operator |(const l_ivector_slice &sl, const l_ivector &rv) 02312 #if(CXSC_INDEX_CHECK) 02313 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02314 #else 02315 throw(); 02316 #endif 02317 02318 INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_ivector_slice &sl2) 02319 #if(CXSC_INDEX_CHECK) 02320 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02321 #else 02322 throw(); 02323 #endif 02324 02325 INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2) 02326 #if(CXSC_INDEX_CHECK) 02327 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02328 #else 02329 throw(); 02330 #endif 02331 02332 INLINE l_ivector &operator |=(l_ivector &rv, const l_ivector_slice &sl) 02333 #if(CXSC_INDEX_CHECK) 02334 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02335 #else 02336 throw(); 02337 #endif 02338 02340 INLINE l_ivector operator &(const l_ivector &rv1, const l_ivector &rv2) 02341 #if(CXSC_INDEX_CHECK) 02342 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02343 #else 02344 throw(); 02345 #endif 02346 02347 INLINE l_ivector operator &(const l_ivector &rv, const l_ivector_slice &sl) 02348 #if(CXSC_INDEX_CHECK) 02349 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02350 #else 02351 throw(); 02352 #endif 02353 02354 INLINE l_ivector operator &(const l_ivector_slice &sl, const l_ivector &rv) 02355 #if(CXSC_INDEX_CHECK) 02356 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02357 #else 02358 throw(); 02359 #endif 02360 02361 INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_ivector_slice &sl2) 02362 #if(CXSC_INDEX_CHECK) 02363 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02364 #else 02365 throw(); 02366 #endif 02367 02368 INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2) 02369 #if(CXSC_INDEX_CHECK) 02370 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02371 #else 02372 throw(); 02373 #endif 02374 02375 INLINE l_ivector &operator &=(l_ivector &rv, const l_ivector_slice &sl) 02376 #if(CXSC_INDEX_CHECK) 02377 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02378 #else 02379 throw(); 02380 #endif 02381 02383 INLINE bool operator ==(const l_ivector &rv1, const l_ivector &rv2) throw(); 02385 INLINE bool operator ==(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw(); 02387 INLINE bool operator ==(const l_ivector_slice &sl, const l_ivector &rv) throw(); 02389 INLINE bool operator ==(const l_ivector &rv, const l_ivector_slice &sl) throw(); 02391 INLINE bool operator !=(const l_ivector &rv1, const l_ivector &rv2) throw(); 02393 INLINE bool operator !=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw(); 02395 INLINE bool operator !=(const l_ivector_slice &sl, const l_ivector &rv) throw(); 02397 INLINE bool operator !=(const l_ivector &rv, const l_ivector_slice &sl) throw(); 02399 INLINE bool operator <(const l_ivector &rv1, const l_ivector &rv2) throw(); 02401 INLINE bool operator <(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw(); 02403 INLINE bool operator < (const l_ivector_slice &sl, const l_ivector &rv) throw(); 02405 INLINE bool operator < (const l_ivector &rv, const l_ivector_slice &sl) throw(); 02407 INLINE bool operator <=(const l_ivector &rv1, const l_ivector &rv2) throw(); 02409 INLINE bool operator <=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw(); 02411 INLINE bool operator <=(const l_ivector_slice &sl, const l_ivector &rv) throw(); 02413 INLINE bool operator <=(const l_ivector &rv, const l_ivector_slice &sl) throw(); 02415 INLINE bool operator >(const l_ivector &rv1, const l_ivector &rv2) throw(); 02417 INLINE bool operator >(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw(); 02419 INLINE bool operator >(const l_ivector_slice &sl, const l_ivector &rv) throw(); 02421 INLINE bool operator >(const l_ivector &rv, const l_ivector_slice &sl) throw(); 02423 INLINE bool operator >=(const l_ivector &rv1, const l_ivector &rv2) throw(); 02425 INLINE bool operator >=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw(); 02427 INLINE bool operator >=(const l_ivector_slice &sl, const l_ivector &rv) throw(); 02429 INLINE bool operator >=(const l_ivector &rv, const l_ivector_slice &sl) throw(); 02430 02431 //-------------------------------- l_interval / Real -------------------------------- 02432 02434 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_ivector &rv2) 02435 #if(CXSC_INDEX_CHECK) 02436 throw(OP_WITH_WRONG_DIM); 02437 #else 02438 throw(); 02439 #endif 02440 02441 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2) 02442 #if(CXSC_INDEX_CHECK) 02443 throw(OP_WITH_WRONG_DIM); 02444 #else 02445 throw(); 02446 #endif 02447 02448 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_ivector &rv) 02449 #if(CXSC_INDEX_CHECK) 02450 throw(OP_WITH_WRONG_DIM); 02451 #else 02452 throw(); 02453 #endif 02454 02455 INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const rvector &rv) 02456 #if(CXSC_INDEX_CHECK) 02457 throw(OP_WITH_WRONG_DIM); 02458 #else 02459 throw(); 02460 #endif 02461 02462 INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_ivector_slice &sl) 02463 #if(CXSC_INDEX_CHECK) 02464 throw(OP_WITH_WRONG_DIM); 02465 #else 02466 throw(); 02467 #endif 02468 02469 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2) 02470 #if(CXSC_INDEX_CHECK) 02471 throw(OP_WITH_WRONG_DIM); 02472 #else 02473 throw(); 02474 #endif 02475 02476 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2) 02477 #if(CXSC_INDEX_CHECK) 02478 throw(OP_WITH_WRONG_DIM); 02479 #else 02480 throw(); 02481 #endif 02482 02483 INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const rvector_slice &sl) 02484 #if(CXSC_INDEX_CHECK) 02485 throw(OP_WITH_WRONG_DIM); 02486 #else 02487 throw(); 02488 #endif 02489 02490 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2) 02491 #if(CXSC_INDEX_CHECK) 02492 throw(OP_WITH_WRONG_DIM); 02493 #else 02494 throw(); 02495 #endif 02496 02497 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2) 02498 #if(CXSC_INDEX_CHECK) 02499 throw(OP_WITH_WRONG_DIM); 02500 #else 02501 throw(); 02502 #endif 02503 02504 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const rvector_slice &sl2) 02505 #if(CXSC_INDEX_CHECK) 02506 throw(OP_WITH_WRONG_DIM); 02507 #else 02508 throw(); 02509 #endif 02510 02511 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_ivector_slice &sl2) 02512 #if(CXSC_INDEX_CHECK) 02513 throw(OP_WITH_WRONG_DIM); 02514 #else 02515 throw(); 02516 #endif 02517 02519 INLINE l_interval operator *(const rvector & rv1, const l_ivector &rv2) 02520 #if(CXSC_INDEX_CHECK) 02521 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02522 #else 02523 throw(); 02524 #endif 02525 02526 INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv) 02527 #if(CXSC_INDEX_CHECK) 02528 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02529 #else 02530 throw(); 02531 #endif 02532 02533 INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl) 02534 #if(CXSC_INDEX_CHECK) 02535 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02536 #else 02537 throw(); 02538 #endif 02539 02540 INLINE l_interval operator *(const rvector_slice & sl1, const l_ivector_slice &sl2) 02541 #if(CXSC_INDEX_CHECK) 02542 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02543 #else 02544 throw(); 02545 #endif 02546 02548 INLINE l_interval operator *(const l_ivector & rv1, const rvector &rv2) 02549 #if(CXSC_INDEX_CHECK) 02550 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02551 #else 02552 throw(); 02553 #endif 02554 02555 INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv) 02556 #if(CXSC_INDEX_CHECK) 02557 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02558 #else 02559 throw(); 02560 #endif 02561 02562 INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl) 02563 #if(CXSC_INDEX_CHECK) 02564 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02565 #else 02566 throw(); 02567 #endif 02568 02569 INLINE l_interval operator *(const l_ivector_slice & sl1, const rvector_slice &sl2) 02570 #if(CXSC_INDEX_CHECK) 02571 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02572 #else 02573 throw(); 02574 #endif 02575 02577 INLINE l_ivector operator +(const rvector &rv1, const l_ivector &rv2) 02578 #if(CXSC_INDEX_CHECK) 02579 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02580 #else 02581 throw(); 02582 #endif 02583 02584 INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl) 02585 #if(CXSC_INDEX_CHECK) 02586 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02587 #else 02588 throw(); 02589 #endif 02590 02591 INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv) 02592 #if(CXSC_INDEX_CHECK) 02593 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02594 #else 02595 throw(); 02596 #endif 02597 02598 INLINE l_ivector operator +(const rvector_slice &sl1, const l_ivector_slice &sl2) 02599 #if(CXSC_INDEX_CHECK) 02600 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02601 #else 02602 throw(); 02603 #endif 02604 02606 INLINE l_ivector operator +(const l_ivector &rv1, const rvector &rv2) 02607 #if(CXSC_INDEX_CHECK) 02608 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02609 #else 02610 throw(); 02611 #endif 02612 02613 INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl) 02614 #if(CXSC_INDEX_CHECK) 02615 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02616 #else 02617 throw(); 02618 #endif 02619 02620 INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv) 02621 #if(CXSC_INDEX_CHECK) 02622 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02623 #else 02624 throw(); 02625 #endif 02626 02627 INLINE l_ivector operator +(const l_ivector_slice &sl1, const rvector_slice &sl2) 02628 #if(CXSC_INDEX_CHECK) 02629 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02630 #else 02631 throw(); 02632 #endif 02633 02635 INLINE l_ivector & operator +=(l_ivector &rv1, const rvector &rv2) 02636 #if(CXSC_INDEX_CHECK) 02637 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02638 #else 02639 throw(); 02640 #endif 02641 02642 INLINE l_ivector &operator +=(l_ivector &rv, const rvector_slice &sl) 02643 #if(CXSC_INDEX_CHECK) 02644 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02645 #else 02646 throw(); 02647 #endif 02648 02650 INLINE l_ivector operator -(const rvector &rv1, const l_ivector &rv2) 02651 #if(CXSC_INDEX_CHECK) 02652 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02653 #else 02654 throw(); 02655 #endif 02656 02657 INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl) 02658 #if(CXSC_INDEX_CHECK) 02659 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02660 #else 02661 throw(); 02662 #endif 02663 02664 INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv) 02665 #if(CXSC_INDEX_CHECK) 02666 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02667 #else 02668 throw(); 02669 #endif 02670 02671 INLINE l_ivector operator -(const rvector_slice &sl1, const l_ivector_slice &sl2) 02672 #if(CXSC_INDEX_CHECK) 02673 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02674 #else 02675 throw(); 02676 #endif 02677 02679 INLINE l_ivector operator -(const l_ivector &rv1, const rvector &rv2) 02680 #if(CXSC_INDEX_CHECK) 02681 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02682 #else 02683 throw(); 02684 #endif 02685 02686 INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl) 02687 #if(CXSC_INDEX_CHECK) 02688 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02689 #else 02690 throw(); 02691 #endif 02692 02693 INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv) 02694 #if(CXSC_INDEX_CHECK) 02695 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02696 #else 02697 throw(); 02698 #endif 02699 02700 INLINE l_ivector operator -(const l_ivector_slice &sl1, const rvector_slice &sl2) 02701 #if(CXSC_INDEX_CHECK) 02702 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02703 #else 02704 throw(); 02705 #endif 02706 02708 INLINE l_ivector & operator -=(l_ivector &rv1, const rvector &rv2) 02709 #if(CXSC_INDEX_CHECK) 02710 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02711 #else 02712 throw(); 02713 #endif 02714 02715 INLINE l_ivector &operator -=(l_ivector &rv, const rvector_slice &sl) 02716 #if(CXSC_INDEX_CHECK) 02717 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02718 #else 02719 throw(); 02720 #endif 02721 02723 INLINE l_ivector operator |(const rvector &rv1, const l_ivector &rv2) 02724 #if(CXSC_INDEX_CHECK) 02725 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02726 #else 02727 throw(); 02728 #endif 02729 02730 INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl) 02731 #if(CXSC_INDEX_CHECK) 02732 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02733 #else 02734 throw(); 02735 #endif 02736 02737 INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv) 02738 #if(CXSC_INDEX_CHECK) 02739 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02740 #else 02741 throw(); 02742 #endif 02743 02744 INLINE l_ivector operator |(const rvector_slice &sl1, const l_ivector_slice &sl2) 02745 #if(CXSC_INDEX_CHECK) 02746 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02747 #else 02748 throw(); 02749 #endif 02750 02752 INLINE l_ivector operator |(const l_ivector &rv1, const rvector &rv2) 02753 #if(CXSC_INDEX_CHECK) 02754 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02755 #else 02756 throw(); 02757 #endif 02758 02759 INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl) 02760 #if(CXSC_INDEX_CHECK) 02761 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02762 #else 02763 throw(); 02764 #endif 02765 02766 INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv) 02767 #if(CXSC_INDEX_CHECK) 02768 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02769 #else 02770 throw(); 02771 #endif 02772 02773 INLINE l_ivector operator |(const l_ivector_slice &sl1, const rvector_slice &sl2) 02774 #if(CXSC_INDEX_CHECK) 02775 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02776 #else 02777 throw(); 02778 #endif 02779 02781 INLINE l_ivector & operator |=(l_ivector &rv1, const rvector &rv2) 02782 #if(CXSC_INDEX_CHECK) 02783 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02784 #else 02785 throw(); 02786 #endif 02787 02788 INLINE l_ivector &operator |=(l_ivector &rv, const rvector_slice &sl) 02789 #if(CXSC_INDEX_CHECK) 02790 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02791 #else 02792 throw(); 02793 #endif 02794 02796 INLINE l_ivector operator &(const rvector &rv1, const l_ivector &rv2) 02797 #if(CXSC_INDEX_CHECK) 02798 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02799 #else 02800 throw(); 02801 #endif 02802 02803 INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl) 02804 #if(CXSC_INDEX_CHECK) 02805 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02806 #else 02807 throw(); 02808 #endif 02809 02810 INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv) 02811 #if(CXSC_INDEX_CHECK) 02812 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02813 #else 02814 throw(); 02815 #endif 02816 02817 INLINE l_ivector operator &(const rvector_slice &sl1, const l_ivector_slice &sl2) 02818 #if(CXSC_INDEX_CHECK) 02819 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02820 #else 02821 throw(); 02822 #endif 02823 02825 INLINE l_ivector operator &(const l_ivector &rv1, const rvector &rv2) 02826 #if(CXSC_INDEX_CHECK) 02827 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02828 #else 02829 throw(); 02830 #endif 02831 02832 INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl) 02833 #if(CXSC_INDEX_CHECK) 02834 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02835 #else 02836 throw(); 02837 #endif 02838 02839 INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv) 02840 #if(CXSC_INDEX_CHECK) 02841 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02842 #else 02843 throw(); 02844 #endif 02845 02846 INLINE l_ivector operator &(const l_ivector_slice &sl1, const rvector_slice &sl2) 02847 #if(CXSC_INDEX_CHECK) 02848 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02849 #else 02850 throw(); 02851 #endif 02852 02854 INLINE l_ivector & operator &=(l_ivector &rv1, const rvector &rv2) 02855 #if(CXSC_INDEX_CHECK) 02856 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02857 #else 02858 throw(); 02859 #endif 02860 02861 INLINE l_ivector &operator &=(l_ivector &rv, const rvector_slice &sl) 02862 #if(CXSC_INDEX_CHECK) 02863 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02864 #else 02865 throw(); 02866 #endif 02867 //-------------------------------- l_interval / l_real -------------------------------- 02868 02870 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_ivector &rv2) 02871 #if(CXSC_INDEX_CHECK) 02872 throw(OP_WITH_WRONG_DIM); 02873 #else 02874 throw(); 02875 #endif 02876 02877 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rvector &rv2) 02878 #if(CXSC_INDEX_CHECK) 02879 throw(OP_WITH_WRONG_DIM); 02880 #else 02881 throw(); 02882 #endif 02883 02884 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_ivector &rv) 02885 #if(CXSC_INDEX_CHECK) 02886 throw(OP_WITH_WRONG_DIM); 02887 #else 02888 throw(); 02889 #endif 02890 02891 INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const l_rvector &rv) 02892 #if(CXSC_INDEX_CHECK) 02893 throw(OP_WITH_WRONG_DIM); 02894 #else 02895 throw(); 02896 #endif 02897 02898 INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_ivector_slice &sl) 02899 #if(CXSC_INDEX_CHECK) 02900 throw(OP_WITH_WRONG_DIM); 02901 #else 02902 throw(); 02903 #endif 02904 02905 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2) 02906 #if(CXSC_INDEX_CHECK) 02907 throw(OP_WITH_WRONG_DIM); 02908 #else 02909 throw(); 02910 #endif 02911 02912 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rmatrix_subv &rv2) 02913 #if(CXSC_INDEX_CHECK) 02914 throw(OP_WITH_WRONG_DIM); 02915 #else 02916 throw(); 02917 #endif 02918 02919 INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const l_rvector_slice &sl) 02920 #if(CXSC_INDEX_CHECK) 02921 throw(OP_WITH_WRONG_DIM); 02922 #else 02923 throw(); 02924 #endif 02925 02926 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_ivector &rv2) 02927 #if(CXSC_INDEX_CHECK) 02928 throw(OP_WITH_WRONG_DIM); 02929 #else 02930 throw(); 02931 #endif 02932 02933 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2) 02934 #if(CXSC_INDEX_CHECK) 02935 throw(OP_WITH_WRONG_DIM); 02936 #else 02937 throw(); 02938 #endif 02939 02940 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_rvector_slice &sl2) 02941 #if(CXSC_INDEX_CHECK) 02942 throw(OP_WITH_WRONG_DIM); 02943 #else 02944 throw(); 02945 #endif 02946 02947 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_ivector_slice &sl2) 02948 #if(CXSC_INDEX_CHECK) 02949 throw(OP_WITH_WRONG_DIM); 02950 #else 02951 throw(); 02952 #endif 02953 02955 INLINE l_interval operator *(const l_rvector & rv1, const l_ivector &rv2) 02956 #if(CXSC_INDEX_CHECK) 02957 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02958 #else 02959 throw(); 02960 #endif 02961 02962 INLINE l_interval operator *(const l_rvector_slice &sl, const l_ivector &rv) 02963 #if(CXSC_INDEX_CHECK) 02964 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02965 #else 02966 throw(); 02967 #endif 02968 02969 INLINE l_interval operator *(const l_rvector &rv, const l_ivector_slice &sl) 02970 #if(CXSC_INDEX_CHECK) 02971 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02972 #else 02973 throw(); 02974 #endif 02975 02976 INLINE l_interval operator *(const l_rvector_slice & sl1, const l_ivector_slice &sl2) 02977 #if(CXSC_INDEX_CHECK) 02978 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02979 #else 02980 throw(); 02981 #endif 02982 02984 INLINE l_interval operator *(const l_ivector & rv1, const l_rvector &rv2) 02985 #if(CXSC_INDEX_CHECK) 02986 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02987 #else 02988 throw(); 02989 #endif 02990 02991 INLINE l_interval operator *(const l_ivector_slice &sl, const l_rvector &rv) 02992 #if(CXSC_INDEX_CHECK) 02993 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 02994 #else 02995 throw(); 02996 #endif 02997 02998 INLINE l_interval operator *(const l_ivector &rv, const l_rvector_slice &sl) 02999 #if(CXSC_INDEX_CHECK) 03000 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03001 #else 03002 throw(); 03003 #endif 03004 03005 INLINE l_interval operator *(const l_ivector_slice & sl1, const l_rvector_slice &sl2) 03006 #if(CXSC_INDEX_CHECK) 03007 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03008 #else 03009 throw(); 03010 #endif 03011 03013 INLINE l_ivector operator +(const l_rvector &rv1, const l_ivector &rv2) 03014 #if(CXSC_INDEX_CHECK) 03015 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03016 #else 03017 throw(); 03018 #endif 03019 03020 INLINE l_ivector operator +(const l_rvector &rv, const l_ivector_slice &sl) 03021 #if(CXSC_INDEX_CHECK) 03022 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03023 #else 03024 throw(); 03025 #endif 03026 03027 INLINE l_ivector operator +(const l_rvector_slice &sl, const l_ivector &rv) 03028 #if(CXSC_INDEX_CHECK) 03029 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03030 #else 03031 throw(); 03032 #endif 03033 03034 INLINE l_ivector operator +(const l_rvector_slice &sl1, const l_ivector_slice &sl2) 03035 #if(CXSC_INDEX_CHECK) 03036 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03037 #else 03038 throw(); 03039 #endif 03040 03042 INLINE l_ivector operator +(const l_ivector &rv1, const l_rvector &rv2) 03043 #if(CXSC_INDEX_CHECK) 03044 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03045 #else 03046 throw(); 03047 #endif 03048 03049 INLINE l_ivector operator +(const l_ivector &rv, const l_rvector_slice &sl) 03050 #if(CXSC_INDEX_CHECK) 03051 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03052 #else 03053 throw(); 03054 #endif 03055 03056 INLINE l_ivector operator +(const l_ivector_slice &sl, const l_rvector &rv) 03057 #if(CXSC_INDEX_CHECK) 03058 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03059 #else 03060 throw(); 03061 #endif 03062 03063 INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_rvector_slice &sl2) 03064 #if(CXSC_INDEX_CHECK) 03065 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03066 #else 03067 throw(); 03068 #endif 03069 03071 INLINE l_ivector & operator +=(l_ivector &rv1, const l_rvector &rv2) 03072 #if(CXSC_INDEX_CHECK) 03073 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03074 #else 03075 throw(); 03076 #endif 03077 03078 INLINE l_ivector &operator +=(l_ivector &rv, const l_rvector_slice &sl) 03079 #if(CXSC_INDEX_CHECK) 03080 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03081 #else 03082 throw(); 03083 #endif 03084 03086 INLINE l_ivector operator -(const l_rvector &rv1, const l_ivector &rv2) 03087 #if(CXSC_INDEX_CHECK) 03088 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03089 #else 03090 throw(); 03091 #endif 03092 03093 INLINE l_ivector operator -(const l_rvector &rv, const l_ivector_slice &sl) 03094 #if(CXSC_INDEX_CHECK) 03095 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03096 #else 03097 throw(); 03098 #endif 03099 03100 INLINE l_ivector operator -(const l_rvector_slice &sl, const l_ivector &rv) 03101 #if(CXSC_INDEX_CHECK) 03102 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03103 #else 03104 throw(); 03105 #endif 03106 03107 INLINE l_ivector operator -(const l_rvector_slice &sl1, const l_ivector_slice &sl2) 03108 #if(CXSC_INDEX_CHECK) 03109 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03110 #else 03111 throw(); 03112 #endif 03113 03115 INLINE l_ivector operator -(const l_ivector &rv1, const l_rvector &rv2) 03116 #if(CXSC_INDEX_CHECK) 03117 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03118 #else 03119 throw(); 03120 #endif 03121 03122 INLINE l_ivector operator -(const l_ivector &rv, const l_rvector_slice &sl) 03123 #if(CXSC_INDEX_CHECK) 03124 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03125 #else 03126 throw(); 03127 #endif 03128 03129 INLINE l_ivector operator -(const l_ivector_slice &sl, const l_rvector &rv) 03130 #if(CXSC_INDEX_CHECK) 03131 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03132 #else 03133 throw(); 03134 #endif 03135 03136 INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_rvector_slice &sl2) 03137 #if(CXSC_INDEX_CHECK) 03138 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03139 #else 03140 throw(); 03141 #endif 03142 03144 INLINE l_ivector & operator -=(l_ivector &rv1, const l_rvector &rv2) 03145 #if(CXSC_INDEX_CHECK) 03146 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03147 #else 03148 throw(); 03149 #endif 03150 03151 INLINE l_ivector &operator -=(l_ivector &rv, const l_rvector_slice &sl) 03152 #if(CXSC_INDEX_CHECK) 03153 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03154 #else 03155 throw(); 03156 #endif 03157 03159 INLINE l_ivector operator |(const l_rvector &rv1, const l_ivector &rv2) 03160 #if(CXSC_INDEX_CHECK) 03161 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03162 #else 03163 throw(); 03164 #endif 03165 03166 INLINE l_ivector operator |(const l_rvector &rv, const l_ivector_slice &sl) 03167 #if(CXSC_INDEX_CHECK) 03168 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03169 #else 03170 throw(); 03171 #endif 03172 03173 INLINE l_ivector operator |(const l_rvector_slice &sl, const l_ivector &rv) 03174 #if(CXSC_INDEX_CHECK) 03175 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03176 #else 03177 throw(); 03178 #endif 03179 03180 INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_ivector_slice &sl2) 03181 #if(CXSC_INDEX_CHECK) 03182 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03183 #else 03184 throw(); 03185 #endif 03186 03188 INLINE l_ivector operator |(const l_ivector &rv1, const l_rvector &rv2) 03189 #if(CXSC_INDEX_CHECK) 03190 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03191 #else 03192 throw(); 03193 #endif 03194 03195 INLINE l_ivector operator |(const l_ivector &rv, const l_rvector_slice &sl) 03196 #if(CXSC_INDEX_CHECK) 03197 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03198 #else 03199 throw(); 03200 #endif 03201 03202 INLINE l_ivector operator |(const l_ivector_slice &sl, const l_rvector &rv) 03203 #if(CXSC_INDEX_CHECK) 03204 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03205 #else 03206 throw(); 03207 #endif 03208 03209 INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_rvector_slice &sl2) 03210 #if(CXSC_INDEX_CHECK) 03211 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03212 #else 03213 throw(); 03214 #endif 03215 03217 INLINE l_ivector & operator |=(l_ivector &rv1, const l_rvector &rv2) 03218 #if(CXSC_INDEX_CHECK) 03219 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03220 #else 03221 throw(); 03222 #endif 03223 03224 INLINE l_ivector &operator |=(l_ivector &rv, const l_rvector_slice &sl) 03225 #if(CXSC_INDEX_CHECK) 03226 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03227 #else 03228 throw(); 03229 #endif 03230 03232 INLINE l_ivector operator &(const l_rvector &rv1, const l_ivector &rv2) 03233 #if(CXSC_INDEX_CHECK) 03234 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03235 #else 03236 throw(); 03237 #endif 03238 03239 INLINE l_ivector operator &(const l_rvector &rv, const l_ivector_slice &sl) 03240 #if(CXSC_INDEX_CHECK) 03241 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03242 #else 03243 throw(); 03244 #endif 03245 03246 INLINE l_ivector operator &(const l_rvector_slice &sl, const l_ivector &rv) 03247 #if(CXSC_INDEX_CHECK) 03248 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03249 #else 03250 throw(); 03251 #endif 03252 03253 INLINE l_ivector operator &(const l_rvector_slice &sl1, const l_ivector_slice &sl2) 03254 #if(CXSC_INDEX_CHECK) 03255 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03256 #else 03257 throw(); 03258 #endif 03259 03261 INLINE l_ivector operator &(const l_ivector &rv1, const l_rvector &rv2) 03262 #if(CXSC_INDEX_CHECK) 03263 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03264 #else 03265 throw(); 03266 #endif 03267 03268 INLINE l_ivector operator &(const l_ivector &rv, const l_rvector_slice &sl) 03269 #if(CXSC_INDEX_CHECK) 03270 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03271 #else 03272 throw(); 03273 #endif 03274 03275 INLINE l_ivector operator &(const l_ivector_slice &sl, const l_rvector &rv) 03276 #if(CXSC_INDEX_CHECK) 03277 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03278 #else 03279 throw(); 03280 #endif 03281 03282 INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_rvector_slice &sl2) 03283 #if(CXSC_INDEX_CHECK) 03284 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03285 #else 03286 throw(); 03287 #endif 03288 03290 INLINE l_ivector & operator &=(l_ivector &rv1, const l_rvector &rv2) 03291 #if(CXSC_INDEX_CHECK) 03292 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03293 #else 03294 throw(); 03295 #endif 03296 03297 INLINE l_ivector &operator &=(l_ivector &rv, const l_rvector_slice &sl) 03298 #if(CXSC_INDEX_CHECK) 03299 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03300 #else 03301 throw(); 03302 #endif 03303 03304 //-------------------------------- l_interval / interval -------------------------------- 03305 03307 INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_ivector &rv2) 03308 #if(CXSC_INDEX_CHECK) 03309 throw(OP_WITH_WRONG_DIM); 03310 #else 03311 throw(); 03312 #endif 03313 03314 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2) 03315 #if(CXSC_INDEX_CHECK) 03316 throw(OP_WITH_WRONG_DIM); 03317 #else 03318 throw(); 03319 #endif 03320 03321 INLINE void accumulate(idotprecision &dp, const ivector_slice & sl, const l_ivector &rv) 03322 #if(CXSC_INDEX_CHECK) 03323 throw(OP_WITH_WRONG_DIM); 03324 #else 03325 throw(); 03326 #endif 03327 03328 INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const ivector &rv) 03329 #if(CXSC_INDEX_CHECK) 03330 throw(OP_WITH_WRONG_DIM); 03331 #else 03332 throw(); 03333 #endif 03334 03335 INLINE void accumulate(idotprecision &dp, const ivector &rv, const l_ivector_slice &sl) 03336 #if(CXSC_INDEX_CHECK) 03337 throw(OP_WITH_WRONG_DIM); 03338 #else 03339 throw(); 03340 #endif 03341 03342 INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2) 03343 #if(CXSC_INDEX_CHECK) 03344 throw(OP_WITH_WRONG_DIM); 03345 #else 03346 throw(); 03347 #endif 03348 03349 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const imatrix_subv &rv2) 03350 #if(CXSC_INDEX_CHECK) 03351 throw(OP_WITH_WRONG_DIM); 03352 #else 03353 throw(); 03354 #endif 03355 03356 INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const ivector_slice &sl) 03357 #if(CXSC_INDEX_CHECK) 03358 throw(OP_WITH_WRONG_DIM); 03359 #else 03360 throw(); 03361 #endif 03362 03363 INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_ivector &rv2) 03364 #if(CXSC_INDEX_CHECK) 03365 throw(OP_WITH_WRONG_DIM); 03366 #else 03367 throw(); 03368 #endif 03369 03370 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2) 03371 #if(CXSC_INDEX_CHECK) 03372 throw(OP_WITH_WRONG_DIM); 03373 #else 03374 throw(); 03375 #endif 03376 03377 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const ivector_slice &sl2) 03378 #if(CXSC_INDEX_CHECK) 03379 throw(OP_WITH_WRONG_DIM); 03380 #else 03381 throw(); 03382 #endif 03383 03384 INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_ivector_slice &sl2) 03385 #if(CXSC_INDEX_CHECK) 03386 throw(OP_WITH_WRONG_DIM); 03387 #else 03388 throw(); 03389 #endif 03390 03392 INLINE l_interval operator *(const ivector & rv1, const l_ivector &rv2) 03393 #if(CXSC_INDEX_CHECK) 03394 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03395 #else 03396 throw(); 03397 #endif 03398 03399 INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv) 03400 #if(CXSC_INDEX_CHECK) 03401 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03402 #else 03403 throw(); 03404 #endif 03405 03406 INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl) 03407 #if(CXSC_INDEX_CHECK) 03408 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03409 #else 03410 throw(); 03411 #endif 03412 03413 INLINE l_interval operator *(const ivector_slice & sl1, const l_ivector_slice &sl2) 03414 #if(CXSC_INDEX_CHECK) 03415 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03416 #else 03417 throw(); 03418 #endif 03419 03421 INLINE l_interval operator *(const l_ivector & rv1, const ivector &rv2) 03422 #if(CXSC_INDEX_CHECK) 03423 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03424 #else 03425 throw(); 03426 #endif 03427 03428 INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv) 03429 #if(CXSC_INDEX_CHECK) 03430 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03431 #else 03432 throw(); 03433 #endif 03434 03435 INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl) 03436 #if(CXSC_INDEX_CHECK) 03437 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03438 #else 03439 throw(); 03440 #endif 03441 03442 INLINE l_interval operator *(const l_ivector_slice & sl1, const ivector_slice &sl2) 03443 #if(CXSC_INDEX_CHECK) 03444 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03445 #else 03446 throw(); 03447 #endif 03448 03450 INLINE l_ivector operator +(const ivector &rv1, const l_ivector &rv2) 03451 #if(CXSC_INDEX_CHECK) 03452 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03453 #else 03454 throw(); 03455 #endif 03456 03457 INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl) 03458 #if(CXSC_INDEX_CHECK) 03459 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03460 #else 03461 throw(); 03462 #endif 03463 03464 INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv) 03465 #if(CXSC_INDEX_CHECK) 03466 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03467 #else 03468 throw(); 03469 #endif 03470 03471 INLINE l_ivector operator +(const ivector_slice &sl1, const l_ivector_slice &sl2) 03472 #if(CXSC_INDEX_CHECK) 03473 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03474 #else 03475 throw(); 03476 #endif 03477 03479 INLINE l_ivector operator +(const l_ivector &rv1, const ivector &rv2) 03480 #if(CXSC_INDEX_CHECK) 03481 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03482 #else 03483 throw(); 03484 #endif 03485 03486 INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl) 03487 #if(CXSC_INDEX_CHECK) 03488 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03489 #else 03490 throw(); 03491 #endif 03492 03493 INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv) 03494 #if(CXSC_INDEX_CHECK) 03495 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03496 #else 03497 throw(); 03498 #endif 03499 03500 INLINE l_ivector operator +(const l_ivector_slice &sl1, const ivector_slice &sl2) 03501 #if(CXSC_INDEX_CHECK) 03502 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03503 #else 03504 throw(); 03505 #endif 03506 03508 INLINE l_ivector & operator +=(l_ivector &rv1, const ivector &rv2) 03509 #if(CXSC_INDEX_CHECK) 03510 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03511 #else 03512 throw(); 03513 #endif 03514 03515 INLINE l_ivector &operator +=(l_ivector &rv, const ivector_slice &sl) 03516 #if(CXSC_INDEX_CHECK) 03517 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03518 #else 03519 throw(); 03520 #endif 03521 03523 INLINE l_ivector operator -(const ivector &rv1, const l_ivector &rv2) 03524 #if(CXSC_INDEX_CHECK) 03525 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03526 #else 03527 throw(); 03528 #endif 03529 03530 INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl) 03531 #if(CXSC_INDEX_CHECK) 03532 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03533 #else 03534 throw(); 03535 #endif 03536 03537 INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv) 03538 #if(CXSC_INDEX_CHECK) 03539 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03540 #else 03541 throw(); 03542 #endif 03543 03544 INLINE l_ivector operator -(const ivector_slice &sl1, const l_ivector_slice &sl2) 03545 #if(CXSC_INDEX_CHECK) 03546 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03547 #else 03548 throw(); 03549 #endif 03550 03552 INLINE l_ivector operator -(const l_ivector &rv1, const ivector &rv2) 03553 #if(CXSC_INDEX_CHECK) 03554 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03555 #else 03556 throw(); 03557 #endif 03558 03559 INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl) 03560 #if(CXSC_INDEX_CHECK) 03561 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03562 #else 03563 throw(); 03564 #endif 03565 03566 INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv) 03567 #if(CXSC_INDEX_CHECK) 03568 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03569 #else 03570 throw(); 03571 #endif 03572 03573 INLINE l_ivector operator -(const l_ivector_slice &sl1, const ivector_slice &sl2) 03574 #if(CXSC_INDEX_CHECK) 03575 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03576 #else 03577 throw(); 03578 #endif 03579 03581 INLINE l_ivector & operator -=(l_ivector &rv1, const ivector &rv2) 03582 #if(CXSC_INDEX_CHECK) 03583 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03584 #else 03585 throw(); 03586 #endif 03587 03588 INLINE l_ivector &operator -=(l_ivector &rv, const ivector_slice &sl) 03589 #if(CXSC_INDEX_CHECK) 03590 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03591 #else 03592 throw(); 03593 #endif 03594 03596 INLINE l_ivector operator |(const ivector &rv1, const l_ivector &rv2) 03597 #if(CXSC_INDEX_CHECK) 03598 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03599 #else 03600 throw(); 03601 #endif 03602 03603 INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl) 03604 #if(CXSC_INDEX_CHECK) 03605 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03606 #else 03607 throw(); 03608 #endif 03609 03610 INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv) 03611 #if(CXSC_INDEX_CHECK) 03612 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03613 #else 03614 throw(); 03615 #endif 03616 03617 INLINE l_ivector operator |(const ivector_slice &sl1, const l_ivector_slice &sl2) 03618 #if(CXSC_INDEX_CHECK) 03619 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03620 #else 03621 throw(); 03622 #endif 03623 03625 INLINE l_ivector operator |(const l_ivector &rv1, const ivector &rv2) 03626 #if(CXSC_INDEX_CHECK) 03627 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03628 #else 03629 throw(); 03630 #endif 03631 03632 INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl) 03633 #if(CXSC_INDEX_CHECK) 03634 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03635 #else 03636 throw(); 03637 #endif 03638 03639 INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv) 03640 #if(CXSC_INDEX_CHECK) 03641 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03642 #else 03643 throw(); 03644 #endif 03645 03646 INLINE l_ivector operator |(const l_ivector_slice &sl1, const ivector_slice &sl2) 03647 #if(CXSC_INDEX_CHECK) 03648 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03649 #else 03650 throw(); 03651 #endif 03652 03654 INLINE l_ivector & operator |=(l_ivector &rv1, const ivector &rv2) 03655 #if(CXSC_INDEX_CHECK) 03656 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03657 #else 03658 throw(); 03659 #endif 03660 03661 INLINE l_ivector &operator |=(l_ivector &rv, const ivector_slice &sl) 03662 #if(CXSC_INDEX_CHECK) 03663 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03664 #else 03665 throw(); 03666 #endif 03667 03669 INLINE l_ivector operator &(const ivector &rv1, const l_ivector &rv2) 03670 #if(CXSC_INDEX_CHECK) 03671 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03672 #else 03673 throw(); 03674 #endif 03675 03676 INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl) 03677 #if(CXSC_INDEX_CHECK) 03678 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03679 #else 03680 throw(); 03681 #endif 03682 03683 INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv) 03684 #if(CXSC_INDEX_CHECK) 03685 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03686 #else 03687 throw(); 03688 #endif 03689 03690 INLINE l_ivector operator &(const ivector_slice &sl1, const l_ivector_slice &sl2) 03691 #if(CXSC_INDEX_CHECK) 03692 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03693 #else 03694 throw(); 03695 #endif 03696 03698 INLINE l_ivector operator &(const l_ivector &rv1, const ivector &rv2) 03699 #if(CXSC_INDEX_CHECK) 03700 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03701 #else 03702 throw(); 03703 #endif 03704 03705 INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl) 03706 #if(CXSC_INDEX_CHECK) 03707 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03708 #else 03709 throw(); 03710 #endif 03711 03712 INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv) 03713 #if(CXSC_INDEX_CHECK) 03714 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03715 #else 03716 throw(); 03717 #endif 03718 03719 INLINE l_ivector operator &(const l_ivector_slice &sl1, const ivector_slice &sl2) 03720 #if(CXSC_INDEX_CHECK) 03721 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03722 #else 03723 throw(); 03724 #endif 03725 03727 INLINE l_ivector & operator &=(l_ivector &rv1, const ivector &rv2) 03728 #if(CXSC_INDEX_CHECK) 03729 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03730 #else 03731 throw(); 03732 #endif 03733 03734 INLINE l_ivector &operator &=(l_ivector &rv, const ivector_slice &sl) 03735 #if(CXSC_INDEX_CHECK) 03736 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03737 #else 03738 throw(); 03739 #endif 03740 03741 //------------- real x l_real ------------------------ 03743 INLINE l_ivector operator |(const rvector &rv1, const l_rvector &rv2) 03744 #if(CXSC_INDEX_CHECK) 03745 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03746 #else 03747 throw(); 03748 #endif 03749 03750 INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2) 03751 #if(CXSC_INDEX_CHECK) 03752 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03753 #else 03754 throw(); 03755 #endif 03756 03757 INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl) 03758 #if(CXSC_INDEX_CHECK) 03759 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03760 #else 03761 throw(); 03762 #endif 03763 03764 INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv) 03765 #if(CXSC_INDEX_CHECK) 03766 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03767 #else 03768 throw(); 03769 #endif 03770 03771 INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv) 03772 #if(CXSC_INDEX_CHECK) 03773 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03774 #else 03775 throw(); 03776 #endif 03777 03778 INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl) 03779 #if(CXSC_INDEX_CHECK) 03780 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03781 #else 03782 throw(); 03783 #endif 03784 03785 INLINE l_ivector operator |(const l_rvector_slice &sl1, const rvector_slice &sl2) 03786 #if(CXSC_INDEX_CHECK) 03787 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03788 #else 03789 throw(); 03790 #endif 03791 03792 INLINE l_ivector operator |(const rvector_slice &sl1, const l_rvector_slice &sl2) 03793 #if(CXSC_INDEX_CHECK) 03794 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03795 #else 03796 throw(); 03797 #endif 03798 03799 //------------- l_real x l_real ------------------------ 03801 INLINE l_ivector operator |(const l_rvector &rv1, const l_rvector &rv2) 03802 #if(CXSC_INDEX_CHECK) 03803 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03804 #else 03805 throw(); 03806 #endif 03807 03808 INLINE l_ivector operator |(const l_rvector_slice &sl, const l_rvector &rv) 03809 #if(CXSC_INDEX_CHECK) 03810 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03811 #else 03812 throw(); 03813 #endif 03814 03815 INLINE l_ivector operator |(const l_rvector &rv,const l_rvector_slice &sl) 03816 #if(CXSC_INDEX_CHECK) 03817 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03818 #else 03819 throw(); 03820 #endif 03821 03822 INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_rvector_slice &sl2) 03823 #if(CXSC_INDEX_CHECK) 03824 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03825 #else 03826 throw(); 03827 #endif 03828 03829 //-------------------------------- interval / l_real -------------------------------- 03830 03831 // multiplication in lrvecivec.hpp 03832 03834 INLINE l_ivector operator +(const l_rvector &rv1, const ivector &rv2) 03835 #if(CXSC_INDEX_CHECK) 03836 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03837 #else 03838 throw(); 03839 #endif 03840 03841 INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl) 03842 #if(CXSC_INDEX_CHECK) 03843 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03844 #else 03845 throw(); 03846 #endif 03847 03848 INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv) 03849 #if(CXSC_INDEX_CHECK) 03850 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03851 #else 03852 throw(); 03853 #endif 03854 03855 INLINE l_ivector operator +(const l_rvector_slice &sl1, const ivector_slice &sl2) 03856 #if(CXSC_INDEX_CHECK) 03857 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03858 #else 03859 throw(); 03860 #endif 03861 03863 INLINE l_ivector operator +(const ivector &rv1, const l_rvector &rv2) 03864 #if(CXSC_INDEX_CHECK) 03865 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03866 #else 03867 throw(); 03868 #endif 03869 03870 INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl) 03871 #if(CXSC_INDEX_CHECK) 03872 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03873 #else 03874 throw(); 03875 #endif 03876 03877 INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv) 03878 #if(CXSC_INDEX_CHECK) 03879 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03880 #else 03881 throw(); 03882 #endif 03883 03884 INLINE l_ivector operator +(const ivector_slice &sl1, const l_rvector_slice &sl2) 03885 #if(CXSC_INDEX_CHECK) 03886 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03887 #else 03888 throw(); 03889 #endif 03890 03891 03893 INLINE l_ivector operator -(const l_rvector &rv1, const ivector &rv2) 03894 #if(CXSC_INDEX_CHECK) 03895 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03896 #else 03897 throw(); 03898 #endif 03899 03900 INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl) 03901 #if(CXSC_INDEX_CHECK) 03902 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03903 #else 03904 throw(); 03905 #endif 03906 03907 INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv) 03908 #if(CXSC_INDEX_CHECK) 03909 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03910 #else 03911 throw(); 03912 #endif 03913 03914 INLINE l_ivector operator -(const l_rvector_slice &sl1, const ivector_slice &sl2) 03915 #if(CXSC_INDEX_CHECK) 03916 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03917 #else 03918 throw(); 03919 #endif 03920 03922 INLINE l_ivector operator -(const ivector &rv1, const l_rvector &rv2) 03923 #if(CXSC_INDEX_CHECK) 03924 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03925 #else 03926 throw(); 03927 #endif 03928 03929 INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl) 03930 #if(CXSC_INDEX_CHECK) 03931 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03932 #else 03933 throw(); 03934 #endif 03935 03936 INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv) 03937 #if(CXSC_INDEX_CHECK) 03938 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03939 #else 03940 throw(); 03941 #endif 03942 03943 INLINE l_ivector operator -(const ivector_slice &sl1, const l_rvector_slice &sl2) 03944 #if(CXSC_INDEX_CHECK) 03945 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03946 #else 03947 throw(); 03948 #endif 03949 03950 03952 INLINE l_ivector operator |(const l_rvector &rv1, const ivector &rv2) 03953 #if(CXSC_INDEX_CHECK) 03954 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03955 #else 03956 throw(); 03957 #endif 03958 03959 INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl) 03960 #if(CXSC_INDEX_CHECK) 03961 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03962 #else 03963 throw(); 03964 #endif 03965 03966 INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv) 03967 #if(CXSC_INDEX_CHECK) 03968 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03969 #else 03970 throw(); 03971 #endif 03972 03973 INLINE l_ivector operator |(const l_rvector_slice &sl1, const ivector_slice &sl2) 03974 #if(CXSC_INDEX_CHECK) 03975 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03976 #else 03977 throw(); 03978 #endif 03979 03981 INLINE l_ivector operator |(const ivector &rv1, const l_rvector &rv2) 03982 #if(CXSC_INDEX_CHECK) 03983 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03984 #else 03985 throw(); 03986 #endif 03987 03988 INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl) 03989 #if(CXSC_INDEX_CHECK) 03990 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03991 #else 03992 throw(); 03993 #endif 03994 03995 INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv) 03996 #if(CXSC_INDEX_CHECK) 03997 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 03998 #else 03999 throw(); 04000 #endif 04001 04002 INLINE l_ivector operator |(const ivector_slice &sl1, const l_rvector_slice &sl2) 04003 #if(CXSC_INDEX_CHECK) 04004 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04005 #else 04006 throw(); 04007 #endif 04008 04010 INLINE l_ivector operator &(const l_rvector &rv1, const ivector &rv2) 04011 #if(CXSC_INDEX_CHECK) 04012 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04013 #else 04014 throw(); 04015 #endif 04016 04017 INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl) 04018 #if(CXSC_INDEX_CHECK) 04019 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04020 #else 04021 throw(); 04022 #endif 04023 04024 INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv) 04025 #if(CXSC_INDEX_CHECK) 04026 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04027 #else 04028 throw(); 04029 #endif 04030 04031 INLINE l_ivector operator &(const l_rvector_slice &sl1, const ivector_slice &sl2) 04032 #if(CXSC_INDEX_CHECK) 04033 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04034 #else 04035 throw(); 04036 #endif 04037 04039 INLINE l_ivector operator &(const ivector &rv1, const l_rvector &rv2) 04040 #if(CXSC_INDEX_CHECK) 04041 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04042 #else 04043 throw(); 04044 #endif 04045 04046 INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl) 04047 #if(CXSC_INDEX_CHECK) 04048 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04049 #else 04050 throw(); 04051 #endif 04052 04053 INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv) 04054 #if(CXSC_INDEX_CHECK) 04055 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04056 #else 04057 throw(); 04058 #endif 04059 04060 INLINE l_ivector operator &(const ivector_slice &sl1, const l_rvector_slice &sl2) 04061 #if(CXSC_INDEX_CHECK) 04062 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>); 04063 #else 04064 throw(); 04065 #endif 04066 04067 } // namespace cxsc 04068 04069 #ifdef _CXSC_INCL_INL 04070 #include "vector.inl" 04071 #include "l_ivector.inl" 04072 #endif 04073 04074 #ifdef _CXSC_RMATRIX_HPP_INCLUDED 04075 # ifdef _CXSC_INCL_INL 04076 # include "livecrmat.inl" 04077 # else 04078 # include "livecrmat.hpp" 04079 # endif 04080 #endif 04081 04082 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED 04083 # ifdef _CXSC_INCL_INL 04084 # include "liveclrmat.inl" 04085 # else 04086 # include "liveclrmat.hpp" 04087 # endif 04088 #endif 04089 04090 #ifdef _CXSC_IMATRIX_HPP_INCLUDED 04091 # ifdef _CXSC_INCL_INL 04092 # include "livecimat.inl" 04093 # else 04094 # include "livecimat.hpp" 04095 # endif 04096 #endif 04097 04098 04099 #endif 04100
1.7.5.1