- 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_rvector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_LRVECTOR_HPP_INCLUDED 00027 #define _CXSC_LRVECTOR_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "except.hpp" 00031 #include "dot.hpp" 00032 #include "idot.hpp" 00033 #include "l_real.hpp" // used for declaration of Inf, Sup,... 00034 //#include "cxscmatr.hpp" 00035 #include "rvector.hpp" 00036 #include "vector.hpp" 00037 00038 00039 #include <iostream> 00040 00041 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9 00042 00043 namespace cxsc { 00044 00045 class l_rvector_slice; 00046 00048 00053 class l_rvector 00054 { 00055 friend class l_rvector_slice; 00056 friend class l_rmatrix; 00057 friend class l_rmatrix_subv; 00058 friend class l_ivector; 00059 friend class l_imatrix; 00060 private: 00061 l_real *dat; 00062 int l,u,size; 00063 00064 public: 00065 //#if(CXSC_INDEX_CHECK) 00066 00067 template<typename S, typename T> 00068 friend inline void addDot(const S &x, const T &y, dotprecision &val); 00069 00070 00071 #ifdef _CXSC_FRIEND_TPL 00072 //------------ Templates -------------------------------------------------- 00073 // l_real 00074 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 00075 #if(CXSC_INDEX_CHECK) 00076 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 00077 #else 00078 throw(); 00079 #endif 00080 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00081 #if(CXSC_INDEX_CHECK) 00082 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00083 #else 00084 throw(); 00085 #endif 00086 template <class V> friend void _vresize(V &rv) throw(); 00087 template <class V,class S> friend void _vresize(V &rv, const int &len) 00088 #if(CXSC_INDEX_CHECK) 00089 throw(ERROR__WRONG_BOUNDARIES<V>); 00090 #else 00091 throw(); 00092 #endif 00093 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub) 00094 #if(CXSC_INDEX_CHECK) 00095 throw(ERROR__WRONG_BOUNDARIES<V>); 00096 #else 00097 throw(); 00098 #endif 00099 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 00100 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 00101 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00102 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00103 #if(CXSC_INDEX_CHECK) 00104 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00105 #else 00106 throw(); 00107 #endif 00108 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00109 #if(CXSC_INDEX_CHECK) 00110 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00111 #else 00112 throw(); 00113 #endif 00114 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00115 template <class V> friend V _vconj(const V &rv) throw(); 00116 template <class VS,class E> friend E _vsconj(const VS &sl) throw(); 00117 template <class V,class E> friend E _vabs(const V &rv) throw(); 00118 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00119 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00120 00121 //-------- vector-vector ----------------------- 00122 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 00123 #if(CXSC_INDEX_CHECK) 00124 throw(OP_WITH_WRONG_DIM); 00125 #else 00126 throw(); 00127 #endif 00128 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00129 #if(CXSC_INDEX_CHECK) 00130 throw(OP_WITH_WRONG_DIM); 00131 #else 00132 throw(); 00133 #endif 00134 template <class V1,class V2,class E> friend E _vvlmult(const V1 & rv1, const V2 &rv2) 00135 #if(CXSC_INDEX_CHECK) 00136 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00137 #else 00138 throw(); 00139 #endif 00140 template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv) 00141 #if(CXSC_INDEX_CHECK) 00142 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00143 #else 00144 throw(); 00145 #endif 00146 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 00147 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 00148 #if(CXSC_INDEX_CHECK) 00149 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00150 #else 00151 throw(); 00152 #endif 00153 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00154 #if(CXSC_INDEX_CHECK) 00155 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00156 #else 00157 throw(); 00158 #endif 00159 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00160 #if(CXSC_INDEX_CHECK) 00161 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00162 #else 00163 throw(); 00164 #endif 00165 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00166 #if(CXSC_INDEX_CHECK) 00167 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00168 #else 00169 throw(); 00170 #endif 00171 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 00172 #if(CXSC_INDEX_CHECK) 00173 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00174 #else 00175 throw(); 00176 #endif 00177 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 00178 #if(CXSC_INDEX_CHECK) 00179 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00180 #else 00181 throw(); 00182 #endif 00183 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 00184 #if(CXSC_INDEX_CHECK) 00185 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00186 #else 00187 throw(); 00188 #endif 00189 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00190 #if(CXSC_INDEX_CHECK) 00191 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00192 #else 00193 throw(); 00194 #endif 00195 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00196 #if(CXSC_INDEX_CHECK) 00197 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00198 #else 00199 throw(); 00200 #endif 00201 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 00202 #if(CXSC_INDEX_CHECK) 00203 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00204 #else 00205 throw(); 00206 #endif 00207 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 00208 #if(CXSC_INDEX_CHECK) 00209 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00210 #else 00211 throw(); 00212 #endif 00213 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 00214 #if(CXSC_INDEX_CHECK) 00215 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00216 #else 00217 throw(); 00218 #endif 00219 template <class V> friend V _vminus(const V &rv) throw(); 00220 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 00221 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 00222 #if(CXSC_INDEX_CHECK) 00223 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00224 #else 00225 throw(); 00226 #endif 00227 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 00228 #if(CXSC_INDEX_CHECK) 00229 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00230 #else 00231 throw(); 00232 #endif 00233 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 00234 #if(CXSC_INDEX_CHECK) 00235 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00236 #else 00237 throw(); 00238 #endif 00239 template <class V,class MV,class S> friend S _vmvlmult(const V &rv1, const MV &rv2) 00240 #if(CXSC_INDEX_CHECK) 00241 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00242 #else 00243 throw(); 00244 #endif 00245 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 00246 #if(CXSC_INDEX_CHECK) 00247 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00248 #else 00249 throw(); 00250 #endif 00251 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 00252 #if(CXSC_INDEX_CHECK) 00253 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00254 #else 00255 throw(); 00256 #endif 00257 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 00258 #if(CXSC_INDEX_CHECK) 00259 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00260 #else 00261 throw(); 00262 #endif 00263 //--------- vector-scalar ----------------- 00264 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 00265 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 00266 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00267 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 00268 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00269 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00270 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00271 #if(CXSC_INDEX_CHECK) 00272 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00273 #else 00274 throw(); 00275 #endif 00276 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00277 #if(CXSC_INDEX_CHECK) 00278 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00279 #else 00280 throw(); 00281 #endif 00282 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00283 #if(CXSC_INDEX_CHECK) 00284 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00285 #else 00286 throw(); 00287 #endif 00288 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00289 #if(CXSC_INDEX_CHECK) 00290 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00291 #else 00292 throw(); 00293 #endif 00294 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00295 #if(CXSC_INDEX_CHECK) 00296 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00297 #else 00298 throw(); 00299 #endif 00300 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00301 #if(CXSC_INDEX_CHECK) 00302 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00303 #else 00304 throw(); 00305 #endif 00306 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00307 #if(CXSC_INDEX_CHECK) 00308 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00309 #else 00310 throw(); 00311 #endif 00312 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00313 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00314 #if(CXSC_INDEX_CHECK) 00315 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00316 #else 00317 throw(); 00318 #endif 00319 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00320 #if(CXSC_INDEX_CHECK) 00321 throw(OP_WITH_WRONG_DIM); 00322 #else 00323 throw(); 00324 #endif 00325 00326 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw(); 00327 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 00328 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw(); 00329 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 00330 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw(); 00331 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 00332 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw(); 00333 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 00334 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 00335 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 00336 template <class V> friend bool _vnot(const V &rv) throw(); 00337 template <class V> friend void *_vvoid(const V &rv) throw(); 00338 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00339 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00340 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00341 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00342 template <class VS> friend bool _vsnot(const VS &sl) throw(); 00343 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 00344 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw(); 00345 template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw(); 00346 00347 //------------- vector-matrix --------------- 00348 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00349 template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v) 00350 #if(CXSC_INDEX_CHECK) 00351 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00352 #else 00353 throw(); 00354 #endif 00355 template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m) 00356 #if(CXSC_INDEX_CHECK) 00357 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00358 #else 00359 throw(); 00360 #endif 00361 template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m) 00362 #if(CXSC_INDEX_CHECK) 00363 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00364 #else 00365 throw(); 00366 #endif 00367 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v) 00368 #if(CXSC_INDEX_CHECK) 00369 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00370 #else 00371 throw(); 00372 #endif 00373 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 00374 #if(CXSC_INDEX_CHECK) 00375 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00376 #else 00377 throw(); 00378 #endif 00379 template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms) 00380 #if(CXSC_INDEX_CHECK) 00381 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00382 #else 00383 throw(); 00384 #endif 00385 00386 // interval ----------------- 00387 // vector-vector 00388 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2) 00389 #if(CXSC_INDEX_CHECK) 00390 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00391 #else 00392 throw(); 00393 #endif 00394 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 00395 #if(CXSC_INDEX_CHECK) 00396 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00397 #else 00398 throw(); 00399 #endif 00400 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 00401 #if(CXSC_INDEX_CHECK) 00402 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00403 #else 00404 throw(); 00405 #endif 00406 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 00407 #if(CXSC_INDEX_CHECK) 00408 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00409 #else 00410 throw(); 00411 #endif 00412 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 00413 #if(CXSC_INDEX_CHECK) 00414 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00415 #else 00416 throw(); 00417 #endif 00418 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 00419 #if(CXSC_INDEX_CHECK) 00420 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00421 #else 00422 throw(); 00423 #endif 00424 00425 // vector-matrix 00426 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 00427 #if(CXSC_INDEX_CHECK) 00428 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00429 #else 00430 throw(); 00431 #endif 00432 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 00433 #if(CXSC_INDEX_CHECK) 00434 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00435 #else 00436 throw(); 00437 #endif 00438 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 00439 #if(CXSC_INDEX_CHECK) 00440 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00441 #else 00442 throw(); 00443 #endif 00444 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 00445 #if(CXSC_INDEX_CHECK) 00446 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00447 #else 00448 throw(); 00449 #endif 00450 00451 // l_interval ----------------- 00452 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2) 00453 #if(CXSC_INDEX_CHECK) 00454 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00455 #else 00456 throw(); 00457 #endif 00458 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2) 00459 #if(CXSC_INDEX_CHECK) 00460 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00461 #else 00462 throw(); 00463 #endif 00464 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2) 00465 #if(CXSC_INDEX_CHECK) 00466 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00467 #else 00468 throw(); 00469 #endif 00470 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2) 00471 #if(CXSC_INDEX_CHECK) 00472 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00473 #else 00474 throw(); 00475 #endif 00476 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv) 00477 #if(CXSC_INDEX_CHECK) 00478 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00479 #else 00480 throw(); 00481 #endif 00482 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv) 00483 #if(CXSC_INDEX_CHECK) 00484 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00485 #else 00486 throw(); 00487 #endif 00488 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv) 00489 #if(CXSC_INDEX_CHECK) 00490 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00491 #else 00492 throw(); 00493 #endif 00494 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv) 00495 #if(CXSC_INDEX_CHECK) 00496 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00497 #else 00498 throw(); 00499 #endif 00500 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv) 00501 #if(CXSC_INDEX_CHECK) 00502 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00503 #else 00504 throw(); 00505 #endif 00506 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv) 00507 #if(CXSC_INDEX_CHECK) 00508 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00509 #else 00510 throw(); 00511 #endif 00512 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv) 00513 #if(CXSC_INDEX_CHECK) 00514 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00515 #else 00516 throw(); 00517 #endif 00518 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv) 00519 #if(CXSC_INDEX_CHECK) 00520 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00521 #else 00522 throw(); 00523 #endif 00524 template <class V,class E> friend E _vmid(const V &rv) throw(); 00525 template <class V,class E> friend E _vinf(const V &rv) throw(); 00526 template <class V,class E> friend E _vsup(const V &rv) throw(); 00527 template <class V,class E> friend E _vdiam(const V &rv) throw(); 00528 template <class VS,class E> friend E _vsmid(const VS &sl) throw(); 00529 template <class VS,class E> friend E _vsinf(const VS &sl) throw(); 00530 template <class VS,class E> friend E _vssup(const VS &sl) throw(); 00531 template <class VS,class E> friend E _vsdiam(const VS &sl) throw(); 00532 template <class MV,class V> friend V _mvdiam(const MV &mv) throw(); 00533 template <class MV,class V> friend V _mvmid(const MV &mv) throw(); 00534 template <class MV,class V> friend V _mvinf(const MV &mv) throw(); 00535 template <class MV,class V> friend V _mvsup(const MV &mv) throw(); 00536 00537 // vector-vector 00538 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 00539 #if(CXSC_INDEX_CHECK) 00540 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00541 #else 00542 throw(); 00543 #endif 00544 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 00545 #if(CXSC_INDEX_CHECK) 00546 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00547 #else 00548 throw(); 00549 #endif 00550 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 00551 #if(CXSC_INDEX_CHECK) 00552 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00553 #else 00554 throw(); 00555 #endif 00556 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 00557 #if(CXSC_INDEX_CHECK) 00558 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00559 #else 00560 throw(); 00561 #endif 00562 00563 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv) 00564 #if(CXSC_INDEX_CHECK) 00565 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00566 #else 00567 throw(); 00568 #endif 00569 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv) 00570 #if(CXSC_INDEX_CHECK) 00571 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00572 #else 00573 throw(); 00574 #endif 00575 00576 00577 #endif 00578 00579 //------ Konstruktoren ---------------------------------------------------- 00581 INLINE l_rvector () throw(); 00583 explicit INLINE l_rvector(const int &i) throw(); 00584 #ifdef OLD_CXSC 00585 00586 explicit INLINE l_rvector(const class index &i) throw(); // for backwards compatibility 00587 #endif 00588 00589 explicit INLINE l_rvector(const int &i1,const int &i2) 00590 #if(CXSC_INDEX_CHECK) 00591 throw(ERROR_LRVECTOR_WRONG_BOUNDARIES,ERROR_LRVECTOR_NO_MORE_MEMORY); 00592 #else 00593 throw(); 00594 #endif 00595 00596 INLINE l_rvector(const l_rmatrix_subv &) throw(); 00598 explicit INLINE l_rvector(const l_real &) throw(); 00600 explicit INLINE l_rvector(const l_rmatrix &) 00601 #if(CXSC_INDEX_CHECK) 00602 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00603 #else 00604 throw(); 00605 #endif 00606 00607 explicit INLINE l_rvector(const l_rmatrix_slice &sl) 00608 #if(CXSC_INDEX_CHECK) 00609 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00610 #else 00611 throw(); 00612 #endif 00613 00614 INLINE l_rvector(const l_rvector_slice &rs) throw(); 00616 INLINE l_rvector(const l_rvector &v) throw(); 00617 // Real 00619 explicit INLINE l_rvector(const real &) throw(); 00621 explicit INLINE l_rvector(const rvector_slice &rs) throw(); 00623 explicit INLINE l_rvector(const rvector &v) throw(); 00625 explicit INLINE l_rvector(const rmatrix &) 00626 #if(CXSC_INDEX_CHECK) 00627 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00628 #else 00629 throw(); 00630 #endif 00631 00632 explicit INLINE l_rvector(const rmatrix_slice &sl) 00633 #if(CXSC_INDEX_CHECK) 00634 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00635 #else 00636 throw(); 00637 #endif 00638 00639 explicit INLINE l_rvector(const rmatrix_subv &) throw(); 00640 00641 // l_real 00643 INLINE l_rvector &operator =(const l_rvector &rv) throw(); 00645 INLINE l_rvector &operator =(const l_rvector_slice &sl) throw(); 00647 INLINE l_rvector &operator =(const l_real &r) throw(); 00649 INLINE l_rvector &operator =(const l_rmatrix &m) 00650 #if(CXSC_INDEX_CHECK) 00651 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00652 #else 00653 throw(); 00654 #endif 00655 00656 INLINE l_rvector &operator =(const l_rmatrix_slice &) 00657 #if(CXSC_INDEX_CHECK) 00658 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00659 #else 00660 throw(); 00661 #endif 00662 00663 INLINE l_rvector &operator =(const l_rmatrix_subv &) throw(); 00664 // Real 00666 INLINE l_rvector &operator =(const rvector &rv) throw(); 00668 INLINE l_rvector &operator =(const rvector_slice &sl) throw(); 00670 INLINE l_rvector &operator =(const real &r) throw(); 00672 INLINE l_rvector &operator =(const rmatrix &m) 00673 #if(CXSC_INDEX_CHECK) 00674 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00675 #else 00676 throw(); 00677 #endif 00678 00679 INLINE l_rvector &operator =(const rmatrix_slice &) 00680 #if(CXSC_INDEX_CHECK) 00681 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00682 #else 00683 throw(); 00684 #endif 00685 00686 INLINE l_rvector &operator =(const rmatrix_subv &) throw(); 00687 00688 //--------- Destruktor ---------------------------------------------------- 00689 INLINE ~l_rvector() { delete [] dat; } 00690 00691 //------ Standardfunktionen ----------------------------------------------- 00692 00693 friend INLINE l_real::l_real(const l_rvector &) 00694 #if(CXSC_INDEX_CHECK) 00695 throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ); 00696 #else 00697 throw(); 00698 #endif 00699 00700 friend INLINE int Lb(const l_rvector &rv) throw() { return rv.l; } 00702 friend INLINE int Ub(const l_rvector &rv) throw() { return rv.u; } 00704 friend INLINE int VecLen(const l_rvector &rv) throw() { return rv.size; } 00706 friend INLINE l_rvector & SetLb(l_rvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;} 00708 friend INLINE l_rvector & SetUb(l_rvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;} 00710 INLINE l_real & operator [](const int &i) const 00711 #if(CXSC_INDEX_CHECK) 00712 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC); 00713 #else 00714 throw(); 00715 #endif 00716 00717 INLINE l_rvector & operator ()() throw() { return *this; } 00719 INLINE l_rvector_slice operator ()(const int &i) 00720 #if(CXSC_INDEX_CHECK) 00721 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG); 00722 #else 00723 throw(); 00724 #endif 00725 00726 INLINE l_rvector_slice operator ()(const int &i1,const int &i2) 00727 #if(CXSC_INDEX_CHECK) 00728 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG); 00729 #else 00730 throw(); 00731 #endif 00732 INLINE operator void*() throw(); 00733 //#else 00734 //#endif 00735 }; 00736 00737 00739 00744 class l_rvector_slice 00745 { 00746 friend class l_rvector; 00747 friend class l_rmatrix; 00748 friend class l_ivector; 00749 friend class l_imatrix; 00750 private: 00751 l_real *dat; 00752 int l,u,size; 00753 int start,end; 00754 00755 public: 00756 //#if(CXSC_INDEX_CHECK) 00757 00758 template<typename S, typename T> 00759 friend inline void addDot(const S &x, const T &y, dotprecision &val); 00760 00761 00762 #ifdef _CXSC_FRIEND_TPL 00763 //------------------------- Templates ------------------------------------------- 00764 // l_real / l_real 00765 00766 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2) 00767 #if(CXSC_INDEX_CHECK) 00768 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00769 #else 00770 throw(); 00771 #endif 00772 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00773 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00774 #if(CXSC_INDEX_CHECK) 00775 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00776 #else 00777 throw(); 00778 #endif 00779 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw(); 00780 00781 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00782 #if(CXSC_INDEX_CHECK) 00783 throw(OP_WITH_WRONG_DIM); 00784 #else 00785 throw(); 00786 #endif 00787 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 00788 #if(CXSC_INDEX_CHECK) 00789 throw(OP_WITH_WRONG_DIM); 00790 #else 00791 throw(); 00792 #endif 00793 00794 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00795 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00796 00797 template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv) 00798 #if(CXSC_INDEX_CHECK) 00799 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00800 #else 00801 throw(); 00802 #endif 00803 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw(); 00804 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw(); 00805 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00806 #if(CXSC_INDEX_CHECK) 00807 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00808 #else 00809 throw(); 00810 #endif 00811 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00812 #if(CXSC_INDEX_CHECK) 00813 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00814 #else 00815 throw(); 00816 #endif 00817 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00818 #if(CXSC_INDEX_CHECK) 00819 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00820 #else 00821 throw(); 00822 #endif 00823 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 00824 #if(CXSC_INDEX_CHECK) 00825 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00826 #else 00827 throw(); 00828 #endif 00829 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 00830 #if(CXSC_INDEX_CHECK) 00831 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00832 #else 00833 throw(); 00834 #endif 00835 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00836 #if(CXSC_INDEX_CHECK) 00837 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00838 #else 00839 throw(); 00840 #endif 00841 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00842 #if(CXSC_INDEX_CHECK) 00843 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00844 #else 00845 throw(); 00846 #endif 00847 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 00848 #if(CXSC_INDEX_CHECK) 00849 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00850 #else 00851 throw(); 00852 #endif 00853 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 00854 #if(CXSC_INDEX_CHECK) 00855 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00856 #else 00857 throw(); 00858 #endif 00859 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 00860 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 00861 #if(CXSC_INDEX_CHECK) 00862 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00863 #else 00864 throw(); 00865 #endif 00866 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 00867 #if(CXSC_INDEX_CHECK) 00868 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00869 #else 00870 throw(); 00871 #endif 00872 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 00873 #if(CXSC_INDEX_CHECK) 00874 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00875 #else 00876 throw(); 00877 #endif 00878 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 00879 #if(CXSC_INDEX_CHECK) 00880 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00881 #else 00882 throw(); 00883 #endif 00884 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 00885 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 00886 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 00887 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 00888 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 00889 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 00890 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00891 template <class VS1,class VS2,class E> friend E _vsvslmult(const VS1 & sl1, const VS2 &sl2) 00892 #if(CXSC_INDEX_CHECK) 00893 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00894 #else 00895 throw(); 00896 #endif 00897 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00898 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00899 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00900 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00901 template <class VS> friend bool _vsnot(const VS &sl) throw(); 00902 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 00903 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw(); 00904 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw(); 00905 00906 template <class VS,class M,class S> friend VS &_vsmlmultassign(VS &v,const M &m) 00907 #if(CXSC_INDEX_CHECK) 00908 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00909 #else 00910 throw(); 00911 #endif 00912 00913 // l_real / Real 00914 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 00915 #if(CXSC_INDEX_CHECK) 00916 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00917 #else 00918 throw(); 00919 #endif 00920 00921 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 00922 #if(CXSC_INDEX_CHECK) 00923 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00924 #else 00925 throw(); 00926 #endif 00927 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 00928 #if(CXSC_INDEX_CHECK) 00929 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00930 #else 00931 throw(); 00932 #endif 00933 00934 // interval ----------- 00935 // vector-vector ------- 00936 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2) 00937 #if(CXSC_INDEX_CHECK) 00938 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00939 #else 00940 throw(); 00941 #endif 00942 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 00943 #if(CXSC_INDEX_CHECK) 00944 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00945 #else 00946 throw(); 00947 #endif 00948 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 00949 #if(CXSC_INDEX_CHECK) 00950 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00951 #else 00952 throw(); 00953 #endif 00954 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 00955 #if(CXSC_INDEX_CHECK) 00956 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00957 #else 00958 throw(); 00959 #endif 00960 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 00961 #if(CXSC_INDEX_CHECK) 00962 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00963 #else 00964 throw(); 00965 #endif 00966 00967 // vector-matrix ------- 00968 /* friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v) 00969 #if(CXSC_INDEX_CHECK) 00970 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 00971 #else 00972 throw(); 00973 #endif */ 00974 /* friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m) 00975 #if(CXSC_INDEX_CHECK) 00976 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 00977 #else 00978 throw(); 00979 #endif */ 00980 00981 // l_interval -- vector-vector 00982 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 00983 #if(CXSC_INDEX_CHECK) 00984 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00985 #else 00986 throw(); 00987 #endif 00988 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 00989 #if(CXSC_INDEX_CHECK) 00990 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00991 #else 00992 throw(); 00993 #endif 00994 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 00995 #if(CXSC_INDEX_CHECK) 00996 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00997 #else 00998 throw(); 00999 #endif 01000 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 01001 #if(CXSC_INDEX_CHECK) 01002 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01003 #else 01004 throw(); 01005 #endif 01006 #endif 01007 01008 //--------------------- Konstruktoren ----------------------------------- 01010 explicit INLINE l_rvector_slice(l_rvector &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) { } 01012 explicit INLINE l_rvector_slice(l_rvector_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) { } 01013 public: 01015 INLINE l_rvector_slice(const l_rvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { } 01016 public: 01017 // l_real 01019 INLINE l_rvector_slice & operator =(const l_rvector_slice &sl) 01020 #if(CXSC_INDEX_CHECK) 01021 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01022 #else 01023 throw(); 01024 #endif 01025 01026 INLINE l_rvector_slice & operator =(const l_rvector &rv) 01027 #if(CXSC_INDEX_CHECK) 01028 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01029 #else 01030 throw(); 01031 #endif 01032 01033 INLINE l_rvector_slice & operator =(const l_real &r) throw(); 01035 INLINE l_rvector_slice & operator =(const l_rmatrix &m) 01036 #if(CXSC_INDEX_CHECK) 01037 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01038 #else 01039 throw(); 01040 #endif 01041 01042 INLINE l_rvector_slice & operator =(const l_rmatrix_slice &m) 01043 #if(CXSC_INDEX_CHECK) 01044 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01045 #else 01046 throw(); 01047 #endif 01048 01049 INLINE l_rvector_slice &operator =(const l_rmatrix_subv &) throw(); 01050 // Real 01052 INLINE l_rvector_slice & operator =(const rvector_slice &sl) 01053 #if(CXSC_INDEX_CHECK) 01054 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01055 #else 01056 throw(); 01057 #endif 01058 01059 INLINE l_rvector_slice & operator =(const rvector &rv) 01060 #if(CXSC_INDEX_CHECK) 01061 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01062 #else 01063 throw(); 01064 #endif 01065 01066 INLINE l_rvector_slice & operator =(const real &r) throw(); 01068 INLINE l_rvector_slice & operator =(const rmatrix &m) 01069 #if(CXSC_INDEX_CHECK) 01070 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01071 #else 01072 throw(); 01073 #endif 01074 01075 INLINE l_rvector_slice & operator =(const rmatrix_slice &m) 01076 #if(CXSC_INDEX_CHECK) 01077 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01078 #else 01079 throw(); 01080 #endif 01081 01082 INLINE l_rvector_slice &operator =(const rmatrix_subv &mv) throw(); 01083 01084 // l_interval -------- 01085 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl) 01086 #if(CXSC_INDEX_CHECK) 01087 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01088 #else 01089 throw(); 01090 #endif 01091 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl) 01092 #if(CXSC_INDEX_CHECK) 01093 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01094 #else 01095 throw(); 01096 #endif 01097 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl) 01098 #if(CXSC_INDEX_CHECK) 01099 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01100 #else 01101 throw(); 01102 #endif 01103 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl) 01104 #if(CXSC_INDEX_CHECK) 01105 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01106 #else 01107 throw(); 01108 #endif 01109 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2) 01110 #if(CXSC_INDEX_CHECK) 01111 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01112 #else 01113 throw(); 01114 #endif 01115 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2) 01116 #if(CXSC_INDEX_CHECK) 01117 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01118 #else 01119 throw(); 01120 #endif 01121 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(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 VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2) 01128 #if(CXSC_INDEX_CHECK) 01129 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01130 #else 01131 throw(); 01132 #endif 01133 01134 // l_interval -- vector-vector 01135 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 01136 #if(CXSC_INDEX_CHECK) 01137 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01138 #else 01139 throw(); 01140 #endif 01141 // l_interval -- vector-matrix 01142 01143 01144 //--------------------- Standardfunktionen ------------------------------ 01145 01146 friend INLINE l_real::l_real(const l_rvector_slice &sl) 01147 #if(CXSC_INDEX_CHECK) 01148 throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ); 01149 #else 01150 throw(); 01151 #endif 01152 01153 friend INLINE int Lb(const l_rvector_slice &sl) throw() { return sl.start; } 01155 friend INLINE int Ub(const l_rvector_slice &sl) throw() { return sl.end; } 01157 friend INLINE int VecLen(const l_rvector_slice &sl) throw() { return sl.end-sl.start+1; } 01159 INLINE l_real & operator [](const int &i) const 01160 #if(CXSC_INDEX_CHECK) 01161 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC); 01162 #else 01163 throw(); 01164 #endif 01165 01166 INLINE l_rvector_slice & operator ()() throw() { return *this; } 01168 INLINE l_rvector_slice operator ()(const int &i) 01169 #if(CXSC_INDEX_CHECK) 01170 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG); 01171 #else 01172 throw(); 01173 #endif 01174 01175 INLINE l_rvector_slice operator ()(const int &i1,const int &i2) 01176 #if(CXSC_INDEX_CHECK) 01177 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG); 01178 #else 01179 throw(); 01180 #endif 01181 01183 INLINE l_rvector_slice &operator /=(const l_real &r) throw(); 01185 INLINE l_rvector_slice &operator /=(const real &r) throw(); 01187 INLINE l_rvector_slice &operator *=(const l_real &r) throw(); 01189 INLINE l_rvector_slice &operator *=(const l_rmatrix &m) 01190 #if(CXSC_INDEX_CHECK) 01191 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01192 #else 01193 throw(); 01194 #endif 01195 01196 INLINE l_rvector_slice &operator *=(const rmatrix &m) 01197 #if(CXSC_INDEX_CHECK) 01198 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01199 #else 01200 throw(); 01201 #endif 01202 01203 INLINE l_rvector_slice &operator *=(const real &r) throw(); 01205 INLINE l_rvector_slice &operator +=(const l_rvector &rv) 01206 #if(CXSC_INDEX_CHECK) 01207 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01208 #else 01209 throw(); 01210 #endif 01211 01212 INLINE l_rvector_slice &operator +=(const l_rvector_slice &sl2) 01213 #if(CXSC_INDEX_CHECK) 01214 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01215 #else 01216 throw(); 01217 #endif 01218 01219 INLINE l_rvector_slice &operator -=(const l_rvector &rv) 01220 #if(CXSC_INDEX_CHECK) 01221 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01222 #else 01223 throw(); 01224 #endif 01225 01226 INLINE l_rvector_slice &operator -=(const l_rvector_slice &sl2) 01227 #if(CXSC_INDEX_CHECK) 01228 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01229 #else 01230 throw(); 01231 #endif 01232 01233 INLINE l_rvector_slice &operator |=(const l_rvector &rv) 01234 #if(CXSC_INDEX_CHECK) 01235 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01236 #else 01237 throw(); 01238 #endif 01239 01240 INLINE l_rvector_slice &operator |=(const l_rvector_slice &sl2) 01241 #if(CXSC_INDEX_CHECK) 01242 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01243 #else 01244 throw(); 01245 #endif 01246 01247 INLINE l_rvector_slice &operator &=(const l_rvector &rv) 01248 #if(CXSC_INDEX_CHECK) 01249 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01250 #else 01251 throw(); 01252 #endif 01253 01254 INLINE l_rvector_slice &operator &=(const l_rvector_slice &sl2) 01255 #if(CXSC_INDEX_CHECK) 01256 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01257 #else 01258 throw(); 01259 #endif 01260 01262 INLINE l_rvector_slice &operator +=(const rvector &rv) 01263 #if(CXSC_INDEX_CHECK) 01264 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01265 #else 01266 throw(); 01267 #endif 01268 01269 INLINE l_rvector_slice &operator +=(const rvector_slice &sl2) 01270 #if(CXSC_INDEX_CHECK) 01271 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01272 #else 01273 throw(); 01274 #endif 01275 01276 INLINE l_rvector_slice &operator -=(const rvector &rv) 01277 #if(CXSC_INDEX_CHECK) 01278 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01279 #else 01280 throw(); 01281 #endif 01282 01283 INLINE l_rvector_slice &operator -=(const rvector_slice &sl2) 01284 #if(CXSC_INDEX_CHECK) 01285 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01286 #else 01287 throw(); 01288 #endif 01289 01290 INLINE l_rvector_slice &operator |=(const rvector &rv) 01291 #if(CXSC_INDEX_CHECK) 01292 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01293 #else 01294 throw(); 01295 #endif 01296 01297 INLINE l_rvector_slice &operator |=(const rvector_slice &sl2) 01298 #if(CXSC_INDEX_CHECK) 01299 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01300 #else 01301 throw(); 01302 #endif 01303 01304 INLINE l_rvector_slice &operator &=(const rvector &rv) 01305 #if(CXSC_INDEX_CHECK) 01306 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01307 #else 01308 throw(); 01309 #endif 01310 01311 INLINE l_rvector_slice &operator &=(const rvector_slice &sl2) 01312 #if(CXSC_INDEX_CHECK) 01313 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01314 #else 01315 throw(); 01316 #endif 01317 INLINE operator void*() throw(); 01318 //#else 01319 //#endif 01320 }; 01321 01322 //======================================================================= 01323 //======================== Vector Functions ============================= 01324 01326 INLINE l_rvector _l_rvector(const l_real &r) throw(); 01327 // INLINE l_rvector _l_rvector(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01328 // INLINE l_rvector _l_rvector(const l_rmatrix_slice &sl) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01330 INLINE l_rvector _l_rvector(const real &r) throw(); 01332 INLINE l_rvector _l_rvector(const rvector_slice &rs) throw(); 01334 INLINE l_rvector _l_rvector(const rvector &rs) throw(); 01335 // INLINE l_rvector _l_rvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01336 // INLINE l_rvector _l_rvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01338 INLINE l_rvector _l_rvector(const rmatrix_subv &rs) throw(); 01339 01341 INLINE void Resize(l_rvector &rv) throw(); 01343 INLINE void Resize(l_rvector &rv, const int &len) 01344 #if(CXSC_INDEX_CHECK) 01345 throw(ERROR__WRONG_BOUNDARIES<l_rvector>); 01346 #else 01347 throw(); 01348 #endif 01349 01350 INLINE void Resize(l_rvector &rv, const int &lb, const int &ub) 01351 #if(CXSC_INDEX_CHECK) 01352 throw(ERROR__WRONG_BOUNDARIES<l_rvector>); 01353 #else 01354 throw(); 01355 #endif 01356 01358 INLINE l_rvector abs(const l_rvector &rv) throw(); 01360 INLINE l_rvector abs(const l_rvector_slice &sl) throw(); 01362 INLINE bool operator !(const l_rvector &rv) throw(); 01364 INLINE bool operator !(const l_rvector_slice &sl) throw(); 01365 01366 //======================= Vector / Scalar =============================== 01367 01368 //----------------------------- l_real --------------------------- 01369 01371 INLINE l_rvector operator *(const l_rvector &rv, const l_real &s) throw(); 01373 INLINE l_rvector operator *(const l_rvector_slice &sl, const l_real &s) throw(); 01375 INLINE l_rvector operator *(const l_real &s, const l_rvector &rv) throw(); 01377 INLINE l_rvector operator *(const l_real &s, const l_rvector_slice &sl) throw(); 01379 INLINE l_rvector &operator *=(l_rvector &rv,const l_real &r) throw(); 01380 01382 INLINE l_rvector operator /(const l_rvector &rv, const l_real &s) throw(); 01384 INLINE l_rvector operator /(const l_rvector_slice &sl, const l_real &s) throw(); 01386 INLINE l_rvector &operator /=(l_rvector &rv,const l_real &r) throw(); 01387 01388 //---------------------------- Real -------------------------------------- 01389 01391 INLINE l_rvector operator *(const l_rvector &rv, const real &s) throw(); 01393 INLINE l_rvector operator *(const l_rvector_slice &sl, const real &s) throw(); 01395 INLINE l_rvector operator *(const real &s, const l_rvector &rv) throw(); 01397 INLINE l_rvector operator *(const real &s, const l_rvector_slice &sl) throw(); 01399 INLINE l_rvector &operator *=(l_rvector &rv,const real &r) throw(); 01400 01402 INLINE l_rvector operator /(const l_rvector &rv, const real &s) throw(); 01404 INLINE l_rvector operator /(const l_rvector_slice &sl, const real &s) throw(); 01406 INLINE l_rvector &operator /=(l_rvector &rv,const real &r) throw(); 01407 01409 INLINE l_rvector operator *(const rvector &rv, const l_real &s) throw(); 01411 INLINE l_rvector operator *(const rvector_slice &sl, const l_real &s) throw(); 01413 INLINE l_rvector operator *(const l_real &s, const rvector &rv) throw(); 01415 INLINE l_rvector operator *(const l_real &s, const rvector_slice &sl) throw(); 01416 01418 INLINE l_rvector operator /(const rvector &rv, const l_real &s) throw(); 01420 INLINE l_rvector operator /(const rvector_slice &sl, const l_real &s) throw(); 01421 01422 //======================= Vector / Vector =============================== 01423 01424 01426 INLINE std::ostream &operator <<(std::ostream &s, const l_rvector &rv) throw(); 01428 INLINE std::ostream &operator <<(std::ostream &o, const l_rvector_slice &sl) throw(); 01430 INLINE std::istream &operator >>(std::istream &s, l_rvector &rv) throw(); 01432 INLINE std::istream &operator >>(std::istream &s, l_rvector_slice &rv) throw(); 01433 01434 //----------------------- l_real / l_real --------------------------- 01435 01437 INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rvector &rv2) 01438 #if(CXSC_INDEX_CHECK) 01439 throw(OP_WITH_WRONG_DIM); 01440 #else 01441 throw(); 01442 #endif 01443 01444 INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv) 01445 #if(CXSC_INDEX_CHECK) 01446 throw(OP_WITH_WRONG_DIM); 01447 #else 01448 throw(); 01449 #endif 01450 01451 INLINE void accumulate(dotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl) 01452 #if(CXSC_INDEX_CHECK) 01453 throw(OP_WITH_WRONG_DIM); 01454 #else 01455 throw(); 01456 #endif 01457 01458 INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2) 01459 #if(CXSC_INDEX_CHECK) 01460 throw(OP_WITH_WRONG_DIM); 01461 #else 01462 throw(); 01463 #endif 01464 01465 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2) 01466 #if(CXSC_INDEX_CHECK) 01467 throw(OP_WITH_WRONG_DIM); 01468 #else 01469 throw(); 01470 #endif 01471 01472 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01473 #if(CXSC_INDEX_CHECK) 01474 throw(OP_WITH_WRONG_DIM); 01475 #else 01476 throw(); 01477 #endif 01478 01479 INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2) 01480 #if(CXSC_INDEX_CHECK) 01481 throw(OP_WITH_WRONG_DIM); 01482 #else 01483 throw(); 01484 #endif 01485 01486 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rvector &rv2) 01487 #if(CXSC_INDEX_CHECK) 01488 throw(OP_WITH_WRONG_DIM); 01489 #else 01490 throw(); 01491 #endif 01492 01493 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv) 01494 #if(CXSC_INDEX_CHECK) 01495 throw(OP_WITH_WRONG_DIM); 01496 #else 01497 throw(); 01498 #endif 01499 01500 INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl) 01501 #if(CXSC_INDEX_CHECK) 01502 throw(OP_WITH_WRONG_DIM); 01503 #else 01504 throw(); 01505 #endif 01506 01507 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2) 01508 #if(CXSC_INDEX_CHECK) 01509 throw(OP_WITH_WRONG_DIM); 01510 #else 01511 throw(); 01512 #endif 01513 01514 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2) 01515 #if(CXSC_INDEX_CHECK) 01516 throw(OP_WITH_WRONG_DIM); 01517 #else 01518 throw(); 01519 #endif 01520 01521 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2) 01522 #if(CXSC_INDEX_CHECK) 01523 throw(OP_WITH_WRONG_DIM); 01524 #else 01525 throw(); 01526 #endif 01527 01528 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01529 #if(CXSC_INDEX_CHECK) 01530 throw(OP_WITH_WRONG_DIM); 01531 #else 01532 throw(); 01533 #endif 01534 01535 01537 INLINE l_real operator *(const l_rvector & rv1, const l_rvector &rv2) 01538 #if(CXSC_INDEX_CHECK) 01539 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01540 #else 01541 throw(); 01542 #endif 01543 01544 INLINE l_real operator *(const l_rvector_slice &sl, const l_rvector &rv) 01545 #if(CXSC_INDEX_CHECK) 01546 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01547 #else 01548 throw(); 01549 #endif 01550 01551 INLINE l_real operator *(const l_rvector &rv, const l_rvector_slice &sl) 01552 #if(CXSC_INDEX_CHECK) 01553 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01554 #else 01555 throw(); 01556 #endif 01557 01558 INLINE l_real operator *(const l_rvector_slice & sl1, const l_rvector_slice &sl2) 01559 #if(CXSC_INDEX_CHECK) 01560 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01561 #else 01562 throw(); 01563 #endif 01564 01566 INLINE const l_rvector &operator +(const l_rvector &rv) throw(); 01568 INLINE l_rvector operator +(const l_rvector_slice &sl) throw(); 01569 01571 INLINE l_rvector operator +(const l_rvector &rv1, const l_rvector &rv2) 01572 #if(CXSC_INDEX_CHECK) 01573 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01574 #else 01575 throw(); 01576 #endif 01577 01578 INLINE l_rvector operator +(const l_rvector &rv, const l_rvector_slice &sl) 01579 #if(CXSC_INDEX_CHECK) 01580 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01581 #else 01582 throw(); 01583 #endif 01584 01585 INLINE l_rvector operator +(const l_rvector_slice &sl, const l_rvector &rv) 01586 #if(CXSC_INDEX_CHECK) 01587 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01588 #else 01589 throw(); 01590 #endif 01591 01592 INLINE l_rvector operator +(const l_rvector_slice &sl1, const l_rvector_slice &sl2) 01593 #if(CXSC_INDEX_CHECK) 01594 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01595 #else 01596 throw(); 01597 #endif 01598 01599 INLINE l_rvector & operator +=(l_rvector &rv1, const l_rvector &rv2) 01600 #if(CXSC_INDEX_CHECK) 01601 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01602 #else 01603 throw(); 01604 #endif 01605 01606 INLINE l_rvector &operator +=(l_rvector &rv, const l_rvector_slice &sl) 01607 #if(CXSC_INDEX_CHECK) 01608 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01609 #else 01610 throw(); 01611 #endif 01612 01614 INLINE l_rvector operator -(const l_rvector &rv) throw(); 01616 INLINE l_rvector operator -(const l_rvector_slice &sl) throw(); 01618 INLINE l_rvector operator -(const l_rvector &rv1, const l_rvector &rv2) 01619 #if(CXSC_INDEX_CHECK) 01620 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01621 #else 01622 throw(); 01623 #endif 01624 01625 INLINE l_rvector operator -(const l_rvector &rv, const l_rvector_slice &sl) 01626 #if(CXSC_INDEX_CHECK) 01627 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01628 #else 01629 throw(); 01630 #endif 01631 01632 INLINE l_rvector operator -(const l_rvector_slice &sl, const l_rvector &rv) 01633 #if(CXSC_INDEX_CHECK) 01634 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01635 #else 01636 throw(); 01637 #endif 01638 01639 INLINE l_rvector operator -(const l_rvector_slice &sl1, const l_rvector_slice &sl2) 01640 #if(CXSC_INDEX_CHECK) 01641 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01642 #else 01643 throw(); 01644 #endif 01645 01646 INLINE l_rvector & operator -=(l_rvector &rv1, const l_rvector &rv2) 01647 #if(CXSC_INDEX_CHECK) 01648 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01649 #else 01650 throw(); 01651 #endif 01652 01653 INLINE l_rvector &operator -=(l_rvector &rv, const l_rvector_slice &sl) 01654 #if(CXSC_INDEX_CHECK) 01655 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01656 #else 01657 throw(); 01658 #endif 01659 01661 INLINE bool operator ==(const l_rvector &rv1, const l_rvector &rv2) throw(); 01663 INLINE bool operator ==(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw(); 01665 INLINE bool operator ==(const l_rvector_slice &sl, const l_rvector &rv) throw(); 01667 INLINE bool operator ==(const l_rvector &rv, const l_rvector_slice &sl) throw(); 01669 INLINE bool operator !=(const l_rvector &rv1, const l_rvector &rv2) throw(); 01671 INLINE bool operator !=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw(); 01673 INLINE bool operator !=(const l_rvector_slice &sl, const l_rvector &rv) throw(); 01675 INLINE bool operator !=(const l_rvector &rv, const l_rvector_slice &sl) throw(); 01677 INLINE bool operator <(const l_rvector &rv1, const l_rvector &rv2) throw(); 01679 INLINE bool operator <(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw(); 01681 INLINE bool operator < (const l_rvector_slice &sl, const l_rvector &rv) throw(); 01683 INLINE bool operator < (const l_rvector &rv, const l_rvector_slice &sl) throw(); 01685 INLINE bool operator <=(const l_rvector &rv1, const l_rvector &rv2) throw(); 01687 INLINE bool operator <=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw(); 01689 INLINE bool operator <=(const l_rvector_slice &sl, const l_rvector &rv) throw(); 01691 INLINE bool operator <=(const l_rvector &rv, const l_rvector_slice &sl) throw(); 01693 INLINE bool operator >(const l_rvector &rv1, const l_rvector &rv2) throw(); 01695 INLINE bool operator >(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw(); 01697 INLINE bool operator >(const l_rvector_slice &sl, const l_rvector &rv) throw(); 01699 INLINE bool operator >(const l_rvector &rv, const l_rvector_slice &sl) throw(); 01701 INLINE bool operator >=(const l_rvector &rv1, const l_rvector &rv2) throw(); 01703 INLINE bool operator >=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw(); 01705 INLINE bool operator >=(const l_rvector_slice &sl, const l_rvector &rv) throw(); 01707 INLINE bool operator >=(const l_rvector &rv, const l_rvector_slice &sl) throw(); 01708 01709 //-------------------------------- l_real / Real -------------------------------- 01710 01711 01713 INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rvector &rv2) 01714 #if(CXSC_INDEX_CHECK) 01715 throw(OP_WITH_WRONG_DIM); 01716 #else 01717 throw(); 01718 #endif 01719 01720 INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rvector &rv2) 01721 #if(CXSC_INDEX_CHECK) 01722 throw(OP_WITH_WRONG_DIM); 01723 #else 01724 throw(); 01725 #endif 01726 01727 INLINE void accumulate(dotprecision &dp, const rvector_slice & sl, const l_rvector &rv) 01728 #if(CXSC_INDEX_CHECK) 01729 throw(OP_WITH_WRONG_DIM); 01730 #else 01731 throw(); 01732 #endif 01733 01734 INLINE void accumulate(dotprecision &dp,const l_rvector_slice &sl,const rvector &rv) 01735 #if(CXSC_INDEX_CHECK) 01736 throw(OP_WITH_WRONG_DIM); 01737 #else 01738 throw(); 01739 #endif 01740 01741 INLINE void accumulate(dotprecision &dp, const rvector &rv, const l_rvector_slice &sl) 01742 #if(CXSC_INDEX_CHECK) 01743 throw(OP_WITH_WRONG_DIM); 01744 #else 01745 throw(); 01746 #endif 01747 01748 INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2) 01749 #if(CXSC_INDEX_CHECK) 01750 throw(OP_WITH_WRONG_DIM); 01751 #else 01752 throw(); 01753 #endif 01754 01755 INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2) 01756 #if(CXSC_INDEX_CHECK) 01757 throw(OP_WITH_WRONG_DIM); 01758 #else 01759 throw(); 01760 #endif 01761 01762 INLINE void accumulate(dotprecision &dp, const rvector_slice & rv1, const l_rmatrix_subv &rv2) 01763 #if(CXSC_INDEX_CHECK) 01764 throw(OP_WITH_WRONG_DIM); 01765 #else 01766 throw(); 01767 #endif 01768 01769 INLINE void accumulate(dotprecision &dp, const l_rvector_slice & rv1, const rmatrix_subv &rv2) 01770 #if(CXSC_INDEX_CHECK) 01771 throw(OP_WITH_WRONG_DIM); 01772 #else 01773 throw(); 01774 #endif 01775 01776 INLINE void accumulate(dotprecision &dp,const l_rvector &rv,const rvector_slice &sl) 01777 #if(CXSC_INDEX_CHECK) 01778 throw(OP_WITH_WRONG_DIM); 01779 #else 01780 throw(); 01781 #endif 01782 01783 INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2) 01784 #if(CXSC_INDEX_CHECK) 01785 throw(OP_WITH_WRONG_DIM); 01786 #else 01787 throw(); 01788 #endif 01789 01790 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2) 01791 #if(CXSC_INDEX_CHECK) 01792 throw(OP_WITH_WRONG_DIM); 01793 #else 01794 throw(); 01795 #endif 01796 01797 INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector_slice &rv2) 01798 #if(CXSC_INDEX_CHECK) 01799 throw(OP_WITH_WRONG_DIM); 01800 #else 01801 throw(); 01802 #endif 01803 01804 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &rv2) 01805 #if(CXSC_INDEX_CHECK) 01806 throw(OP_WITH_WRONG_DIM); 01807 #else 01808 throw(); 01809 #endif 01810 01811 INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2) 01812 #if(CXSC_INDEX_CHECK) 01813 throw(OP_WITH_WRONG_DIM); 01814 #else 01815 throw(); 01816 #endif 01817 01818 INLINE void accumulate(dotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2) 01819 #if(CXSC_INDEX_CHECK) 01820 throw(OP_WITH_WRONG_DIM); 01821 #else 01822 throw(); 01823 #endif 01824 01825 INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01826 #if(CXSC_INDEX_CHECK) 01827 throw(OP_WITH_WRONG_DIM); 01828 #else 01829 throw(); 01830 #endif 01831 01832 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2) 01833 #if(CXSC_INDEX_CHECK) 01834 throw(OP_WITH_WRONG_DIM); 01835 #else 01836 throw(); 01837 #endif 01838 01840 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rvector &rv2) 01841 #if(CXSC_INDEX_CHECK) 01842 throw(OP_WITH_WRONG_DIM); 01843 #else 01844 throw(); 01845 #endif 01846 01847 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rvector &rv2) 01848 #if(CXSC_INDEX_CHECK) 01849 throw(OP_WITH_WRONG_DIM); 01850 #else 01851 throw(); 01852 #endif 01853 01854 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_rvector &rv) 01855 #if(CXSC_INDEX_CHECK) 01856 throw(OP_WITH_WRONG_DIM); 01857 #else 01858 throw(); 01859 #endif 01860 01861 INLINE void accumulate(idotprecision &dp,const l_rvector_slice &sl,const rvector &rv) 01862 #if(CXSC_INDEX_CHECK) 01863 throw(OP_WITH_WRONG_DIM); 01864 #else 01865 throw(); 01866 #endif 01867 01868 INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_rvector_slice &sl) 01869 #if(CXSC_INDEX_CHECK) 01870 throw(OP_WITH_WRONG_DIM); 01871 #else 01872 throw(); 01873 #endif 01874 01875 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2) 01876 #if(CXSC_INDEX_CHECK) 01877 throw(OP_WITH_WRONG_DIM); 01878 #else 01879 throw(); 01880 #endif 01881 01882 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2) 01883 #if(CXSC_INDEX_CHECK) 01884 throw(OP_WITH_WRONG_DIM); 01885 #else 01886 throw(); 01887 #endif 01888 01889 INLINE void accumulate(idotprecision &dp, const rvector_slice & rv1, const l_rmatrix_subv &rv2) 01890 #if(CXSC_INDEX_CHECK) 01891 throw(OP_WITH_WRONG_DIM); 01892 #else 01893 throw(); 01894 #endif 01895 01896 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & rv1, const rmatrix_subv &rv2) 01897 #if(CXSC_INDEX_CHECK) 01898 throw(OP_WITH_WRONG_DIM); 01899 #else 01900 throw(); 01901 #endif 01902 01903 INLINE void accumulate(idotprecision &dp,const l_rvector &rv,const rvector_slice &sl) 01904 #if(CXSC_INDEX_CHECK) 01905 throw(OP_WITH_WRONG_DIM); 01906 #else 01907 throw(); 01908 #endif 01909 01910 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2) 01911 #if(CXSC_INDEX_CHECK) 01912 throw(OP_WITH_WRONG_DIM); 01913 #else 01914 throw(); 01915 #endif 01916 01917 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2) 01918 #if(CXSC_INDEX_CHECK) 01919 throw(OP_WITH_WRONG_DIM); 01920 #else 01921 throw(); 01922 #endif 01923 01924 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector_slice &rv2) 01925 #if(CXSC_INDEX_CHECK) 01926 throw(OP_WITH_WRONG_DIM); 01927 #else 01928 throw(); 01929 #endif 01930 01931 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &rv2) 01932 #if(CXSC_INDEX_CHECK) 01933 throw(OP_WITH_WRONG_DIM); 01934 #else 01935 throw(); 01936 #endif 01937 01938 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2) 01939 #if(CXSC_INDEX_CHECK) 01940 throw(OP_WITH_WRONG_DIM); 01941 #else 01942 throw(); 01943 #endif 01944 01945 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2) 01946 #if(CXSC_INDEX_CHECK) 01947 throw(OP_WITH_WRONG_DIM); 01948 #else 01949 throw(); 01950 #endif 01951 01952 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01953 #if(CXSC_INDEX_CHECK) 01954 throw(OP_WITH_WRONG_DIM); 01955 #else 01956 throw(); 01957 #endif 01958 01959 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2) 01960 #if(CXSC_INDEX_CHECK) 01961 throw(OP_WITH_WRONG_DIM); 01962 #else 01963 throw(); 01964 #endif 01965 01967 INLINE l_real operator *(const rvector & rv1, const l_rvector &rv2) 01968 #if(CXSC_INDEX_CHECK) 01969 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01970 #else 01971 throw(); 01972 #endif 01973 01974 INLINE l_real operator *(const rvector_slice &sl, const l_rvector &rv) 01975 #if(CXSC_INDEX_CHECK) 01976 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01977 #else 01978 throw(); 01979 #endif 01980 01981 INLINE l_real operator *(const rvector &rv, const l_rvector_slice &sl) 01982 #if(CXSC_INDEX_CHECK) 01983 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01984 #else 01985 throw(); 01986 #endif 01987 01988 INLINE l_real operator *(const rvector_slice & sl1, const l_rvector_slice &sl2) 01989 #if(CXSC_INDEX_CHECK) 01990 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01991 #else 01992 throw(); 01993 #endif 01994 01996 INLINE l_real operator *(const l_rvector & rv1, const rvector &rv2) 01997 #if(CXSC_INDEX_CHECK) 01998 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 01999 #else 02000 throw(); 02001 #endif 02002 02003 INLINE l_real operator *(const l_rvector_slice &sl, const rvector &rv) 02004 #if(CXSC_INDEX_CHECK) 02005 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02006 #else 02007 throw(); 02008 #endif 02009 02010 INLINE l_real operator *(const l_rvector &rv, const rvector_slice &sl) 02011 #if(CXSC_INDEX_CHECK) 02012 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02013 #else 02014 throw(); 02015 #endif 02016 02017 INLINE l_real operator *(const l_rvector_slice & sl1, const rvector_slice &sl2) 02018 #if(CXSC_INDEX_CHECK) 02019 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02020 #else 02021 throw(); 02022 #endif 02023 02025 INLINE l_rvector operator +(const rvector &rv1, const l_rvector &rv2) 02026 #if(CXSC_INDEX_CHECK) 02027 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02028 #else 02029 throw(); 02030 #endif 02031 02032 INLINE l_rvector operator +(const rvector &rv, const l_rvector_slice &sl) 02033 #if(CXSC_INDEX_CHECK) 02034 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02035 #else 02036 throw(); 02037 #endif 02038 02039 INLINE l_rvector operator +(const rvector_slice &sl, const l_rvector &rv) 02040 #if(CXSC_INDEX_CHECK) 02041 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02042 #else 02043 throw(); 02044 #endif 02045 02046 INLINE l_rvector operator +(const rvector_slice &sl1, const l_rvector_slice &sl2) 02047 #if(CXSC_INDEX_CHECK) 02048 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02049 #else 02050 throw(); 02051 #endif 02052 02054 INLINE l_rvector operator +(const l_rvector &rv1, const rvector &rv2) 02055 #if(CXSC_INDEX_CHECK) 02056 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02057 #else 02058 throw(); 02059 #endif 02060 02061 INLINE l_rvector operator +(const l_rvector &rv, const rvector_slice &sl) 02062 #if(CXSC_INDEX_CHECK) 02063 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02064 #else 02065 throw(); 02066 #endif 02067 02068 INLINE l_rvector operator +(const l_rvector_slice &sl, const rvector &rv) 02069 #if(CXSC_INDEX_CHECK) 02070 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02071 #else 02072 throw(); 02073 #endif 02074 02075 INLINE l_rvector operator +(const l_rvector_slice &sl1, const rvector_slice &sl2) 02076 #if(CXSC_INDEX_CHECK) 02077 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02078 #else 02079 throw(); 02080 #endif 02081 02083 INLINE l_rvector & operator +=(l_rvector &rv1, const rvector &rv2) 02084 #if(CXSC_INDEX_CHECK) 02085 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02086 #else 02087 throw(); 02088 #endif 02089 02090 INLINE l_rvector &operator +=(l_rvector &rv, const rvector_slice &sl) 02091 #if(CXSC_INDEX_CHECK) 02092 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02093 #else 02094 throw(); 02095 #endif 02096 02098 INLINE l_rvector operator -(const rvector &rv1, const l_rvector &rv2) 02099 #if(CXSC_INDEX_CHECK) 02100 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02101 #else 02102 throw(); 02103 #endif 02104 02105 INLINE l_rvector operator -(const rvector &rv, const l_rvector_slice &sl) 02106 #if(CXSC_INDEX_CHECK) 02107 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02108 #else 02109 throw(); 02110 #endif 02111 02112 INLINE l_rvector operator -(const rvector_slice &sl, const l_rvector &rv) 02113 #if(CXSC_INDEX_CHECK) 02114 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02115 #else 02116 throw(); 02117 #endif 02118 02119 INLINE l_rvector operator -(const rvector_slice &sl1, const l_rvector_slice &sl2) 02120 #if(CXSC_INDEX_CHECK) 02121 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02122 #else 02123 throw(); 02124 #endif 02125 02127 INLINE l_rvector operator -(const l_rvector &rv1, const rvector &rv2) 02128 #if(CXSC_INDEX_CHECK) 02129 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02130 #else 02131 throw(); 02132 #endif 02133 02134 INLINE l_rvector operator -(const l_rvector &rv, const rvector_slice &sl) 02135 #if(CXSC_INDEX_CHECK) 02136 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02137 #else 02138 throw(); 02139 #endif 02140 02141 INLINE l_rvector operator -(const l_rvector_slice &sl, const rvector &rv) 02142 #if(CXSC_INDEX_CHECK) 02143 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02144 #else 02145 throw(); 02146 #endif 02147 02148 INLINE l_rvector operator -(const l_rvector_slice &sl1, const rvector_slice &sl2) 02149 #if(CXSC_INDEX_CHECK) 02150 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02151 #else 02152 throw(); 02153 #endif 02154 02155 INLINE l_rvector & operator -=(l_rvector &rv1, const rvector &rv2) 02156 #if(CXSC_INDEX_CHECK) 02157 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02158 #else 02159 throw(); 02160 #endif 02161 02162 INLINE l_rvector &operator -=(l_rvector &rv, const rvector_slice &sl) 02163 #if(CXSC_INDEX_CHECK) 02164 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>); 02165 #else 02166 throw(); 02167 #endif 02168 02169 } // namespace cxsc 02170 02171 #ifdef _CXSC_INCL_INL 02172 #include "vector.inl" 02173 #include "l_rvector.inl" 02174 #endif 02175 02176 #ifdef _CXSC_RMATRIX_HPP_INCLUDED 02177 # ifdef _CXSC_INCL_INL 02178 # include "lrvecrmat.inl" 02179 # else 02180 # include "lrvecrmat.hpp" 02181 # endif 02182 #endif 02183 02184 #ifdef _CXSC_IMATRIX_HPP_INCLUDED 02185 # ifdef _CXSC_INCL_INL 02186 # include "cvecimat.inl" 02187 # else 02188 # include "cvecimat.hpp" 02189 # endif 02190 #endif 02191 02192 #ifdef _CXSC_IVECTOR_HPP_INCLUDED 02193 # ifdef _CXSC_INCL_INL 02194 # include "lrvecivec.inl" 02195 # else 02196 # include "lrvecivec.hpp" 02197 # endif 02198 #endif 02199 02200 02201 #endif 02202
1.7.5.1