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