00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef _CXSC_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
00074
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
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
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
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
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
00703
00704 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
00705
00706
00707
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
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
00767
00768
00769
00770
00771
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
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
00811
00812
00813
00814
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
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
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
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
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();
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
00990 INLINE ~rvector() { delete [] dat; }
00991
00992
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
01054
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
01084
01085 #ifdef _CXSC_FRIEND_TPL
01086
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
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
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
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
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
01336
01337
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
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
01432
01433
01434 #endif
01435
01436
01437
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
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
01581
01582 };
01583
01584
01585
01587 INLINE rvector _rvector(const real &r) throw();
01588
01589
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
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
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 }
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
