- 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: rvector.hpp,v 1.34 2014/01/30 17:23:48 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_RVECTOR_HPP_INCLUDED 00027 #define _CXSC_RVECTOR_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "dot.hpp" 00031 #include "idot.hpp" 00032 #include "cidot.hpp" 00033 #include "real.hpp" 00034 #include "except.hpp" 00035 #include "vector.hpp" 00036 00037 #include <iostream> 00038 00039 namespace cxsc { 00040 00041 class srvector; 00042 class srvector_slice; 00043 class rvector_slice; 00044 00046 00057 class rvector 00058 { 00059 friend class cvector; 00060 friend class cvector_slice; 00061 friend class cmatrix; 00062 friend class rvector_slice; 00063 friend class rmatrix; 00064 friend class rmatrix_subv; 00065 friend class ivector; 00066 friend class imatrix; 00067 friend class l_ivector; 00068 friend class l_imatrix; 00069 friend class l_rvector; 00070 friend class l_rmatrix; 00071 friend class civector; 00072 friend class cimatrix; 00073 //#if(CXSC_INDEX_CHECK) 00074 //------------ Templates -------------------------------------------------- 00075 00076 #ifdef _CXSC_FRIEND_TPL 00077 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 00078 #if(CXSC_INDEX_CHECK) 00079 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 00080 #else 00081 throw(); 00082 #endif 00083 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00084 #if(CXSC_INDEX_CHECK) 00085 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00086 #else 00087 throw(); 00088 #endif 00089 template <class V> friend void _vresize(V &rv) throw(); 00090 template <class V,class S> friend void _vresize(V &rv, const int &len) 00091 #if(CXSC_INDEX_CHECK) 00092 throw(ERROR__WRONG_BOUNDARIES<V>); 00093 #else 00094 throw(); 00095 #endif 00096 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub) 00097 #if(CXSC_INDEX_CHECK) 00098 throw(ERROR__WRONG_BOUNDARIES<V>); 00099 #else 00100 throw(); 00101 #endif 00102 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 00103 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 00104 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00105 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00106 #if(CXSC_INDEX_CHECK) 00107 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00108 #else 00109 throw(); 00110 #endif 00111 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00112 #if(CXSC_INDEX_CHECK) 00113 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00114 #else 00115 throw(); 00116 #endif 00117 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00118 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00119 #if(CXSC_INDEX_CHECK) 00120 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00121 #else 00122 throw(); 00123 #endif 00124 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00125 00126 //-------- vector-vector ----------------- 00127 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 00128 #if(CXSC_INDEX_CHECK) 00129 throw(OP_WITH_WRONG_DIM); 00130 #else 00131 throw(); 00132 #endif 00133 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00134 #if(CXSC_INDEX_CHECK) 00135 throw(OP_WITH_WRONG_DIM); 00136 #else 00137 throw(); 00138 #endif 00139 00140 00141 template <class V1,class V2,class E> friend E _vvmult(const V1 & rv1, const V2 &rv2) 00142 #if(CXSC_INDEX_CHECK) 00143 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00144 #else 00145 throw(); 00146 #endif 00147 template <class VS,class V,class E> friend E _vsvmult(const VS & sl, const V &rv) 00148 #if(CXSC_INDEX_CHECK) 00149 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00150 #else 00151 throw(); 00152 #endif 00153 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 00154 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw(); 00155 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw(); 00156 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 00157 #if(CXSC_INDEX_CHECK) 00158 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00159 #else 00160 throw(); 00161 #endif 00162 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00163 #if(CXSC_INDEX_CHECK) 00164 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00165 #else 00166 throw(); 00167 #endif 00168 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00169 #if(CXSC_INDEX_CHECK) 00170 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00171 #else 00172 throw(); 00173 #endif 00174 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00175 #if(CXSC_INDEX_CHECK) 00176 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00177 #else 00178 throw(); 00179 #endif 00180 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 00181 #if(CXSC_INDEX_CHECK) 00182 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00183 #else 00184 throw(); 00185 #endif 00186 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 00187 #if(CXSC_INDEX_CHECK) 00188 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00189 #else 00190 throw(); 00191 #endif 00192 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 00193 #if(CXSC_INDEX_CHECK) 00194 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00195 #else 00196 throw(); 00197 #endif 00198 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00199 #if(CXSC_INDEX_CHECK) 00200 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00201 #else 00202 throw(); 00203 #endif 00204 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00205 #if(CXSC_INDEX_CHECK) 00206 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00207 #else 00208 throw(); 00209 #endif 00210 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 00211 #if(CXSC_INDEX_CHECK) 00212 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00213 #else 00214 throw(); 00215 #endif 00216 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 00217 #if(CXSC_INDEX_CHECK) 00218 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00219 #else 00220 throw(); 00221 #endif 00222 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 00223 #if(CXSC_INDEX_CHECK) 00224 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00225 #else 00226 throw(); 00227 #endif 00228 template <class V> friend V _vminus(const V &rv) throw(); 00229 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 00230 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 00231 #if(CXSC_INDEX_CHECK) 00232 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00233 #else 00234 throw(); 00235 #endif 00236 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 00237 #if(CXSC_INDEX_CHECK) 00238 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00239 #else 00240 throw(); 00241 #endif 00242 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 00243 #if(CXSC_INDEX_CHECK) 00244 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00245 #else 00246 throw(); 00247 #endif 00248 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2) 00249 #if(CXSC_INDEX_CHECK) 00250 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00251 #else 00252 throw(); 00253 #endif 00254 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2) 00255 #if(CXSC_INDEX_CHECK) 00256 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00257 #else 00258 throw(); 00259 #endif 00260 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v) 00261 #if(CXSC_INDEX_CHECK) 00262 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00263 #else 00264 throw(); 00265 #endif 00266 00267 template <class M,class V,class E> friend E _mvmult(const M &m,const V &v) 00268 #if(CXSC_INDEX_CHECK) 00269 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00270 #else 00271 throw(); 00272 #endif 00273 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v) 00274 #if(CXSC_INDEX_CHECK) 00275 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00276 #else 00277 throw(); 00278 #endif 00279 template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v) 00280 #if(CXSC_INDEX_CHECK) 00281 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00282 #else 00283 throw(); 00284 #endif 00285 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v) 00286 #if(CXSC_INDEX_CHECK) 00287 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00288 #else 00289 throw(); 00290 #endif 00291 template <class V,class M,class E> friend E _vmmult(const V &v,const M &m) 00292 #if(CXSC_INDEX_CHECK) 00293 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00294 #else 00295 throw(); 00296 #endif 00297 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m) 00298 #if(CXSC_INDEX_CHECK) 00299 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00300 #else 00301 throw(); 00302 #endif 00303 template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m) 00304 #if(CXSC_INDEX_CHECK) 00305 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00306 #else 00307 throw(); 00308 #endif 00309 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m) 00310 #if(CXSC_INDEX_CHECK) 00311 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00312 #else 00313 throw(); 00314 #endif 00315 template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m) 00316 #if(CXSC_INDEX_CHECK) 00317 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00318 #else 00319 throw(); 00320 #endif 00321 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m) 00322 #if(CXSC_INDEX_CHECK) 00323 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00324 #else 00325 throw(); 00326 #endif 00327 template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m) 00328 #if(CXSC_INDEX_CHECK) 00329 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00330 #else 00331 throw(); 00332 #endif 00333 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m) 00334 #if(CXSC_INDEX_CHECK) 00335 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00336 #else 00337 throw(); 00338 #endif 00339 template <class MS,class V,class E> friend E _msvmult(const MS &ms,const V &v) 00340 #if(CXSC_INDEX_CHECK) 00341 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00342 #else 00343 throw(); 00344 #endif 00345 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v) 00346 #if(CXSC_INDEX_CHECK) 00347 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00348 #else 00349 throw(); 00350 #endif 00351 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v) 00352 #if(CXSC_INDEX_CHECK) 00353 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00354 #else 00355 throw(); 00356 #endif 00357 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 00358 #if(CXSC_INDEX_CHECK) 00359 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00360 #else 00361 throw(); 00362 #endif 00363 template <class V,class MS,class E> friend E _vmsmult(const V &v,const MS &ms) 00364 #if(CXSC_INDEX_CHECK) 00365 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00366 #else 00367 throw(); 00368 #endif 00369 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms) 00370 #if(CXSC_INDEX_CHECK) 00371 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00372 #else 00373 throw(); 00374 #endif 00375 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms) 00376 #if(CXSC_INDEX_CHECK) 00377 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00378 #else 00379 throw(); 00380 #endif 00381 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 00382 #if(CXSC_INDEX_CHECK) 00383 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00384 #else 00385 throw(); 00386 #endif 00387 template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms) 00388 #if(CXSC_INDEX_CHECK) 00389 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00390 #else 00391 throw(); 00392 #endif 00393 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms) 00394 #if(CXSC_INDEX_CHECK) 00395 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00396 #else 00397 throw(); 00398 #endif 00399 template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms) 00400 #if(CXSC_INDEX_CHECK) 00401 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00402 #else 00403 throw(); 00404 #endif 00405 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms) 00406 #if(CXSC_INDEX_CHECK) 00407 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00408 #else 00409 throw(); 00410 #endif 00411 template <class V,class MV,class S> friend S _vmvmult(const V &rv1, const MV &rv2) 00412 #if(CXSC_INDEX_CHECK) 00413 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00414 #else 00415 throw(); 00416 #endif 00417 template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2) 00418 #if(CXSC_INDEX_CHECK) 00419 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00420 #else 00421 throw(); 00422 #endif 00423 template <class V,class MV,class S> friend S _vmvcmult(const V &rv1, const MV &rv2) 00424 #if(CXSC_INDEX_CHECK) 00425 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00426 #else 00427 throw(); 00428 #endif 00429 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2) 00430 #if(CXSC_INDEX_CHECK) 00431 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00432 #else 00433 throw(); 00434 #endif 00435 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00436 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00437 #if(CXSC_INDEX_CHECK) 00438 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00439 #else 00440 throw(); 00441 #endif 00442 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00443 #if(CXSC_INDEX_CHECK) 00444 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00445 #else 00446 throw(); 00447 #endif 00448 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00449 #if(CXSC_INDEX_CHECK) 00450 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00451 #else 00452 throw(); 00453 #endif 00454 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00455 #if(CXSC_INDEX_CHECK) 00456 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00457 #else 00458 throw(); 00459 #endif 00460 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00461 #if(CXSC_INDEX_CHECK) 00462 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00463 #else 00464 throw(); 00465 #endif 00466 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00467 #if(CXSC_INDEX_CHECK) 00468 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00469 #else 00470 throw(); 00471 #endif 00472 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00473 #if(CXSC_INDEX_CHECK) 00474 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00475 #else 00476 throw(); 00477 #endif 00478 00479 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 00480 #if(CXSC_INDEX_CHECK) 00481 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00482 #else 00483 throw(); 00484 #endif 00485 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 00486 #if(CXSC_INDEX_CHECK) 00487 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00488 #else 00489 throw(); 00490 #endif 00491 00492 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00493 #if(CXSC_INDEX_CHECK) 00494 throw(OP_WITH_WRONG_DIM); 00495 #else 00496 throw(); 00497 #endif 00498 00499 //--------- vector-scalar ---------------- 00500 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 00501 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00502 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 00503 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00504 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw(); 00505 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 00506 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw(); 00507 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 00508 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw(); 00509 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 00510 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw(); 00511 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 00512 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 00513 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 00514 template <class V> friend bool _vnot(const V &rv) throw(); 00515 template <class V> friend void *_vvoid(const V &rv) throw(); 00516 template <class V,class E> friend E _vabs(const V &rv) throw(); 00517 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00518 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00519 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00520 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00521 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00522 template <class VS> friend bool _vsnot(const VS &sl) throw(); 00523 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 00524 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw(); 00525 template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw(); 00526 00527 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00528 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00529 // Interval 00530 00531 00532 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv) 00533 #if(CXSC_INDEX_CHECK) 00534 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00535 #else 00536 throw(); 00537 #endif 00538 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv) 00539 #if(CXSC_INDEX_CHECK) 00540 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00541 #else 00542 throw(); 00543 #endif 00544 00545 //--- Interval ---- vector-vector ---------- 00546 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2) 00547 #if(CXSC_INDEX_CHECK) 00548 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00549 #else 00550 throw(); 00551 #endif 00552 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2) 00553 #if(CXSC_INDEX_CHECK) 00554 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00555 #else 00556 throw(); 00557 #endif 00558 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2) 00559 #if(CXSC_INDEX_CHECK) 00560 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00561 #else 00562 throw(); 00563 #endif 00564 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2) 00565 #if(CXSC_INDEX_CHECK) 00566 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00567 #else 00568 throw(); 00569 #endif 00570 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv) 00571 #if(CXSC_INDEX_CHECK) 00572 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00573 #else 00574 throw(); 00575 #endif 00576 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv) 00577 #if(CXSC_INDEX_CHECK) 00578 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00579 #else 00580 throw(); 00581 #endif 00582 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv) 00583 #if(CXSC_INDEX_CHECK) 00584 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00585 #else 00586 throw(); 00587 #endif 00588 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv) 00589 #if(CXSC_INDEX_CHECK) 00590 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00591 #else 00592 throw(); 00593 #endif 00594 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv) 00595 #if(CXSC_INDEX_CHECK) 00596 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00597 #else 00598 throw(); 00599 #endif 00600 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv) 00601 #if(CXSC_INDEX_CHECK) 00602 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00603 #else 00604 throw(); 00605 #endif 00606 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv) 00607 #if(CXSC_INDEX_CHECK) 00608 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00609 #else 00610 throw(); 00611 #endif 00612 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv) 00613 #if(CXSC_INDEX_CHECK) 00614 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00615 #else 00616 throw(); 00617 #endif 00618 template <class V,class E> friend E _vdiam(const V &rv) throw(); 00619 template <class V,class E> friend E _vmid(const V &rv) throw(); 00620 template <class V,class E> friend E _vinf(const V &rv) throw(); 00621 template <class V,class E> friend E _vsup(const V &rv) throw(); 00622 template <class VS,class E> friend E _vsdiam(const VS &sl) throw(); 00623 template <class VS,class E> friend E _vsmid(const VS &sl) throw(); 00624 template <class VS,class E> friend E _vsinf(const VS &sl) throw(); 00625 template <class VS,class E> friend E _vssup(const VS &sl) throw(); 00626 template <class MV,class V> friend V _mvdiam(const MV &mv) throw(); 00627 template <class MV,class V> friend V _mvmid(const MV &mv) throw(); 00628 template <class MV,class V> friend V _mvinf(const MV &mv) throw(); 00629 template <class MV,class V> friend V _mvsup(const MV &mv) throw(); 00630 00631 00632 template <class V1,class V2,class E> friend E _vvimult(const V1 & rv1, const V2 &rv2) 00633 #if(CXSC_INDEX_CHECK) 00634 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00635 #else 00636 throw(); 00637 #endif 00638 template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv) 00639 #if(CXSC_INDEX_CHECK) 00640 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00641 #else 00642 throw(); 00643 #endif 00644 00645 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 00646 #if(CXSC_INDEX_CHECK) 00647 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00648 #else 00649 throw(); 00650 #endif 00651 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 00652 #if(CXSC_INDEX_CHECK) 00653 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00654 #else 00655 throw(); 00656 #endif 00657 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 00658 #if(CXSC_INDEX_CHECK) 00659 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00660 #else 00661 throw(); 00662 #endif 00663 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 00664 #if(CXSC_INDEX_CHECK) 00665 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00666 #else 00667 throw(); 00668 #endif 00669 00670 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 00671 #if(CXSC_INDEX_CHECK) 00672 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00673 #else 00674 throw(); 00675 #endif 00676 00677 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 00678 #if(CXSC_INDEX_CHECK) 00679 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00680 #else 00681 throw(); 00682 #endif 00683 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 00684 #if(CXSC_INDEX_CHECK) 00685 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00686 #else 00687 throw(); 00688 #endif 00689 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 00690 #if(CXSC_INDEX_CHECK) 00691 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00692 #else 00693 throw(); 00694 #endif 00695 00696 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 00697 #if(CXSC_INDEX_CHECK) 00698 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00699 #else 00700 throw(); 00701 #endif 00702 //--- Interval ---- vector-scalar ---------- 00703 00704 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 00705 00706 00707 // complex 00708 00709 template <class V,class E> friend E _vim(const V &rv) throw(); 00710 template <class V,class E> friend E _vre(const V &rv) throw(); 00711 template <class MV,class V> friend V _mvim(const MV &mv) throw(); 00712 template <class MV,class V> friend V _mvre(const MV &mv) throw(); 00713 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv) 00714 #if(CXSC_INDEX_CHECK) 00715 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00716 #else 00717 throw(); 00718 #endif 00719 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv) 00720 #if(CXSC_INDEX_CHECK) 00721 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00722 #else 00723 throw(); 00724 #endif 00725 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2) 00726 #if(CXSC_INDEX_CHECK) 00727 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00728 #else 00729 throw(); 00730 #endif 00731 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2) 00732 #if(CXSC_INDEX_CHECK) 00733 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00734 #else 00735 throw(); 00736 #endif 00737 template <class VS,class E> friend E _vsim(const VS &sl) throw(); 00738 template <class VS,class E> friend E _vsre(const VS &sl) throw(); 00739 template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv) 00740 #if(CXSC_INDEX_CHECK) 00741 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00742 #else 00743 throw(); 00744 #endif 00745 template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv) 00746 #if(CXSC_INDEX_CHECK) 00747 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00748 #else 00749 throw(); 00750 #endif 00751 00752 //--- complex ---- vector-vector ---------- 00753 template <class V1,class V2,class E> friend E _vvcmult(const V1 & rv1, const V2 &rv2) 00754 #if(CXSC_INDEX_CHECK) 00755 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00756 #else 00757 throw(); 00758 #endif 00759 template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv) 00760 #if(CXSC_INDEX_CHECK) 00761 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00762 #else 00763 throw(); 00764 #endif 00765 00766 // 5.10. S.W. 00767 00768 //--- complex ---- vector-scalar ---------- 00769 00770 00771 // cinterval ------------------------------ 00773 friend INLINE rvector SupRe(const civector &v) throw(); 00775 friend INLINE rvector SupIm(const civector &v) throw(); 00777 friend INLINE rvector InfRe(const civector &v) throw(); 00779 friend INLINE rvector InfIm(const civector &v) throw(); 00781 friend INLINE rvector SupRe(const civector_slice &v) throw(); 00783 friend INLINE rvector SupIm(const civector_slice &v) throw(); 00785 friend INLINE rvector InfRe(const civector_slice &v) throw(); 00787 friend INLINE rvector InfIm(const civector_slice &v) throw(); 00788 00789 // vector-vector // 5.10. S.W. 00790 00791 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2) 00792 #if(CXSC_INDEX_CHECK) 00793 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00794 #else 00795 throw(); 00796 #endif 00797 template <class VS,class V,class E> friend E _vsvcimult(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 00804 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2) 00805 #if(CXSC_INDEX_CHECK) 00806 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00807 #else 00808 throw(); 00809 #endif 00810 // 5.10. S.W. 00811 00812 // vector-matrix 00813 00814 //--- l_real ---- vector-matrix ---------- 00815 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 00816 #if(CXSC_INDEX_CHECK) 00817 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00818 #else 00819 throw(); 00820 #endif 00821 template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v) 00822 #if(CXSC_INDEX_CHECK) 00823 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00824 #else 00825 throw(); 00826 #endif 00827 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v) 00828 #if(CXSC_INDEX_CHECK) 00829 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00830 #else 00831 throw(); 00832 #endif 00833 00834 template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m) 00835 #if(CXSC_INDEX_CHECK) 00836 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00837 #else 00838 throw(); 00839 #endif 00840 00841 //--- l_real ---- vector-vector ---------- 00842 template <class V1,class V2,class E> friend E _vvlmult(const V1 & rv1, const V2 &rv2) 00843 #if(CXSC_INDEX_CHECK) 00844 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00845 #else 00846 throw(); 00847 #endif 00848 template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv) 00849 #if(CXSC_INDEX_CHECK) 00850 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00851 #else 00852 throw(); 00853 #endif 00854 00855 // vector-vector 00856 00857 template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2) 00858 #if(CXSC_INDEX_CHECK) 00859 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00860 #else 00861 throw(); 00862 #endif 00863 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 00864 #if(CXSC_INDEX_CHECK) 00865 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00866 #else 00867 throw(); 00868 #endif 00869 00870 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 00871 #if(CXSC_INDEX_CHECK) 00872 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00873 #else 00874 throw(); 00875 #endif 00876 00877 // vector-matrix 00878 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 00879 #if(CXSC_INDEX_CHECK) 00880 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00881 #else 00882 throw(); 00883 #endif 00884 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 00885 #if(CXSC_INDEX_CHECK) 00886 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00887 #else 00888 throw(); 00889 #endif 00890 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 00891 #if(CXSC_INDEX_CHECK) 00892 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00893 #else 00894 throw(); 00895 #endif 00896 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 00897 #if(CXSC_INDEX_CHECK) 00898 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00899 #else 00900 throw(); 00901 #endif 00902 #endif 00903 00904 private: 00905 real *dat; 00906 int l,u,size; 00907 00908 public: 00909 double* to_blas_array() const { return (double*)dat; } 00910 //------ Konstruktoren ---------------------------------------------------- 00912 INLINE rvector () throw(); 00914 explicit INLINE rvector(const int &i) throw(); 00915 #ifdef OLD_CXSC 00916 00917 explicit INLINE rvector(const class index &i) throw(); // for backwards compatibility 00918 #endif 00919 00920 explicit INLINE rvector(const int &i1,const int &i2) 00921 #if(CXSC_INDEX_CHECK) 00922 throw(ERROR_RVECTOR_WRONG_BOUNDARIES,ERROR_RVECTOR_NO_MORE_MEMORY); 00923 #else 00924 throw(); 00925 #endif 00926 00927 INLINE rvector(const rmatrix_subv &) throw(); 00929 explicit INLINE rvector(const real &) throw(); 00931 explicit INLINE rvector(const rmatrix &) 00932 #if(CXSC_INDEX_CHECK) 00933 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00934 #else 00935 throw(); 00936 #endif 00937 00938 explicit INLINE rvector(const rmatrix_slice &sl) 00939 #if(CXSC_INDEX_CHECK) 00940 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00941 #else 00942 throw(); 00943 #endif 00944 00946 INLINE rvector(const intvector&); 00947 00949 INLINE rvector(const rvector_slice &rs) throw(); 00951 INLINE rvector(const rvector &v) throw(); 00953 INLINE rvector(const srvector &v); 00955 INLINE rvector(const srvector_slice &v); 00957 INLINE rvector &operator =(const rvector &rv) throw(); 00959 INLINE rvector &operator =(const rvector_slice &sl) throw(); 00961 INLINE rvector &operator =(const srvector &rv); 00963 INLINE rvector &operator =(const srvector_slice &sl); 00965 INLINE rvector &operator =(const real &r) throw(); 00967 INLINE rvector &operator =(const rmatrix &) 00968 #if(CXSC_INDEX_CHECK) 00969 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00970 #else 00971 throw(); 00972 #endif 00973 00974 INLINE rvector &operator =(const rmatrix_slice &) 00975 #if(CXSC_INDEX_CHECK) 00976 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00977 #else 00978 throw(); 00979 #endif 00980 00981 INLINE rvector &operator =(const rmatrix_subv &) throw(); 00982 00984 INLINE rvector operator()(const intvector& p); 00986 INLINE rvector operator()(const intmatrix& P); 00987 00988 00989 //--------- Destruktor ---------------------------------------------------- 00990 INLINE ~rvector() { delete [] dat; } 00991 00992 //------ Standardfunktionen ----------------------------------------------- 00993 00994 friend INLINE real::real(const rvector &) 00995 #if(CXSC_INDEX_CHECK) 00996 throw(ERROR_RVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_RVECTOR_USE_OF_UNINITIALIZED_OBJ); 00997 #else 00998 throw(); 00999 #endif 01000 01001 friend INLINE int Lb(const rvector &rv) throw() { return rv.l; } 01003 friend INLINE int Ub(const rvector &rv) throw() { return rv.u; } 01005 friend INLINE int VecLen(const rvector &rv) throw() { return rv.size; } 01007 friend INLINE rvector &SetLb(rvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv; } 01009 friend INLINE rvector &SetUb(rvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv; } 01011 INLINE real & operator [](const int &i) const 01012 #if(CXSC_INDEX_CHECK) 01013 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC); 01014 #else 01015 throw(); 01016 #endif 01017 01019 INLINE real & operator [](const int &i) 01020 #if(CXSC_INDEX_CHECK) 01021 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC); 01022 #else 01023 throw(); 01024 #endif 01025 01027 INLINE rvector & operator ()() throw() { return *this; } 01029 INLINE rvector_slice operator ()(const int &i) 01030 #if(CXSC_INDEX_CHECK) 01031 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG); 01032 #else 01033 throw(); 01034 #endif 01035 01036 INLINE rvector_slice operator ()(const int &i1,const int &i2) 01037 #if(CXSC_INDEX_CHECK) 01038 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG); 01039 #else 01040 throw(); 01041 #endif 01042 01044 INLINE rvector &operator +=(const srvector &rv); 01046 INLINE rvector &operator +=(const srvector_slice &rv); 01048 INLINE rvector &operator -=(const srvector &rv); 01050 INLINE rvector &operator -=(const srvector_slice &rv); 01051 01052 INLINE operator void*() throw(); 01053 //#else 01054 //#endif 01055 }; 01056 01058 01063 class rvector_slice 01064 { 01065 friend class rvector; 01066 friend class rmatrix; 01067 friend class ivector; 01068 friend class imatrix; 01069 friend class cvector; 01070 friend class cmatrix; 01071 friend class civector; 01072 friend class cimatrix; 01073 friend class l_rvector; 01074 friend class l_rmatrix; 01075 friend class l_ivector; 01076 friend class l_imatrix; 01077 private: 01078 real *dat; 01079 int l,u,size; 01080 int start,end; 01081 01082 public: 01083 //#if(CXSC_INDEX_CHECK) 01084 01085 #ifdef _CXSC_FRIEND_TPL 01086 //------------------------- Templates ------------------------------------------- 01087 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2) 01088 #if(CXSC_INDEX_CHECK) 01089 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01090 #else 01091 throw(); 01092 #endif 01093 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 01094 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 01095 #if(CXSC_INDEX_CHECK) 01096 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01097 #else 01098 throw(); 01099 #endif 01100 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw(); 01101 template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m) 01102 #if(CXSC_INDEX_CHECK) 01103 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01104 #else 01105 throw(); 01106 #endif 01107 //-------- vector-scalar ------------------ 01108 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw(); 01109 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw(); 01110 01111 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 01112 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 01113 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 01114 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 01115 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 01116 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 01117 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 01118 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 01119 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 01120 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 01121 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 01122 template <class VS> friend bool _vsnot(const VS &sl) throw(); 01123 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 01124 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw(); 01125 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw(); 01126 //------- vector-vector ----------------- 01127 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 01128 #if(CXSC_INDEX_CHECK) 01129 throw(OP_WITH_WRONG_DIM); 01130 #else 01131 throw(); 01132 #endif 01133 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 01134 #if(CXSC_INDEX_CHECK) 01135 throw(OP_WITH_WRONG_DIM); 01136 #else 01137 throw(); 01138 #endif 01139 01140 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 01141 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 01142 template <class VS,class V,class E> friend E _vsvmult(const VS & sl, const V &rv) 01143 #if(CXSC_INDEX_CHECK) 01144 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01145 #else 01146 throw(); 01147 #endif 01148 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 01149 #if(CXSC_INDEX_CHECK) 01150 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01151 #else 01152 throw(); 01153 #endif 01154 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 01155 #if(CXSC_INDEX_CHECK) 01156 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01157 #else 01158 throw(); 01159 #endif 01160 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 01161 #if(CXSC_INDEX_CHECK) 01162 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01163 #else 01164 throw(); 01165 #endif 01166 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 01167 #if(CXSC_INDEX_CHECK) 01168 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01169 #else 01170 throw(); 01171 #endif 01172 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 01173 #if(CXSC_INDEX_CHECK) 01174 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01175 #else 01176 throw(); 01177 #endif 01178 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 01179 #if(CXSC_INDEX_CHECK) 01180 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01181 #else 01182 throw(); 01183 #endif 01184 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 01185 #if(CXSC_INDEX_CHECK) 01186 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01187 #else 01188 throw(); 01189 #endif 01190 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 01191 #if(CXSC_INDEX_CHECK) 01192 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01193 #else 01194 throw(); 01195 #endif 01196 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 01197 #if(CXSC_INDEX_CHECK) 01198 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01199 #else 01200 throw(); 01201 #endif 01202 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 01203 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 01204 #if(CXSC_INDEX_CHECK) 01205 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01206 #else 01207 throw(); 01208 #endif 01209 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 01210 #if(CXSC_INDEX_CHECK) 01211 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01212 #else 01213 throw(); 01214 #endif 01215 template <class VS1,class VS2,class E> friend E _vsvsmult(const VS1 & sl1, const VS2 &sl2) 01216 #if(CXSC_INDEX_CHECK) 01217 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01218 #else 01219 throw(); 01220 #endif 01221 01222 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 01223 #if(CXSC_INDEX_CHECK) 01224 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01225 #else 01226 throw(); 01227 #endif 01228 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 01229 #if(CXSC_INDEX_CHECK) 01230 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01231 #else 01232 throw(); 01233 #endif 01234 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 01235 #if(CXSC_INDEX_CHECK) 01236 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01237 #else 01238 throw(); 01239 #endif 01240 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 01241 #if(CXSC_INDEX_CHECK) 01242 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01243 #else 01244 throw(); 01245 #endif 01246 // interval ----------- 01247 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl) 01248 #if(CXSC_INDEX_CHECK) 01249 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01250 #else 01251 throw(); 01252 #endif 01253 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl) 01254 #if(CXSC_INDEX_CHECK) 01255 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01256 #else 01257 throw(); 01258 #endif 01259 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl) 01260 #if(CXSC_INDEX_CHECK) 01261 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01262 #else 01263 throw(); 01264 #endif 01265 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl) 01266 #if(CXSC_INDEX_CHECK) 01267 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01268 #else 01269 throw(); 01270 #endif 01271 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2) 01272 #if(CXSC_INDEX_CHECK) 01273 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01274 #else 01275 throw(); 01276 #endif 01277 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2) 01278 #if(CXSC_INDEX_CHECK) 01279 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01280 #else 01281 throw(); 01282 #endif 01283 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2) 01284 #if(CXSC_INDEX_CHECK) 01285 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01286 #else 01287 throw(); 01288 #endif 01289 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2) 01290 #if(CXSC_INDEX_CHECK) 01291 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01292 #else 01293 throw(); 01294 #endif 01295 // interval ----------------- 01296 01297 01298 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 01299 #if(CXSC_INDEX_CHECK) 01300 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01301 #else 01302 throw(); 01303 #endif 01304 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 01305 #if(CXSC_INDEX_CHECK) 01306 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01307 #else 01308 throw(); 01309 #endif 01310 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 01311 #if(CXSC_INDEX_CHECK) 01312 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01313 #else 01314 throw(); 01315 #endif 01316 01317 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 01318 #if(CXSC_INDEX_CHECK) 01319 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01320 #else 01321 throw(); 01322 #endif 01323 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 01324 #if(CXSC_INDEX_CHECK) 01325 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01326 #else 01327 throw(); 01328 #endif 01329 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 01330 #if(CXSC_INDEX_CHECK) 01331 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01332 #else 01333 throw(); 01334 #endif 01335 // Interval 01336 01337 //-- Interval ------- vector-vector ------------ 01338 01339 template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv) 01340 #if(CXSC_INDEX_CHECK) 01341 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01342 #else 01343 throw(); 01344 #endif 01345 template <class VS1,class VS2,class E> friend E _vsvsimult(const VS1 & sl1, const VS2 &sl2) 01346 #if(CXSC_INDEX_CHECK) 01347 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01348 #else 01349 throw(); 01350 #endif 01351 01352 template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2) 01353 #if(CXSC_INDEX_CHECK) 01354 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01355 #else 01356 throw(); 01357 #endif 01358 template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2) 01359 #if(CXSC_INDEX_CHECK) 01360 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01361 #else 01362 throw(); 01363 #endif 01364 template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl) 01365 #if(CXSC_INDEX_CHECK) 01366 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01367 #else 01368 throw(); 01369 #endif 01370 template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl) 01371 #if(CXSC_INDEX_CHECK) 01372 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01373 #else 01374 throw(); 01375 #endif 01376 01377 //-- complex ------- vector-vector ------------ 01378 01379 template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv) 01380 #if(CXSC_INDEX_CHECK) 01381 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01382 #else 01383 throw(); 01384 #endif 01385 template <class VS1,class VS2,class E> friend E _vsvscmult(const VS1 & sl1, const VS2 &sl2) 01386 #if(CXSC_INDEX_CHECK) 01387 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01388 #else 01389 throw(); 01390 #endif 01391 01392 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv) 01393 #if(CXSC_INDEX_CHECK) 01394 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01395 #else 01396 throw(); 01397 #endif 01398 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2) 01399 #if(CXSC_INDEX_CHECK) 01400 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01401 #else 01402 throw(); 01403 #endif 01404 01405 template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv) 01406 #if(CXSC_INDEX_CHECK) 01407 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01408 #else 01409 throw(); 01410 #endif 01411 template <class VS1,class VS2,class E> friend E _vsvslmult(const VS1 & sl1, const VS2 &sl2) 01412 #if(CXSC_INDEX_CHECK) 01413 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01414 #else 01415 throw(); 01416 #endif 01417 01418 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv) 01419 #if(CXSC_INDEX_CHECK) 01420 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01421 #else 01422 throw(); 01423 #endif 01424 template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 01425 #if(CXSC_INDEX_CHECK) 01426 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01427 #else 01428 throw(); 01429 #endif 01430 01431 // l_interval -- vector-matrix 01432 01433 01434 #endif 01435 01436 01437 //--------------------- Konstruktoren ----------------------------------- 01439 explicit INLINE rvector_slice(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) { } 01441 explicit INLINE rvector_slice(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) { } 01442 public: 01444 INLINE rvector_slice(const rvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { } 01445 public: 01447 INLINE rvector_slice & operator =(const rvector_slice &sl) 01448 #if(CXSC_INDEX_CHECK) 01449 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01450 #else 01451 throw(); 01452 #endif 01453 01454 INLINE rvector_slice & operator =(const rvector &rv) 01455 #if(CXSC_INDEX_CHECK) 01456 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01457 #else 01458 throw(); 01459 #endif 01460 01461 INLINE rvector_slice & operator =(const srvector &rv); 01463 INLINE rvector_slice & operator =(const srvector_slice &rv); 01465 INLINE rvector_slice & operator =(const real &r) throw(); 01467 INLINE rvector_slice & operator =(const rmatrix &m) 01468 #if(CXSC_INDEX_CHECK) 01469 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01470 #else 01471 throw(); 01472 #endif 01473 01474 INLINE rvector_slice & operator =(const rmatrix_slice &m) 01475 #if(CXSC_INDEX_CHECK) 01476 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01477 #else 01478 throw(); 01479 #endif 01480 01481 INLINE rvector_slice &operator =(const rmatrix_subv &) throw(); 01482 01483 //--------------------- Standardfunktionen ------------------------------ 01484 01485 friend INLINE real::real(const rvector_slice &sl) 01486 #if(CXSC_INDEX_CHECK) 01487 throw(ERROR_RVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_RVECTOR_USE_OF_UNINITIALIZED_OBJ); 01488 #else 01489 throw(); 01490 #endif 01491 01492 friend INLINE int Lb(const rvector_slice &sl) throw() { return sl.start; } 01494 friend INLINE int Ub(const rvector_slice &sl) throw() { return sl.end; } 01496 friend INLINE int VecLen(const rvector_slice &sl) throw() { return sl.end-sl.start+1; } 01498 INLINE real & operator [](const int &i) 01499 #if(CXSC_INDEX_CHECK) 01500 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC); 01501 #else 01502 throw(); 01503 #endif 01504 01506 INLINE real & operator [](const int &i) const 01507 #if(CXSC_INDEX_CHECK) 01508 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC); 01509 #else 01510 throw(); 01511 #endif 01512 01514 INLINE rvector_slice & operator ()() throw() { return *this; } 01516 INLINE rvector_slice operator ()(const int &i) 01517 #if(CXSC_INDEX_CHECK) 01518 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG); 01519 #else 01520 throw(); 01521 #endif 01522 01523 INLINE rvector_slice operator ()(const int &i1,const int &i2) 01524 #if(CXSC_INDEX_CHECK) 01525 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG); 01526 #else 01527 throw(); 01528 #endif 01529 01530 INLINE rvector_slice &operator /=(const real &r) throw(); 01532 INLINE rvector_slice &operator *=(const real &r) throw(); 01534 INLINE rvector_slice &operator *=(const rmatrix &m) 01535 #if(CXSC_INDEX_CHECK) 01536 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01537 #else 01538 throw(); 01539 #endif 01540 01541 INLINE rvector_slice &operator +=(const rvector &rv) 01542 #if(CXSC_INDEX_CHECK) 01543 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01544 #else 01545 throw(); 01546 #endif 01547 01548 INLINE rvector_slice &operator +=(const rvector_slice &sl2) 01549 #if(CXSC_INDEX_CHECK) 01550 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01551 #else 01552 throw(); 01553 #endif 01554 01555 INLINE rvector_slice &operator -=(const rvector &rv) 01556 #if(CXSC_INDEX_CHECK) 01557 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01558 #else 01559 throw(); 01560 #endif 01561 01562 INLINE rvector_slice &operator -=(const rvector_slice &sl2) 01563 #if(CXSC_INDEX_CHECK) 01564 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01565 #else 01566 throw(); 01567 #endif 01568 01570 INLINE rvector_slice &operator +=(const srvector &rv); 01572 INLINE rvector_slice &operator +=(const srvector_slice &rv); 01574 INLINE rvector_slice &operator -=(const srvector &rv); 01576 INLINE rvector_slice &operator -=(const srvector_slice &rv); 01577 01578 01579 INLINE operator void*() throw(); 01580 //#else 01581 //#endif 01582 }; 01583 01584 //======================== Vector Functions ============================= 01585 01587 INLINE rvector _rvector(const real &r) throw(); 01588 // INLINE rvector _rvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01589 // INLINE rvector _rvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01590 01592 INLINE void Resize(rvector &rv) throw(); 01594 INLINE void Resize(rvector &rv, const int &len) 01595 #if(CXSC_INDEX_CHECK) 01596 throw(ERROR__WRONG_BOUNDARIES<rvector>); 01597 #else 01598 throw(); 01599 #endif 01600 01601 INLINE void Resize(rvector &rv, const int &lb, const int &ub) 01602 #if(CXSC_INDEX_CHECK) 01603 throw(ERROR__WRONG_BOUNDARIES<rvector>); 01604 #else 01605 throw(); 01606 #endif 01607 01609 INLINE rvector abs(const rvector &rv) throw(); 01611 INLINE rvector abs(const rvector_slice &sl) throw(); 01613 INLINE bool operator !(const rvector &rv) throw(); 01615 INLINE bool operator !(const rvector_slice &sl) throw(); 01616 01617 //======================= Vector / Scalar =============================== 01618 01620 INLINE rvector operator *(const rvector &rv, const real &s) throw(); 01622 INLINE rvector operator *(const rvector_slice &sl, const real &s) throw(); 01624 INLINE rvector operator *(const real &s, const rvector &rv) throw(); 01626 INLINE rvector operator *(const real &s, const rvector_slice &sl) throw(); 01628 INLINE rvector &operator *=(rvector &rv,const real &r) throw(); 01629 01631 INLINE rvector operator /(const rvector &rv, const real &s) throw(); 01633 INLINE rvector operator /(const rvector_slice &sl, const real &s) throw(); 01635 INLINE rvector &operator /=(rvector &rv,const real &r) throw(); 01636 01637 //======================= Vector / Vector =============================== 01638 01640 void accumulate(dotprecision &dp, const rvector &); 01641 01643 void accumulate(dotprecision &dp, const rvector & rv1, const rvector &rv2) 01644 #if(CXSC_INDEX_CHECK) 01645 throw(OP_WITH_WRONG_DIM); 01646 #else 01647 throw(); 01648 #endif 01649 01651 void accumulate_approx(dotprecision &dp, const rvector & rv1, const rvector &rv2); 01652 01653 01655 void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 01656 #if(CXSC_INDEX_CHECK) 01657 throw(OP_WITH_WRONG_DIM); 01658 #else 01659 throw(); 01660 #endif 01661 01663 void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2); 01664 01665 01667 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 01668 #if(CXSC_INDEX_CHECK) 01669 throw(OP_WITH_WRONG_DIM); 01670 #else 01671 throw(); 01672 #endif 01673 01675 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2); 01676 01678 void accumulate(dotprecision &dp,const rvector_slice &sl,const rvector &rv) 01679 #if(CXSC_INDEX_CHECK) 01680 throw(OP_WITH_WRONG_DIM); 01681 #else 01682 throw(); 01683 #endif 01684 01686 void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rvector &rv); 01687 01688 01690 void accumulate(dotprecision &dp,const rvector &rv,const rvector_slice &sl) 01691 #if(CXSC_INDEX_CHECK) 01692 throw(OP_WITH_WRONG_DIM); 01693 #else 01694 throw(); 01695 #endif 01696 01698 void accumulate_approx(dotprecision &dp,const rvector &rv,const rvector_slice &sl); 01699 01700 01702 void accumulate(dotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2) 01703 #if(CXSC_INDEX_CHECK) 01704 throw(OP_WITH_WRONG_DIM); 01705 #else 01706 throw(); 01707 #endif 01708 01710 void accumulate_approx(dotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2); 01711 01712 01714 void accumulate(idotprecision &dp, const rvector & rv1, const rvector &rv2) 01715 #if(CXSC_INDEX_CHECK) 01716 throw(OP_WITH_WRONG_DIM); 01717 #else 01718 throw(); 01719 #endif 01720 01721 void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 01722 #if(CXSC_INDEX_CHECK) 01723 throw(OP_WITH_WRONG_DIM); 01724 #else 01725 throw(); 01726 #endif 01727 01728 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 01729 #if(CXSC_INDEX_CHECK) 01730 throw(OP_WITH_WRONG_DIM); 01731 #else 01732 throw(); 01733 #endif 01734 01735 void accumulate(idotprecision &dp,const rvector_slice &sl,const rvector &rv) 01736 #if(CXSC_INDEX_CHECK) 01737 throw(OP_WITH_WRONG_DIM); 01738 #else 01739 throw(); 01740 #endif 01741 01742 void accumulate(idotprecision &dp,const rvector &rv,const rvector_slice &sl) 01743 #if(CXSC_INDEX_CHECK) 01744 throw(OP_WITH_WRONG_DIM); 01745 #else 01746 throw(); 01747 #endif 01748 01749 void accumulate(idotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2) 01750 #if(CXSC_INDEX_CHECK) 01751 throw(OP_WITH_WRONG_DIM); 01752 #else 01753 throw(); 01754 #endif 01755 01757 void accumulate(cdotprecision &dp, const rvector & rv1, const rvector &rv2) 01758 #if(CXSC_INDEX_CHECK) 01759 throw(OP_WITH_WRONG_DIM); 01760 #else 01761 throw(); 01762 #endif 01763 01765 void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rvector &rv2); 01766 01768 void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 01769 #if(CXSC_INDEX_CHECK) 01770 throw(OP_WITH_WRONG_DIM); 01771 #else 01772 throw(); 01773 #endif 01774 01776 void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2); 01777 01779 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 01780 #if(CXSC_INDEX_CHECK) 01781 throw(OP_WITH_WRONG_DIM); 01782 #else 01783 throw(); 01784 #endif 01785 01787 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2); 01788 01790 void accumulate(cdotprecision &dp,const rvector_slice &sl,const rvector &rv) 01791 #if(CXSC_INDEX_CHECK) 01792 throw(OP_WITH_WRONG_DIM); 01793 #else 01794 throw(); 01795 #endif 01796 01798 void accumulate_approx(cdotprecision &dp,const rvector_slice &sl,const rvector &rv); 01799 01801 void accumulate(cdotprecision &dp,const rvector &rv,const rvector_slice &sl) 01802 #if(CXSC_INDEX_CHECK) 01803 throw(OP_WITH_WRONG_DIM); 01804 #else 01805 throw(); 01806 #endif 01807 01809 void accumulate_approx(cdotprecision &dp,const rvector &rv,const rvector_slice &sl); 01810 01812 void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2) 01813 #if(CXSC_INDEX_CHECK) 01814 throw(OP_WITH_WRONG_DIM); 01815 #else 01816 throw(); 01817 #endif 01818 01820 void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2); 01821 01823 void accumulate(cidotprecision &dp, const rvector & rv1, const rvector &rv2) 01824 #if(CXSC_INDEX_CHECK) 01825 throw(OP_WITH_WRONG_DIM); 01826 #else 01827 throw(); 01828 #endif 01829 01830 void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 01831 #if(CXSC_INDEX_CHECK) 01832 throw(OP_WITH_WRONG_DIM); 01833 #else 01834 throw(); 01835 #endif 01836 01837 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 01838 #if(CXSC_INDEX_CHECK) 01839 throw(OP_WITH_WRONG_DIM); 01840 #else 01841 throw(); 01842 #endif 01843 01844 void accumulate(cidotprecision &dp,const rvector_slice &sl,const rvector &rv) 01845 #if(CXSC_INDEX_CHECK) 01846 throw(OP_WITH_WRONG_DIM); 01847 #else 01848 throw(); 01849 #endif 01850 01851 void accumulate(cidotprecision &dp,const rvector &rv,const rvector_slice &sl) 01852 #if(CXSC_INDEX_CHECK) 01853 throw(OP_WITH_WRONG_DIM); 01854 #else 01855 throw(); 01856 #endif 01857 01858 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2) 01859 #if(CXSC_INDEX_CHECK) 01860 throw(OP_WITH_WRONG_DIM); 01861 #else 01862 throw(); 01863 #endif 01864 01866 INLINE real operator *(const rvector & rv1, const rvector &rv2) 01867 #if(CXSC_INDEX_CHECK) 01868 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01869 #else 01870 throw(); 01871 #endif 01872 01873 INLINE real operator *(const rvector_slice &sl, const rvector &rv) 01874 #if(CXSC_INDEX_CHECK) 01875 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01876 #else 01877 throw(); 01878 #endif 01879 01880 INLINE real operator *(const rvector &rv, const rvector_slice &sl) 01881 #if(CXSC_INDEX_CHECK) 01882 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01883 #else 01884 throw(); 01885 #endif 01886 01887 INLINE real operator *(const rvector_slice & sl1, const rvector_slice &sl2) 01888 #if(CXSC_INDEX_CHECK) 01889 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01890 #else 01891 throw(); 01892 #endif 01893 01895 INLINE const rvector &operator +(const rvector &rv) throw(); 01897 INLINE rvector operator +(const rvector_slice &sl) throw(); 01899 INLINE rvector operator +(const rvector &rv1, const rvector &rv2) 01900 #if(CXSC_INDEX_CHECK) 01901 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01902 #else 01903 throw(); 01904 #endif 01905 01906 INLINE rvector operator +(const rvector &rv, const rvector_slice &sl) 01907 #if(CXSC_INDEX_CHECK) 01908 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01909 #else 01910 throw(); 01911 #endif 01912 01913 INLINE rvector operator +(const rvector_slice &sl, const rvector &rv) 01914 #if(CXSC_INDEX_CHECK) 01915 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01916 #else 01917 throw(); 01918 #endif 01919 01920 INLINE rvector operator +(const rvector_slice &sl1, const rvector_slice &sl2) 01921 #if(CXSC_INDEX_CHECK) 01922 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01923 #else 01924 throw(); 01925 #endif 01926 01927 INLINE rvector & operator +=(rvector &rv1, const rvector &rv2) 01928 #if(CXSC_INDEX_CHECK) 01929 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01930 #else 01931 throw(); 01932 #endif 01933 01934 INLINE rvector &operator +=(rvector &rv, const rvector_slice &sl) 01935 #if(CXSC_INDEX_CHECK) 01936 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01937 #else 01938 throw(); 01939 #endif 01940 01942 INLINE rvector operator -(const rvector &rv) throw(); 01944 INLINE rvector operator -(const rvector_slice &sl) throw(); 01946 INLINE rvector operator -(const rvector &rv1, const rvector &rv2) 01947 #if(CXSC_INDEX_CHECK) 01948 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01949 #else 01950 throw(); 01951 #endif 01952 01953 INLINE rvector operator -(const rvector &rv, const rvector_slice &sl) 01954 #if(CXSC_INDEX_CHECK) 01955 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01956 #else 01957 throw(); 01958 #endif 01959 01960 INLINE rvector operator -(const rvector_slice &sl, const rvector &rv) 01961 #if(CXSC_INDEX_CHECK) 01962 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01963 #else 01964 throw(); 01965 #endif 01966 01967 INLINE rvector operator -(const rvector_slice &sl1, const rvector_slice &sl2) 01968 #if(CXSC_INDEX_CHECK) 01969 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01970 #else 01971 throw(); 01972 #endif 01973 01974 INLINE rvector & operator -=(rvector &rv1, const rvector &rv2) 01975 #if(CXSC_INDEX_CHECK) 01976 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01977 #else 01978 throw(); 01979 #endif 01980 01981 INLINE rvector &operator -=(rvector &rv, const rvector_slice &sl) 01982 #if(CXSC_INDEX_CHECK) 01983 throw(ERROR__OP_WITH_WRONG_DIM<rvector>); 01984 #else 01985 throw(); 01986 #endif 01987 01989 INLINE bool operator ==(const rvector &rv1, const rvector &rv2) throw(); 01991 INLINE bool operator ==(const rvector_slice &sl1, const rvector_slice &sl2) throw(); 01993 INLINE bool operator ==(const rvector_slice &sl, const rvector &rv) throw(); 01995 INLINE bool operator ==(const rvector &rv, const rvector_slice &sl) throw(); 01997 INLINE bool operator !=(const rvector &rv1, const rvector &rv2) throw(); 01999 INLINE bool operator !=(const rvector_slice &sl1, const rvector_slice &sl2) throw(); 02001 INLINE bool operator !=(const rvector_slice &sl, const rvector &rv) throw(); 02003 INLINE bool operator !=(const rvector &rv, const rvector_slice &sl) throw(); 02005 INLINE bool operator <(const rvector &rv1, const rvector &rv2) throw(); 02007 INLINE bool operator <(const rvector_slice &sl1, const rvector_slice &sl2) throw(); 02009 INLINE bool operator < (const rvector_slice &sl, const rvector &rv) throw(); 02011 INLINE bool operator < (const rvector &rv, const rvector_slice &sl) throw(); 02013 INLINE bool operator <=(const rvector &rv1, const rvector &rv2) throw(); 02015 INLINE bool operator <=(const rvector_slice &sl1, const rvector_slice &sl2) throw(); 02017 INLINE bool operator <=(const rvector_slice &sl, const rvector &rv) throw(); 02019 INLINE bool operator <=(const rvector &rv, const rvector_slice &sl) throw(); 02021 INLINE bool operator >(const rvector &rv1, const rvector &rv2) throw(); 02023 INLINE bool operator >(const rvector_slice &sl1, const rvector_slice &sl2) throw(); 02025 INLINE bool operator >(const rvector_slice &sl, const rvector &rv) throw(); 02027 INLINE bool operator >(const rvector &rv, const rvector_slice &sl) throw(); 02029 INLINE bool operator >=(const rvector &rv1, const rvector &rv2) throw(); 02031 INLINE bool operator >=(const rvector_slice &sl1, const rvector_slice &sl2) throw(); 02033 INLINE bool operator >=(const rvector_slice &sl, const rvector &rv) throw(); 02035 INLINE bool operator >=(const rvector &rv, const rvector_slice &sl) throw(); 02036 02038 INLINE std::ostream &operator <<(std::ostream &s, const rvector &rv) throw(); 02040 INLINE std::ostream &operator <<(std::ostream &o, const rvector_slice &sl) throw(); 02042 INLINE std::istream &operator >>(std::istream &s, rvector &rv) throw(); 02044 INLINE std::istream &operator >>(std::istream &s, rvector_slice &rv) throw(); 02045 02046 02047 } // namespace cxsc 02048 02049 #ifdef _CXSC_INCL_INL 02050 #include "rvector.inl" 02051 #include "vector.inl" 02052 #endif 02053 02054 #ifdef CXSC_USE_BLAS 02055 #define _CXSC_BLAS_RVECTOR 02056 #include "cxsc_blas.inl" 02057 #endif 02058 02059 #endif
1.7.5.1