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_CIVECTOR_HPP_INCLUDED
00027 #define _CXSC_CIVECTOR_HPP_INCLUDED
00028
00029 #include "xscclass.hpp"
00030 #include "except.hpp"
00031 #include "cidot.hpp"
00032 #include "cinterval.hpp"
00033
00034 #include "rvector.hpp"
00035 #include "ivector.hpp"
00036 #include "cvector.hpp"
00037 #include "vector.hpp"
00038
00039
00040 #include <iostream>
00041
00042
00043
00044 namespace cxsc {
00045
00046 class civector_slice;
00047 class scivector;
00048 class scivector_slice;
00049
00051
00056 class civector
00057 {
00058 friend class civector_slice;
00059 friend class cimatrix;
00060 friend class cimatrix_subv;
00061 private:
00062 cinterval *dat;
00063 int l,u,size;
00064
00065 public:
00066
00067 #ifdef _CXSC_FRIEND_TPL
00068
00069
00070 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
00071 #if(CXSC_INDEX_CHECK)
00072 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
00073 #else
00074 throw();
00075 #endif
00076 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
00077 #if(CXSC_INDEX_CHECK)
00078 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00079 #else
00080 throw();
00081 #endif
00082 template <class V> friend void _vresize(V &rv) throw();
00083 template <class V,class S> friend void _vresize(V &rv, const int &len)
00084 #if(CXSC_INDEX_CHECK)
00085 throw(ERROR__WRONG_BOUNDARIES<V>);
00086 #else
00087 throw();
00088 #endif
00089 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
00090 #if(CXSC_INDEX_CHECK)
00091 throw(ERROR__WRONG_BOUNDARIES<V>);
00092 #else
00093 throw();
00094 #endif
00095 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
00096 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
00097 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
00098 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
00099 #if(CXSC_INDEX_CHECK)
00100 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00101 #else
00102 throw();
00103 #endif
00104 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
00105 #if(CXSC_INDEX_CHECK)
00106 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00107 #else
00108 throw();
00109 #endif
00110 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
00111 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00112 #if(CXSC_INDEX_CHECK)
00113 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00114 #else
00115 throw();
00116 #endif
00117 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00118 #if(CXSC_INDEX_CHECK)
00119 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00120 #else
00121 throw();
00122 #endif
00123 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
00124 #if(CXSC_INDEX_CHECK)
00125 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00126 #else
00127 throw();
00128 #endif
00129 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
00130 #if(CXSC_INDEX_CHECK)
00131 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00132 #else
00133 throw();
00134 #endif
00135 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
00136 #if(CXSC_INDEX_CHECK)
00137 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00138 #else
00139 throw();
00140 #endif
00141 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
00142 #if(CXSC_INDEX_CHECK)
00143 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00144 #else
00145 throw();
00146 #endif
00147 template <class V1,class V2> friend V1 &_vvusetinf(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 V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00154 #if(CXSC_INDEX_CHECK)
00155 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00156 #else
00157 throw();
00158 #endif
00159 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
00160 #if(CXSC_INDEX_CHECK)
00161 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00162 #else
00163 throw();
00164 #endif
00165 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
00166 #if(CXSC_INDEX_CHECK)
00167 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00168 #else
00169 throw();
00170 #endif
00171 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
00172 #if(CXSC_INDEX_CHECK)
00173 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00174 #else
00175 throw();
00176 #endif
00177 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
00178 #if(CXSC_INDEX_CHECK)
00179 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00180 #else
00181 throw();
00182 #endif
00183 template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw();
00184 template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw();
00185 template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw();
00186 template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw();
00187 template <class V,class S> friend V &_vssetim(V &v, const S &s) throw();
00188 template <class V,class S> friend V &_vssetre(V &v, const S &s) throw();
00189 template <class V> friend V _vconj(const V &rv) throw();
00190 template <class VS,class E> friend E _vsconj(const VS &sl) throw();
00191 template <class V,class E> friend E _vabs(const V &rv) throw();
00192 template <class VS,class E> friend E _vsabs(const VS &sl) throw();
00193 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
00194 template <class V,class E> friend E _vdiam(const V &rv) throw();
00195 template <class V,class E> friend E _vmid(const V &rv) throw();
00196 template <class V,class E> friend E _vinf(const V &rv) throw();
00197 template <class V,class E> friend E _vsup(const V &rv) throw();
00198 template <class V,class E> friend E _vim(const V &rv) throw();
00199 template <class V,class E> friend E _vre(const V &rv) throw();
00200 friend INLINE ivector Re(const civector &v) throw();
00201 friend INLINE ivector Im(const civector &v) throw();
00202 friend INLINE cvector Inf(const civector &v) throw();
00203 friend INLINE cvector Sup(const civector &v) throw();
00204 friend INLINE rvector SupRe(const civector &v) throw();
00205 friend INLINE rvector SupIm(const civector &v) throw();
00206 friend INLINE rvector InfRe(const civector &v) throw();
00207 friend INLINE rvector InfIm(const civector &v) throw();
00208 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
00209 #if(CXSC_INDEX_CHECK)
00210 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00211 #else
00212 throw();
00213 #endif
00214 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
00215 #if(CXSC_INDEX_CHECK)
00216 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00217 #else
00218 throw();
00219 #endif
00220 template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
00221 #if(CXSC_INDEX_CHECK)
00222 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00223 #else
00224 throw();
00225 #endif
00226 template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
00227 #if(CXSC_INDEX_CHECK)
00228 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00229 #else
00230 throw();
00231 #endif
00232 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
00233 #if(CXSC_INDEX_CHECK)
00234 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00235 #else
00236 throw();
00237 #endif
00238 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
00239 #if(CXSC_INDEX_CHECK)
00240 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00241 #else
00242 throw();
00243 #endif
00244
00245
00246 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00247 #if(CXSC_INDEX_CHECK)
00248 throw(OP_WITH_WRONG_DIM);
00249 #else
00250 throw();
00251 #endif
00252 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00253 #if(CXSC_INDEX_CHECK)
00254 throw(OP_WITH_WRONG_DIM);
00255 #else
00256 throw();
00257 #endif
00258
00259 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
00260 #if(CXSC_INDEX_CHECK)
00261 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00262 #else
00263 throw();
00264 #endif
00265 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
00266 #if(CXSC_INDEX_CHECK)
00267 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00268 #else
00269 throw();
00270 #endif
00271
00272 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
00273 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
00274 #if(CXSC_INDEX_CHECK)
00275 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00276 #else
00277 throw();
00278 #endif
00279 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
00280 #if(CXSC_INDEX_CHECK)
00281 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00282 #else
00283 throw();
00284 #endif
00285 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
00286 #if(CXSC_INDEX_CHECK)
00287 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00288 #else
00289 throw();
00290 #endif
00291 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
00292 #if(CXSC_INDEX_CHECK)
00293 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00294 #else
00295 throw();
00296 #endif
00297 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00298 #if(CXSC_INDEX_CHECK)
00299 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00300 #else
00301 throw();
00302 #endif
00303 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
00304 #if(CXSC_INDEX_CHECK)
00305 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00306 #else
00307 throw();
00308 #endif
00309 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
00310 #if(CXSC_INDEX_CHECK)
00311 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00312 #else
00313 throw();
00314 #endif
00315 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00316 #if(CXSC_INDEX_CHECK)
00317 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00318 #else
00319 throw();
00320 #endif
00321 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00322 #if(CXSC_INDEX_CHECK)
00323 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00324 #else
00325 throw();
00326 #endif
00327 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00328 #if(CXSC_INDEX_CHECK)
00329 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00330 #else
00331 throw();
00332 #endif
00333 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
00334 #if(CXSC_INDEX_CHECK)
00335 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00336 #else
00337 throw();
00338 #endif
00339 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
00340 #if(CXSC_INDEX_CHECK)
00341 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00342 #else
00343 throw();
00344 #endif
00345 template <class V> friend V _vminus(const V &rv) throw();
00346 template <class VS,class V> friend V _vsminus(const VS &sl) throw();
00347 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
00348 #if(CXSC_INDEX_CHECK)
00349 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00350 #else
00351 throw();
00352 #endif
00353 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
00354 #if(CXSC_INDEX_CHECK)
00355 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00356 #else
00357 throw();
00358 #endif
00359 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
00360 #if(CXSC_INDEX_CHECK)
00361 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00362 #else
00363 throw();
00364 #endif
00365 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
00366 #if(CXSC_INDEX_CHECK)
00367 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00368 #else
00369 throw();
00370 #endif
00371 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
00372 #if(CXSC_INDEX_CHECK)
00373 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00374 #else
00375 throw();
00376 #endif
00377 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
00378 #if(CXSC_INDEX_CHECK)
00379 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00380 #else
00381 throw();
00382 #endif
00383 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00384 #if(CXSC_INDEX_CHECK)
00385 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00386 #else
00387 throw();
00388 #endif
00389 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
00390 #if(CXSC_INDEX_CHECK)
00391 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00392 #else
00393 throw();
00394 #endif
00395 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
00396 #if(CXSC_INDEX_CHECK)
00397 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00398 #else
00399 throw();
00400 #endif
00401 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
00402 #if(CXSC_INDEX_CHECK)
00403 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00404 #else
00405 throw();
00406 #endif
00407 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
00408 #if(CXSC_INDEX_CHECK)
00409 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00410 #else
00411 throw();
00412 #endif
00413 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
00414 #if(CXSC_INDEX_CHECK)
00415 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00416 #else
00417 throw();
00418 #endif
00419 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
00420 #if(CXSC_INDEX_CHECK)
00421 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00422 #else
00423 throw();
00424 #endif
00425 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00426 #if(CXSC_INDEX_CHECK)
00427 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00428 #else
00429 throw();
00430 #endif
00431 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
00432 #if(CXSC_INDEX_CHECK)
00433 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00434 #else
00435 throw();
00436 #endif
00437 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
00438 #if(CXSC_INDEX_CHECK)
00439 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00440 #else
00441 throw();
00442 #endif
00443 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
00444 #if(CXSC_INDEX_CHECK)
00445 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00446 #else
00447 throw();
00448 #endif
00449 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00450 #if(CXSC_INDEX_CHECK)
00451 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00452 #else
00453 throw();
00454 #endif
00455 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
00456 #if(CXSC_INDEX_CHECK)
00457 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00458 #else
00459 throw();
00460 #endif
00461 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
00462 #if(CXSC_INDEX_CHECK)
00463 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00464 #else
00465 throw();
00466 #endif
00467 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
00468 #if(CXSC_INDEX_CHECK)
00469 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00470 #else
00471 throw();
00472 #endif
00473 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00474 #if(CXSC_INDEX_CHECK)
00475 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00476 #else
00477 throw();
00478 #endif
00479 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
00480 #if(CXSC_INDEX_CHECK)
00481 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00482 #else
00483 throw();
00484 #endif
00485 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
00486 #if(CXSC_INDEX_CHECK)
00487 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00488 #else
00489 throw();
00490 #endif
00491 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
00492 #if(CXSC_INDEX_CHECK)
00493 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00494 #else
00495 throw();
00496 #endif
00497 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
00498 #if(CXSC_INDEX_CHECK)
00499 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00500 #else
00501 throw();
00502 #endif
00503
00504 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
00505 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
00506 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
00507 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
00508 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
00509 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
00510 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00511 #if(CXSC_INDEX_CHECK)
00512 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00513 #else
00514 throw();
00515 #endif
00516 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
00517 #if(CXSC_INDEX_CHECK)
00518 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00519 #else
00520 throw();
00521 #endif
00522 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
00523 #if(CXSC_INDEX_CHECK)
00524 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00525 #else
00526 throw();
00527 #endif
00528 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
00529 #if(CXSC_INDEX_CHECK)
00530 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00531 #else
00532 throw();
00533 #endif
00534 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00535 #if(CXSC_INDEX_CHECK)
00536 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00537 #else
00538 throw();
00539 #endif
00540 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
00541 #if(CXSC_INDEX_CHECK)
00542 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00543 #else
00544 throw();
00545 #endif
00546 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
00547 #if(CXSC_INDEX_CHECK)
00548 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00549 #else
00550 throw();
00551 #endif
00552 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
00553 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
00554 #if(CXSC_INDEX_CHECK)
00555 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00556 #else
00557 throw();
00558 #endif
00559
00560 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00561 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
00562 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00563 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
00564 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00565 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
00566 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00567 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
00568 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
00569 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
00570 template <class V> friend bool _vnot(const V &rv) throw();
00571 template <class V> friend void *_vvoid(const V &rv) throw();
00572 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00573 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00574 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00575 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00576 template <class VS> friend bool _vsnot(const VS &sl) throw();
00577 template <class VS> friend void *_vsvoid(const VS &sl) throw();
00578 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
00579 template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
00580
00581
00582 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00583 #if(CXSC_INDEX_CHECK)
00584 throw(OP_WITH_WRONG_DIM);
00585 #else
00586 throw();
00587 #endif
00588
00589 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
00590 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
00591 #if(CXSC_INDEX_CHECK)
00592 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00593 #else
00594 throw();
00595 #endif
00596 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
00597 #if(CXSC_INDEX_CHECK)
00598 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00599 #else
00600 throw();
00601 #endif
00602 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
00603 #if(CXSC_INDEX_CHECK)
00604 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00605 #else
00606 throw();
00607 #endif
00608 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
00609 #if(CXSC_INDEX_CHECK)
00610 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00611 #else
00612 throw();
00613 #endif
00614 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
00615 #if(CXSC_INDEX_CHECK)
00616 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00617 #else
00618 throw();
00619 #endif
00620 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
00621 #if(CXSC_INDEX_CHECK)
00622 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00623 #else
00624 throw();
00625 #endif
00626 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
00627 #if(CXSC_INDEX_CHECK)
00628 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00629 #else
00630 throw();
00631 #endif
00632
00633
00634 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
00635 #if(CXSC_INDEX_CHECK)
00636 throw(OP_WITH_WRONG_DIM);
00637 #else
00638 throw();
00639 #endif
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673 #endif
00674
00675
00676
00678 INLINE civector () throw();
00680 explicit INLINE civector(const int &i) throw();
00681 #ifdef OLD_CXSC
00682
00683 explicit INLINE civector(const class index &i) throw();
00684 #endif
00685
00686 explicit INLINE civector(const int &i1,const int &i2)
00687 #if(CXSC_INDEX_CHECK)
00688 throw(ERROR_CIVECTOR_WRONG_BOUNDARIES,ERROR_CIVECTOR_NO_MORE_MEMORY);
00689 #else
00690 throw();
00691 #endif
00692
00693 INLINE civector(const cimatrix_subv &) throw();
00695 explicit INLINE civector(const cinterval &) throw();
00697
00698 explicit civector(const cimatrix &)
00699 #if(CXSC_INDEX_CHECK)
00700 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00701 #else
00702 throw();
00703 #endif
00704
00705 explicit INLINE civector(const cimatrix_slice &sl)
00706 #if(CXSC_INDEX_CHECK)
00707 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00708 #else
00709 throw();
00710 #endif
00711
00712 INLINE civector(const civector_slice &rs) throw();
00714 INLINE civector(const civector &v) throw();
00716 INLINE civector(const scivector_slice &rs);
00718 INLINE civector(const scivector &v);
00719
00721 explicit INLINE civector(const real &) throw();
00723 explicit INLINE civector(const rvector_slice &rs) throw();
00725 explicit INLINE civector(const rvector &v) throw();
00727 explicit INLINE civector(const srvector_slice &rs);
00729 explicit INLINE civector(const srvector &v);
00731 explicit INLINE civector(const rmatrix &)
00732 #if(CXSC_INDEX_CHECK)
00733 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00734 #else
00735 throw();
00736 #endif
00737
00738 explicit INLINE civector(const rmatrix_slice &sl)
00739 #if(CXSC_INDEX_CHECK)
00740 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00741 #else
00742 throw();
00743 #endif
00744
00745 explicit INLINE civector(const rmatrix_subv &) throw();
00746
00747
00749 explicit INLINE civector(const complex &) throw();
00751 explicit INLINE civector(const cvector_slice &rs) throw();
00753 explicit INLINE civector(const cvector &v) throw();
00755 explicit INLINE civector(const scvector_slice &rs);
00757 explicit INLINE civector(const scvector &v);
00759 explicit INLINE civector(const cmatrix &)
00760 #if(CXSC_INDEX_CHECK)
00761 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00762 #else
00763 throw();
00764 #endif
00765
00766 explicit INLINE civector(const cmatrix_slice &sl)
00767 #if(CXSC_INDEX_CHECK)
00768 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00769 #else
00770 throw();
00771 #endif
00772
00773 explicit INLINE civector(const cmatrix_subv &) throw();
00774
00775
00777 explicit INLINE civector(const interval &) throw();
00779 explicit INLINE civector(const ivector_slice &rs) throw();
00781 explicit INLINE civector(const ivector &v) throw();
00783 explicit INLINE civector(const sivector_slice &rs);
00785 explicit INLINE civector(const sivector &v);
00787 explicit INLINE civector(const imatrix &)
00788 #if(CXSC_INDEX_CHECK)
00789 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00790 #else
00791 throw();
00792 #endif
00793
00794 explicit INLINE civector(const imatrix_slice &sl)
00795 #if(CXSC_INDEX_CHECK)
00796 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00797 #else
00798 throw();
00799 #endif
00800
00801 explicit INLINE civector(const imatrix_subv &) throw();
00802
00803
00805 INLINE civector &operator =(const civector &rv) throw();
00807 INLINE civector &operator =(const civector_slice &sl) throw();
00809 INLINE civector &operator =(const scivector &rv) ;
00811 INLINE civector &operator =(const scivector_slice &sl) ;
00813 INLINE civector &operator =(const cinterval &r) throw();
00815 INLINE civector &operator =(const cimatrix &m)
00816 #if(CXSC_INDEX_CHECK)
00817 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00818 #else
00819 throw();
00820 #endif
00821
00822 INLINE civector &operator =(const cimatrix_slice &)
00823 #if(CXSC_INDEX_CHECK)
00824 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00825 #else
00826 throw();
00827 #endif
00828
00829 INLINE civector &operator =(const cimatrix_subv &) throw();
00830
00832 INLINE civector &operator =(const rvector &rv) throw();
00834 INLINE civector &operator =(const rvector_slice &sl) throw();
00836 INLINE civector &operator =(const srvector &rv);
00838 INLINE civector &operator =(const srvector_slice &sl);
00840 INLINE civector &operator =(const real &r) throw();
00842 INLINE civector &operator =(const rmatrix &m)
00843 #if(CXSC_INDEX_CHECK)
00844 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00845 #else
00846 throw();
00847 #endif
00848
00849 INLINE civector &operator =(const rmatrix_slice &)
00850 #if(CXSC_INDEX_CHECK)
00851 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00852 #else
00853 throw();
00854 #endif
00855
00856 INLINE civector &operator =(const rmatrix_subv &) throw();
00857
00858
00860 INLINE civector &operator =(const cvector &rv) throw();
00862 INLINE civector &operator =(const cvector_slice &sl) throw();
00864 INLINE civector &operator =(const scvector &rv);
00866 INLINE civector &operator =(const scvector_slice &sl);
00868 INLINE civector &operator =(const complex &r) throw();
00870 INLINE civector &operator =(const cmatrix &m)
00871 #if(CXSC_INDEX_CHECK)
00872 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00873 #else
00874 throw();
00875 #endif
00876
00877 INLINE civector &operator =(const cmatrix_slice &)
00878 #if(CXSC_INDEX_CHECK)
00879 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00880 #else
00881 throw();
00882 #endif
00883
00884 INLINE civector &operator =(const cmatrix_subv &) throw();
00885
00886
00888 INLINE civector &operator =(const ivector &rv) throw();
00890 INLINE civector &operator =(const ivector_slice &sl) throw();
00892 INLINE civector &operator =(const sivector &rv) ;
00894 INLINE civector &operator =(const sivector_slice &sl) ;
00896 INLINE civector &operator =(const interval &r) throw();
00898 INLINE civector &operator =(const imatrix &m)
00899 #if(CXSC_INDEX_CHECK)
00900 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00901 #else
00902 throw();
00903 #endif
00904
00905 INLINE civector &operator =(const imatrix_slice &)
00906 #if(CXSC_INDEX_CHECK)
00907 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00908 #else
00909 throw();
00910 #endif
00911
00912 INLINE civector &operator =(const imatrix_subv &) throw();
00913
00914
00915 civector& operator+=(const srvector&);
00916 civector& operator+=(const scvector&);
00917 civector& operator+=(const sivector&);
00918 civector& operator+=(const scivector&);
00919 civector& operator-=(const srvector&);
00920 civector& operator-=(const scvector&);
00921 civector& operator-=(const sivector&);
00922 civector& operator-=(const scivector&);
00923 civector& operator|=(const srvector&);
00924 civector& operator|=(const scvector&);
00925 civector& operator|=(const sivector&);
00926 civector& operator|=(const scivector&);
00927 civector& operator&=(const sivector&);
00928 civector& operator&=(const scivector&);
00929 civector& operator+=(const srvector_slice&);
00930 civector& operator+=(const scvector_slice&);
00931 civector& operator+=(const sivector_slice&);
00932 civector& operator+=(const scivector_slice&);
00933 civector& operator-=(const srvector_slice&);
00934 civector& operator-=(const scvector_slice&);
00935 civector& operator-=(const sivector_slice&);
00936 civector& operator-=(const scivector_slice&);
00937 civector& operator|=(const srvector_slice&);
00938 civector& operator|=(const scvector_slice&);
00939 civector& operator|=(const sivector_slice&);
00940 civector& operator|=(const scivector_slice&);
00941 civector& operator&=(const sivector_slice&);
00942 civector& operator&=(const scivector_slice&);
00943
00945 INLINE civector operator()(const intvector& p);
00947 INLINE civector operator()(const intmatrix& P);
00948
00949
00950 INLINE ~civector() { delete [] dat; }
00951
00952
00953
00954 friend INLINE cinterval::cinterval(const civector &)
00955 #if(CXSC_INDEX_CHECK)
00956 throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ);
00957 #else
00958 throw();
00959 #endif
00960
00961 friend INLINE int Lb(const civector &rv) throw() { return rv.l; }
00963 friend INLINE int Ub(const civector &rv) throw() { return rv.u; }
00965 friend INLINE int VecLen(const civector &rv) throw() { return rv.size; }
00967 friend INLINE civector & SetLb(civector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
00969 friend INLINE civector & SetUb(civector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
00971 INLINE cinterval & operator [](const int &i) const
00972 #if(CXSC_INDEX_CHECK)
00973 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
00974 #else
00975 throw();
00976 #endif
00977
00979 INLINE cinterval & operator [](const int &i)
00980 #if(CXSC_INDEX_CHECK)
00981 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
00982 #else
00983 throw();
00984 #endif
00985
00987 INLINE civector & operator ()() throw() { return *this; }
00989 INLINE civector_slice operator ()(const int &i)
00990 #if(CXSC_INDEX_CHECK)
00991 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
00992 #else
00993 throw();
00994 #endif
00995
00996 civector_slice operator ()(const int &i1,const int &i2)
00997 #if(CXSC_INDEX_CHECK)
00998 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
00999 #else
01000 throw();
01001 #endif
01002
01003 INLINE operator void*() throw();
01004
01005
01006 };
01007
01009
01014 class civector_slice
01015 {
01016 friend class civector;
01017 friend class cimatrix;
01018 private:
01019 cinterval *dat;
01020 int l,u,size;
01021 int start,end;
01022
01023 public:
01024
01025 #ifdef _CXSC_FRIEND_TPL
01026
01027
01028
01029 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
01030 #if(CXSC_INDEX_CHECK)
01031 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01032 #else
01033 throw();
01034 #endif
01035 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
01036 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
01037 #if(CXSC_INDEX_CHECK)
01038 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01039 #else
01040 throw();
01041 #endif
01042 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
01043 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
01044 #if(CXSC_INDEX_CHECK)
01045 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01046 #else
01047 throw();
01048 #endif
01049 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
01050 #if(CXSC_INDEX_CHECK)
01051 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01052 #else
01053 throw();
01054 #endif
01055 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
01056 #if(CXSC_INDEX_CHECK)
01057 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01058 #else
01059 throw();
01060 #endif
01061 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
01062 #if(CXSC_INDEX_CHECK)
01063 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01064 #else
01065 throw();
01066 #endif
01067 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
01068 #if(CXSC_INDEX_CHECK)
01069 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01070 #else
01071 throw();
01072 #endif
01073 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
01074 #if(CXSC_INDEX_CHECK)
01075 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01076 #else
01077 throw();
01078 #endif
01079 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
01080 #if(CXSC_INDEX_CHECK)
01081 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01082 #else
01083 throw();
01084 #endif
01085 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
01086 #if(CXSC_INDEX_CHECK)
01087 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01088 #else
01089 throw();
01090 #endif
01091
01092 template <class VS,class E> friend E _vsconj(const VS &sl) throw();
01093 template <class VS,class E> friend E _vsabs(const VS &sl) throw();
01094 template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
01095 template <class VS,class E> friend E _vsmid(const VS &sl) throw();
01096 template <class VS,class E> friend E _vsinf(const VS &sl) throw();
01097 template <class VS,class E> friend E _vssup(const VS &sl) throw();
01098 template <class VS,class E> friend E _vsim(const VS &sl) throw();
01099 template <class VS,class E> friend E _vsre(const VS &sl) throw();
01100 friend INLINE ivector Re(const civector_slice &v) throw();
01101 friend INLINE ivector Im(const civector_slice &v) throw();
01102 friend INLINE cvector Inf(const civector_slice &v) throw();
01103 friend INLINE cvector Sup(const civector_slice &v) throw();
01104 friend INLINE rvector SupRe(const civector_slice &v) throw();
01105 friend INLINE rvector SupIm(const civector_slice &v) throw();
01106 friend INLINE rvector InfRe(const civector_slice &v) throw();
01107 friend INLINE rvector InfIm(const civector_slice &v) throw();
01108 template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
01109 #if(CXSC_INDEX_CHECK)
01110 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01111 #else
01112 throw();
01113 #endif
01114 template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
01115 #if(CXSC_INDEX_CHECK)
01116 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01117 #else
01118 throw();
01119 #endif
01120 template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
01121 #if(CXSC_INDEX_CHECK)
01122 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01123 #else
01124 throw();
01125 #endif
01126 template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
01127 #if(CXSC_INDEX_CHECK)
01128 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01129 #else
01130 throw();
01131 #endif
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144 template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw();
01145 template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw();
01146 template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw();
01147 template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw();
01148 template <class VS,class S> friend VS &_vsssetim(VS &vs, const S &s) throw();
01149 template <class VS,class S> friend VS &_vsssetre(VS &vs, const S &s) throw();
01150
01151 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
01152 #if(CXSC_INDEX_CHECK)
01153 throw(OP_WITH_WRONG_DIM);
01154 #else
01155 throw();
01156 #endif
01157 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
01158 #if(CXSC_INDEX_CHECK)
01159 throw(OP_WITH_WRONG_DIM);
01160 #else
01161 throw();
01162 #endif
01163
01164 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
01165 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
01166
01167 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
01168 #if(CXSC_INDEX_CHECK)
01169 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01170 #else
01171 throw();
01172 #endif
01173 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
01174 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
01175 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
01176 #if(CXSC_INDEX_CHECK)
01177 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01178 #else
01179 throw();
01180 #endif
01181 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
01182 #if(CXSC_INDEX_CHECK)
01183 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01184 #else
01185 throw();
01186 #endif
01187 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
01188 #if(CXSC_INDEX_CHECK)
01189 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01190 #else
01191 throw();
01192 #endif
01193 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
01194 #if(CXSC_INDEX_CHECK)
01195 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01196 #else
01197 throw();
01198 #endif
01199 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
01200 #if(CXSC_INDEX_CHECK)
01201 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01202 #else
01203 throw();
01204 #endif
01205 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
01206 #if(CXSC_INDEX_CHECK)
01207 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01208 #else
01209 throw();
01210 #endif
01211 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
01212 #if(CXSC_INDEX_CHECK)
01213 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01214 #else
01215 throw();
01216 #endif
01217 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
01218 #if(CXSC_INDEX_CHECK)
01219 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01220 #else
01221 throw();
01222 #endif
01223 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
01224 #if(CXSC_INDEX_CHECK)
01225 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01226 #else
01227 throw();
01228 #endif
01229 template <class VS,class V> friend V _vsminus(const VS &sl) throw();
01230 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
01231 #if(CXSC_INDEX_CHECK)
01232 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01233 #else
01234 throw();
01235 #endif
01236 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
01237 #if(CXSC_INDEX_CHECK)
01238 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01239 #else
01240 throw();
01241 #endif
01242 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
01243 #if(CXSC_INDEX_CHECK)
01244 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01245 #else
01246 throw();
01247 #endif
01248 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
01249 #if(CXSC_INDEX_CHECK)
01250 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01251 #else
01252 throw();
01253 #endif
01254 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
01255 #if(CXSC_INDEX_CHECK)
01256 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01257 #else
01258 throw();
01259 #endif
01260 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
01261 #if(CXSC_INDEX_CHECK)
01262 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01263 #else
01264 throw();
01265 #endif
01266 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01267 #if(CXSC_INDEX_CHECK)
01268 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01269 #else
01270 throw();
01271 #endif
01272 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
01273 #if(CXSC_INDEX_CHECK)
01274 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01275 #else
01276 throw();
01277 #endif
01278 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
01279 #if(CXSC_INDEX_CHECK)
01280 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01281 #else
01282 throw();
01283 #endif
01284 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
01285 #if(CXSC_INDEX_CHECK)
01286 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01287 #else
01288 throw();
01289 #endif
01290 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
01291 #if(CXSC_INDEX_CHECK)
01292 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01293 #else
01294 throw();
01295 #endif
01296 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
01297 #if(CXSC_INDEX_CHECK)
01298 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01299 #else
01300 throw();
01301 #endif
01302 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
01303 #if(CXSC_INDEX_CHECK)
01304 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01305 #else
01306 throw();
01307 #endif
01308
01309 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
01310 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
01311 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
01312 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
01313 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
01314 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
01315 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
01316 #if(CXSC_INDEX_CHECK)
01317 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01318 #else
01319 throw();
01320 #endif
01321 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
01322 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
01323 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
01324 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
01325 template <class VS> friend bool _vsnot(const VS &sl) throw();
01326 template <class VS> friend void *_vsvoid(const VS &sl) throw();
01327 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
01328 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
01329
01330
01331 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
01332 #if(CXSC_INDEX_CHECK)
01333 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01334 #else
01335 throw();
01336 #endif
01337
01338 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
01339 #if(CXSC_INDEX_CHECK)
01340 throw(OP_WITH_WRONG_DIM);
01341 #else
01342 throw();
01343 #endif
01344
01345
01346
01347 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
01348 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
01349
01350 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
01351 #if(CXSC_INDEX_CHECK)
01352 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
01353 #else
01354 throw();
01355 #endif
01356 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
01357 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
01358
01359 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
01360 #if(CXSC_INDEX_CHECK)
01361 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01362 #else
01363 throw();
01364 #endif
01365
01366
01367 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
01368 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
01369 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
01370 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
01371 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
01372
01373 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
01374 #if(CXSC_INDEX_CHECK)
01375 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01376 #else
01377 throw();
01378 #endif
01379 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
01380 #if(CXSC_INDEX_CHECK)
01381 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01382 #else
01383 throw();
01384 #endif
01385 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
01386 #if(CXSC_INDEX_CHECK)
01387 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01388 #else
01389 throw();
01390 #endif
01391 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
01392 #if(CXSC_INDEX_CHECK)
01393 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01394 #else
01395 throw();
01396 #endif
01397 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
01398 #if(CXSC_INDEX_CHECK)
01399 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01400 #else
01401 throw();
01402 #endif
01403 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
01404 #if(CXSC_INDEX_CHECK)
01405 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01406 #else
01407 throw();
01408 #endif
01409 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
01410 #if(CXSC_INDEX_CHECK)
01411 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01412 #else
01413 throw();
01414 #endif
01415 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
01416 #if(CXSC_INDEX_CHECK)
01417 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01418 #else
01419 throw();
01420 #endif
01421
01422
01423 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
01424 #if(CXSC_INDEX_CHECK)
01425 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01426 #else
01427 throw();
01428 #endif
01429 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
01430 #if(CXSC_INDEX_CHECK)
01431 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
01432 #else
01433 throw();
01434 #endif
01435 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
01436 #if(CXSC_INDEX_CHECK)
01437 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01438 #else
01439 throw();
01440 #endif
01441 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
01442 #if(CXSC_INDEX_CHECK)
01443 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01444 #else
01445 throw();
01446 #endif
01447 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
01448 #if(CXSC_INDEX_CHECK)
01449 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01450 #else
01451 throw();
01452 #endif
01453 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
01454 #if(CXSC_INDEX_CHECK)
01455 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01456 #else
01457 throw();
01458 #endif
01459 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
01460 #if(CXSC_INDEX_CHECK)
01461 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01462 #else
01463 throw();
01464 #endif
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502
01503
01504
01505
01506
01507
01508
01509 #endif
01510
01511
01513 explicit INLINE civector_slice(civector &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) { }
01515 explicit INLINE civector_slice(civector_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) { }
01516 public:
01518 INLINE civector_slice(const civector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01519 public:
01520
01522 INLINE civector_slice & operator =(const scivector_slice &sl);
01524 INLINE civector_slice & operator =(const scivector &sl);
01525
01527 INLINE civector_slice & operator =(const civector_slice &sl)
01528 #if(CXSC_INDEX_CHECK)
01529 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01530 #else
01531 throw();
01532 #endif
01533
01534 INLINE civector_slice & operator =(const civector &rv)
01535 #if(CXSC_INDEX_CHECK)
01536 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01537 #else
01538 throw();
01539 #endif
01540
01541 INLINE civector_slice & operator =(const cinterval &r) throw();
01543 INLINE civector_slice & operator =(const cimatrix &m)
01544 #if(CXSC_INDEX_CHECK)
01545 throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01546 #else
01547 throw();
01548 #endif
01549
01550 INLINE civector_slice & operator =(const cimatrix_slice &m)
01551 #if(CXSC_INDEX_CHECK)
01552 throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01553 #else
01554 throw();
01555 #endif
01556
01557 INLINE civector_slice &operator =(const cimatrix_subv &) throw();
01558
01560 INLINE civector_slice & operator =(const srvector_slice &sl);
01562 INLINE civector_slice & operator =(const srvector &sl);
01563
01565 INLINE civector_slice & operator =(const rvector_slice &sl)
01566 #if(CXSC_INDEX_CHECK)
01567 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01568 #else
01569 throw();
01570 #endif
01571
01572 INLINE civector_slice & operator =(const rvector &rv)
01573 #if(CXSC_INDEX_CHECK)
01574 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01575 #else
01576 throw();
01577 #endif
01578
01579 INLINE civector_slice & operator =(const real &r) throw();
01581 INLINE civector_slice & operator =(const rmatrix &m)
01582 #if(CXSC_INDEX_CHECK)
01583 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01584 #else
01585 throw();
01586 #endif
01587
01588 INLINE civector_slice & operator =(const rmatrix_slice &m)
01589 #if(CXSC_INDEX_CHECK)
01590 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01591 #else
01592 throw();
01593 #endif
01594
01595 INLINE civector_slice &operator =(const rmatrix_subv &mv) throw();
01596
01597
01599 INLINE civector_slice & operator =(const scvector_slice &sl);
01601 INLINE civector_slice & operator =(const scvector &sl);
01602
01604 INLINE civector_slice & operator =(const cvector_slice &sl)
01605 #if(CXSC_INDEX_CHECK)
01606 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01607 #else
01608 throw();
01609 #endif
01610
01611 INLINE civector_slice & operator =(const cvector &rv)
01612 #if(CXSC_INDEX_CHECK)
01613 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01614 #else
01615 throw();
01616 #endif
01617
01618 INLINE civector_slice & operator =(const complex &r) throw();
01620 INLINE civector_slice & operator =(const cmatrix &m)
01621 #if(CXSC_INDEX_CHECK)
01622 throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01623 #else
01624 throw();
01625 #endif
01626
01627 INLINE civector_slice & operator =(const cmatrix_slice &m)
01628 #if(CXSC_INDEX_CHECK)
01629 throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01630 #else
01631 throw();
01632 #endif
01633
01634 INLINE civector_slice &operator =(const cmatrix_subv &mv) throw();
01635
01636
01638 INLINE civector_slice & operator =(const sivector_slice &sl);
01640 INLINE civector_slice & operator =(const sivector &sl);
01641
01643 INLINE civector_slice & operator =(const ivector_slice &sl)
01644 #if(CXSC_INDEX_CHECK)
01645 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01646 #else
01647 throw();
01648 #endif
01649
01650 INLINE civector_slice & operator =(const ivector &rv)
01651 #if(CXSC_INDEX_CHECK)
01652 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01653 #else
01654 throw();
01655 #endif
01656
01657 INLINE civector_slice & operator =(const interval &r) throw();
01659 INLINE civector_slice & operator =(const imatrix &m)
01660 #if(CXSC_INDEX_CHECK)
01661 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01662 #else
01663 throw();
01664 #endif
01665
01666 INLINE civector_slice & operator =(const imatrix_slice &m)
01667 #if(CXSC_INDEX_CHECK)
01668 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01669 #else
01670 throw();
01671 #endif
01672
01673 INLINE civector_slice &operator =(const imatrix_subv &mv) throw();
01674
01675
01676
01677 friend INLINE cinterval::cinterval(const civector_slice &sl)
01678 #if(CXSC_INDEX_CHECK)
01679 throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ);
01680 #else
01681 throw();
01682 #endif
01683
01684 friend INLINE int Lb(const civector_slice &sl) throw() { return sl.start; }
01686 friend INLINE int Ub(const civector_slice &sl) throw() { return sl.end; }
01688 friend INLINE int VecLen(const civector_slice &sl) throw() { return sl.size; }
01689
01691 INLINE cinterval & operator [](const int &i) const
01692 #if(CXSC_INDEX_CHECK)
01693 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
01694 #else
01695 throw();
01696 #endif
01697
01699 INLINE cinterval & operator [](const int &i)
01700 #if(CXSC_INDEX_CHECK)
01701 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
01702 #else
01703 throw();
01704 #endif
01705
01707 INLINE civector_slice & operator ()() throw() { return *this; }
01709 INLINE civector_slice operator ()(const int &i)
01710 #if(CXSC_INDEX_CHECK)
01711 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
01712 #else
01713 throw();
01714 #endif
01715
01716 civector_slice operator ()(const int &i1,const int &i2)
01717 #if(CXSC_INDEX_CHECK)
01718 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
01719 #else
01720 throw();
01721 #endif
01722 INLINE operator void*() throw();
01723
01725 INLINE civector_slice &operator *=(const cinterval &r) throw();
01727 INLINE civector_slice &operator /=(const cinterval &r) throw();
01729 INLINE civector_slice &operator *=(const cimatrix &m)
01730 #if(CXSC_INDEX_CHECK)
01731 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01732 #else
01733 throw();
01734 #endif
01735
01736 INLINE civector_slice &operator *=(const cimatrix_slice &m)
01737 #if(CXSC_INDEX_CHECK)
01738 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01739 #else
01740 throw();
01741 #endif
01742
01743 INLINE civector_slice &operator +=(const civector &rv)
01744 #if(CXSC_INDEX_CHECK)
01745 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01746 #else
01747 throw();
01748 #endif
01749
01750 INLINE civector_slice &operator +=(const civector_slice &sl2)
01751 #if(CXSC_INDEX_CHECK)
01752 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01753 #else
01754 throw();
01755 #endif
01756
01757 INLINE civector_slice &operator -=(const civector &rv)
01758 #if(CXSC_INDEX_CHECK)
01759 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01760 #else
01761 throw();
01762 #endif
01763
01764 INLINE civector_slice &operator -=(const civector_slice &sl2)
01765 #if(CXSC_INDEX_CHECK)
01766 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01767 #else
01768 throw();
01769 #endif
01770
01771 INLINE civector_slice &operator |=(const civector &rv)
01772 #if(CXSC_INDEX_CHECK)
01773 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01774 #else
01775 throw();
01776 #endif
01777
01778 INLINE civector_slice &operator |=(const civector_slice &sl2)
01779 #if(CXSC_INDEX_CHECK)
01780 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01781 #else
01782 throw();
01783 #endif
01784
01785 INLINE civector_slice &operator &=(const civector &rv)
01786 #if(CXSC_INDEX_CHECK)
01787 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01788 #else
01789 throw();
01790 #endif
01791
01792 INLINE civector_slice &operator &=(const civector_slice &sl2)
01793 #if(CXSC_INDEX_CHECK)
01794 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01795 #else
01796 throw();
01797 #endif
01798
01800 INLINE civector_slice &operator *=(const real &r) throw();
01802 INLINE civector_slice &operator /=(const real &r) throw();
01804 INLINE civector_slice &operator +=(const rvector &rv)
01805 #if(CXSC_INDEX_CHECK)
01806 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01807 #else
01808 throw();
01809 #endif
01810
01811 INLINE civector_slice &operator +=(const rvector_slice &sl2)
01812 #if(CXSC_INDEX_CHECK)
01813 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01814 #else
01815 throw();
01816 #endif
01817
01818 INLINE civector_slice &operator -=(const rvector &rv)
01819 #if(CXSC_INDEX_CHECK)
01820 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01821 #else
01822 throw();
01823 #endif
01824
01825 INLINE civector_slice &operator -=(const rvector_slice &sl2)
01826 #if(CXSC_INDEX_CHECK)
01827 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01828 #else
01829 throw();
01830 #endif
01831
01832 INLINE civector_slice &operator |=(const rvector &rv)
01833 #if(CXSC_INDEX_CHECK)
01834 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01835 #else
01836 throw();
01837 #endif
01838
01839 INLINE civector_slice &operator |=(const rvector_slice &sl2)
01840 #if(CXSC_INDEX_CHECK)
01841 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01842 #else
01843 throw();
01844 #endif
01845
01846 INLINE civector_slice &operator &=(const rvector &rv)
01847 #if(CXSC_INDEX_CHECK)
01848 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01849 #else
01850 throw();
01851 #endif
01852
01853 INLINE civector_slice &operator &=(const rvector_slice &sl2)
01854 #if(CXSC_INDEX_CHECK)
01855 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01856 #else
01857 throw();
01858 #endif
01859
01860 INLINE civector_slice &operator *=(const rmatrix &m)
01861 #if(CXSC_INDEX_CHECK)
01862 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01863 #else
01864 throw();
01865 #endif
01866
01867 INLINE civector_slice &operator *=(const rmatrix_slice &m)
01868 #if(CXSC_INDEX_CHECK)
01869 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01870 #else
01871 throw();
01872 #endif
01873
01875 INLINE civector_slice &operator *=(const complex &r) throw();
01877 INLINE civector_slice &operator /=(const complex &r) throw();
01879 INLINE civector_slice &operator +=(const cvector &rv)
01880 #if(CXSC_INDEX_CHECK)
01881 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01882 #else
01883 throw();
01884 #endif
01885
01886 INLINE civector_slice &operator +=(const cvector_slice &sl2)
01887 #if(CXSC_INDEX_CHECK)
01888 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01889 #else
01890 throw();
01891 #endif
01892
01893 INLINE civector_slice &operator -=(const cvector &rv)
01894 #if(CXSC_INDEX_CHECK)
01895 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01896 #else
01897 throw();
01898 #endif
01899
01900 INLINE civector_slice &operator -=(const cvector_slice &sl2)
01901 #if(CXSC_INDEX_CHECK)
01902 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01903 #else
01904 throw();
01905 #endif
01906
01907 INLINE civector_slice &operator |=(const cvector &rv)
01908 #if(CXSC_INDEX_CHECK)
01909 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01910 #else
01911 throw();
01912 #endif
01913
01914 INLINE civector_slice &operator |=(const cvector_slice &sl2)
01915 #if(CXSC_INDEX_CHECK)
01916 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01917 #else
01918 throw();
01919 #endif
01920
01921 INLINE civector_slice &operator &=(const cvector &rv)
01922 #if(CXSC_INDEX_CHECK)
01923 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01924 #else
01925 throw();
01926 #endif
01927
01928 INLINE civector_slice &operator &=(const cvector_slice &sl2)
01929 #if(CXSC_INDEX_CHECK)
01930 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01931 #else
01932 throw();
01933 #endif
01934
01935 INLINE civector_slice &operator *=(const cmatrix &m)
01936 #if(CXSC_INDEX_CHECK)
01937 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01938 #else
01939 throw();
01940 #endif
01941
01942 INLINE civector_slice &operator *=(const cmatrix_slice &m)
01943 #if(CXSC_INDEX_CHECK)
01944 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01945 #else
01946 throw();
01947 #endif
01948
01950 INLINE civector_slice &operator *=(const interval &r) throw();
01952 INLINE civector_slice &operator /=(const interval &r) throw();
01954 INLINE civector_slice &operator +=(const ivector &rv)
01955 #if(CXSC_INDEX_CHECK)
01956 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01957 #else
01958 throw();
01959 #endif
01960
01961 INLINE civector_slice &operator +=(const ivector_slice &sl2)
01962 #if(CXSC_INDEX_CHECK)
01963 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01964 #else
01965 throw();
01966 #endif
01967
01968 INLINE civector_slice &operator -=(const ivector &rv)
01969 #if(CXSC_INDEX_CHECK)
01970 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01971 #else
01972 throw();
01973 #endif
01974
01975 INLINE civector_slice &operator -=(const ivector_slice &sl2)
01976 #if(CXSC_INDEX_CHECK)
01977 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01978 #else
01979 throw();
01980 #endif
01981
01982 INLINE civector_slice &operator |=(const ivector &rv)
01983 #if(CXSC_INDEX_CHECK)
01984 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01985 #else
01986 throw();
01987 #endif
01988
01989 INLINE civector_slice &operator |=(const ivector_slice &sl2)
01990 #if(CXSC_INDEX_CHECK)
01991 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01992 #else
01993 throw();
01994 #endif
01995
01996 INLINE civector_slice &operator &=(const ivector &rv)
01997 #if(CXSC_INDEX_CHECK)
01998 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01999 #else
02000 throw();
02001 #endif
02002
02003 INLINE civector_slice &operator &=(const ivector_slice &sl2)
02004 #if(CXSC_INDEX_CHECK)
02005 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02006 #else
02007 throw();
02008 #endif
02009
02010 INLINE civector_slice &operator *=(const imatrix &m)
02011 #if(CXSC_INDEX_CHECK)
02012 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02013 #else
02014 throw();
02015 #endif
02016
02017 INLINE civector_slice &operator *=(const imatrix_slice &m)
02018 #if(CXSC_INDEX_CHECK)
02019 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02020 #else
02021 throw();
02022 #endif
02023
02024
02025
02026 civector_slice& operator+=(const srvector&);
02027 civector_slice& operator+=(const scvector&);
02028 civector_slice& operator+=(const sivector&);
02029 civector_slice& operator+=(const scivector&);
02030 civector_slice& operator-=(const srvector&);
02031 civector_slice& operator-=(const scvector&);
02032 civector_slice& operator-=(const sivector&);
02033 civector_slice& operator-=(const scivector&);
02034 civector_slice& operator|=(const srvector&);
02035 civector_slice& operator|=(const scvector&);
02036 civector_slice& operator|=(const sivector&);
02037 civector_slice& operator|=(const scivector&);
02038 civector_slice& operator&=(const sivector&);
02039 civector_slice& operator&=(const scivector&);
02040 civector_slice& operator+=(const srvector_slice&);
02041 civector_slice& operator+=(const scvector_slice&);
02042 civector_slice& operator+=(const sivector_slice&);
02043 civector_slice& operator+=(const scivector_slice&);
02044 civector_slice& operator-=(const srvector_slice&);
02045 civector_slice& operator-=(const scvector_slice&);
02046 civector_slice& operator-=(const sivector_slice&);
02047 civector_slice& operator-=(const scivector_slice&);
02048 civector_slice& operator|=(const srvector_slice&);
02049 civector_slice& operator|=(const scvector_slice&);
02050 civector_slice& operator|=(const sivector_slice&);
02051 civector_slice& operator|=(const scivector_slice&);
02052 civector_slice& operator&=(const sivector_slice&);
02053 civector_slice& operator&=(const scivector_slice&);
02054
02055 };
02056
02057
02058
02059
02061 INLINE civector _civector(const cinterval &r) throw();
02062
02063
02065 INLINE civector _civector(const real &r) throw();
02067 INLINE civector _civector(const rvector_slice &rs) throw();
02069 INLINE civector _civector(const rvector &rs) throw();
02070
02071
02073 INLINE civector _civector(const rmatrix_subv &rs) throw();
02074
02076 INLINE civector &SetInf(civector &iv,const cvector &rv)
02077 #if(CXSC_INDEX_CHECK)
02078 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02079 #else
02080 throw();
02081 #endif
02082
02083 INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv)
02084 #if(CXSC_INDEX_CHECK)
02085 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02086 #else
02087 throw();
02088 #endif
02089
02090 INLINE civector &SetInf(civector &iv,const cvector_slice &rv)
02091 #if(CXSC_INDEX_CHECK)
02092 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02093 #else
02094 throw();
02095 #endif
02096
02097 INLINE civector_slice &SetInf(civector_slice &iv,const cvector_slice &rv)
02098 #if(CXSC_INDEX_CHECK)
02099 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02100 #else
02101 throw();
02102 #endif
02103
02104 INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv)
02105 #if(CXSC_INDEX_CHECK)
02106 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02107 #else
02108 throw();
02109 #endif
02110
02111 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv)
02112 #if(CXSC_INDEX_CHECK)
02113 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02114 #else
02115 throw();
02116 #endif
02117
02118 INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv)
02119 #if(CXSC_INDEX_CHECK)
02120 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02121 #else
02122 throw();
02123 #endif
02124
02125 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector_slice &rv)
02126 #if(CXSC_INDEX_CHECK)
02127 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02128 #else
02129 throw();
02130 #endif
02131
02133 INLINE civector &SetSup(civector &iv,const cvector &rv)
02134 #if(CXSC_INDEX_CHECK)
02135 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02136 #else
02137 throw();
02138 #endif
02139
02140 INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv)
02141 #if(CXSC_INDEX_CHECK)
02142 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02143 #else
02144 throw();
02145 #endif
02146
02147 INLINE civector &SetSup(civector &iv,const cvector_slice &rv)
02148 #if(CXSC_INDEX_CHECK)
02149 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02150 #else
02151 throw();
02152 #endif
02153
02154 INLINE civector_slice &SetSup(civector_slice &iv,const cvector_slice &rv)
02155 #if(CXSC_INDEX_CHECK)
02156 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02157 #else
02158 throw();
02159 #endif
02160
02161 INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv)
02162 #if(CXSC_INDEX_CHECK)
02163 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02164 #else
02165 throw();
02166 #endif
02167
02168 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv)
02169 #if(CXSC_INDEX_CHECK)
02170 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02171 #else
02172 throw();
02173 #endif
02174
02175 INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv)
02176 #if(CXSC_INDEX_CHECK)
02177 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02178 #else
02179 throw();
02180 #endif
02181
02182 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector_slice &rv)
02183 #if(CXSC_INDEX_CHECK)
02184 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02185 #else
02186 throw();
02187 #endif
02188
02190 INLINE civector &SetRe(civector &iv,const ivector &rv)
02191 #if(CXSC_INDEX_CHECK)
02192 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02193 #else
02194 throw();
02195 #endif
02196
02197 INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv)
02198 #if(CXSC_INDEX_CHECK)
02199 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02200 #else
02201 throw();
02202 #endif
02203
02204 INLINE civector &SetRe(civector &iv,const ivector_slice &rv)
02205 #if(CXSC_INDEX_CHECK)
02206 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02207 #else
02208 throw();
02209 #endif
02210
02211 INLINE civector_slice &SetRe(civector_slice &iv,const ivector_slice &rv)
02212 #if(CXSC_INDEX_CHECK)
02213 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02214 #else
02215 throw();
02216 #endif
02217
02219 INLINE civector &SetIm(civector &iv,const ivector &rv)
02220 #if(CXSC_INDEX_CHECK)
02221 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02222 #else
02223 throw();
02224 #endif
02225
02226 INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv)
02227 #if(CXSC_INDEX_CHECK)
02228 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02229 #else
02230 throw();
02231 #endif
02232
02233 INLINE civector &SetIm(civector &iv,const ivector_slice &rv)
02234 #if(CXSC_INDEX_CHECK)
02235 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02236 #else
02237 throw();
02238 #endif
02239
02240 INLINE civector_slice &SetIm(civector_slice &iv,const ivector_slice &rv)
02241 #if(CXSC_INDEX_CHECK)
02242 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02243 #else
02244 throw();
02245 #endif
02246
02248 INLINE civector &SetSup(civector &iv,const complex &r) throw();
02250 INLINE civector &SetInf(civector &iv,const complex &r) throw();
02252 INLINE civector &UncheckedSetSup(civector &iv,const complex &r) throw();
02254 INLINE civector &SetUncheckedInf(civector &iv,const complex &r) throw();
02256 INLINE civector &SetRe(civector &iv,const interval &r) throw();
02258 INLINE civector &SetIm(civector &iv,const interval &r) throw();
02259
02261 INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) throw();
02263 INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) throw();
02265 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) throw();
02267 INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) throw();
02269 INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) throw();
02271 INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) throw();
02272
02274 INLINE void Resize(civector &rv) throw();
02276 INLINE void Resize(civector &rv, const int &len)
02277 #if(CXSC_INDEX_CHECK)
02278 throw(ERROR__WRONG_BOUNDARIES<civector>);
02279 #else
02280 throw();
02281 #endif
02282
02283 INLINE void Resize(civector &rv, const int &lb, const int &ub)
02284 #if(CXSC_INDEX_CHECK)
02285 throw(ERROR__WRONG_BOUNDARIES<civector>);
02286 #else
02287 throw();
02288 #endif
02289
02291 INLINE civector conj(const civector &rv) throw();
02293 INLINE civector conj(const civector_slice &sl) throw();
02294
02296 INLINE ivector abs(const civector &rv) throw();
02298 INLINE ivector abs(const civector_slice &sl) throw();
02300 INLINE cvector diam(const civector &v) throw();
02302 INLINE cvector diam(const civector_slice &v) throw();
02304 INLINE cvector mid(const civector &v) throw();
02306 INLINE cvector mid(const civector_slice &v) throw();
02308 INLINE cvector Inf(const civector &v) throw();
02310 INLINE cvector Inf(const civector_slice &v) throw();
02312 INLINE cvector Sup(const civector &v) throw();
02314 INLINE cvector Sup(const civector_slice &v) throw();
02316 INLINE rvector SupRe(const civector &v) throw();
02318 INLINE rvector SupIm(const civector &v) throw();
02320 INLINE rvector InfRe(const civector &v) throw();
02322 INLINE rvector InfIm(const civector &v) throw();
02324 INLINE rvector SupRe(const civector_slice &v) throw();
02326 INLINE rvector SupIm(const civector_slice &v) throw();
02328 INLINE rvector InfRe(const civector_slice &v) throw();
02330 INLINE rvector InfIm(const civector_slice &v) throw();
02332 INLINE bool operator !(const civector &rv) throw();
02334 INLINE bool operator !(const civector_slice &sl) throw();
02335
02336
02337
02338
02339
02341 INLINE civector operator *(const civector &rv, const cinterval &s) throw();
02343 INLINE civector operator *(const civector_slice &sl, const cinterval &s) throw();
02345 INLINE civector operator *(const cinterval &s, const civector &rv) throw();
02347 INLINE civector operator *(const cinterval &s, const civector_slice &sl) throw();
02349 INLINE civector &operator *=(civector &rv,const cinterval &r) throw();
02350
02352 INLINE civector operator /(const civector &rv, const cinterval &s) throw();
02354 INLINE civector operator /(const civector_slice &sl, const cinterval &s) throw();
02356 INLINE civector &operator /=(civector &rv,const cinterval &r) throw();
02357
02358
02359
02361 INLINE civector operator *(const civector &rv, const real &s) throw();
02363 INLINE civector operator *(const civector_slice &sl, const real &s) throw();
02365 INLINE civector operator *(const real &s, const civector &rv) throw();
02367 INLINE civector operator *(const real &s, const civector_slice &sl) throw();
02369 INLINE civector &operator *=(civector &rv,const real &r) throw();
02370
02372 INLINE civector operator /(const civector &rv, const real &s) throw();
02374 INLINE civector operator /(const civector_slice &sl, const real &s) throw();
02376 INLINE civector &operator /=(civector &rv,const real &r) throw();
02377
02379 INLINE civector operator *(const rvector &rv, const cinterval &s) throw();
02381 INLINE civector operator *(const rvector_slice &sl, const cinterval &s) throw();
02383 INLINE civector operator *(const cinterval &s, const rvector &rv) throw();
02385 INLINE civector operator *(const cinterval &s, const rvector_slice &sl) throw();
02386
02388 INLINE civector operator /(const rvector &rv, const cinterval &s) throw();
02390 INLINE civector operator /(const rvector_slice &sl, const cinterval &s) throw();
02391
02392
02393
02395 INLINE civector operator *(const civector &rv, const complex &s) throw();
02397 INLINE civector operator *(const civector_slice &sl, const complex &s) throw();
02399 INLINE civector operator *(const complex &s, const civector &rv) throw();
02401 INLINE civector operator *(const complex &s, const civector_slice &sl) throw();
02403 INLINE civector &operator *=(civector &rv,const complex &r) throw();
02404
02406 INLINE civector operator /(const civector &rv, const complex &s) throw();
02408 INLINE civector operator /(const civector_slice &sl, const complex &s) throw();
02410 INLINE civector &operator /=(civector &rv,const complex &r) throw();
02411
02413 INLINE civector operator *(const cvector &rv, const cinterval &s) throw();
02415 INLINE civector operator *(const cvector_slice &sl, const cinterval &s) throw();
02417 INLINE civector operator *(const cinterval &s, const cvector &rv) throw();
02419 INLINE civector operator *(const cinterval &s, const cvector_slice &sl) throw();
02420
02422 INLINE civector operator /(const cvector &rv, const cinterval &s) throw();
02424 INLINE civector operator /(const cvector_slice &sl, const cinterval &s) throw();
02425
02426
02427
02429 INLINE civector operator *(const civector &rv, const interval &s) throw();
02431 INLINE civector operator *(const civector_slice &sl, const interval &s) throw();
02433 INLINE civector operator *(const interval &s, const civector &rv) throw();
02435 INLINE civector operator *(const interval &s, const civector_slice &sl) throw();
02437 INLINE civector &operator *=(civector &rv,const interval &r) throw();
02438
02440 INLINE civector operator /(const civector &rv, const interval &s) throw();
02442 INLINE civector operator /(const civector_slice &sl, const interval &s) throw();
02444 INLINE civector &operator /=(civector &rv,const interval &r) throw();
02445
02447 INLINE civector operator *(const ivector &rv, const cinterval &s) throw();
02449 INLINE civector operator *(const ivector_slice &sl, const cinterval &s) throw();
02451 INLINE civector operator *(const cinterval &s, const ivector &rv) throw();
02453 INLINE civector operator *(const cinterval &s, const ivector_slice &sl) throw();
02454
02456 INLINE civector operator /(const ivector &rv, const cinterval &s) throw();
02458 INLINE civector operator /(const ivector_slice &sl, const cinterval &s) throw();
02459
02460
02461
02462
02464 INLINE std::ostream &operator <<(std::ostream &s, const civector &rv) throw();
02466 INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) throw();
02468 INLINE std::istream &operator >>(std::istream &s, civector &rv) throw();
02470 INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) throw();
02471
02472
02473
02475 void accumulate(cidotprecision &dp, const cvector &);
02476
02478 void accumulate(cidotprecision &dp, const rvector &);
02479
02481 void accumulate(cidotprecision &dp, const civector &);
02482
02484 void accumulate(cidotprecision &dp, const ivector &);
02485
02486
02488 void accumulate(cidotprecision &dp, const civector & rv1, const civector &rv2)
02489 #if(CXSC_INDEX_CHECK)
02490 throw(OP_WITH_WRONG_DIM);
02491 #else
02492 throw();
02493 #endif
02494
02495 void accumulate(cidotprecision &dp, const civector_slice & sl, const civector &rv)
02496 #if(CXSC_INDEX_CHECK)
02497 throw(OP_WITH_WRONG_DIM);
02498 #else
02499 throw();
02500 #endif
02501
02502 void accumulate(cidotprecision &dp, const civector &rv, const civector_slice &sl)
02503 #if(CXSC_INDEX_CHECK)
02504 throw(OP_WITH_WRONG_DIM);
02505 #else
02506 throw();
02507 #endif
02508
02509 void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
02510 #if(CXSC_INDEX_CHECK)
02511 throw(OP_WITH_WRONG_DIM);
02512 #else
02513 throw();
02514 #endif
02515
02516 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
02517 #if(CXSC_INDEX_CHECK)
02518 throw(OP_WITH_WRONG_DIM);
02519 #else
02520 throw();
02521 #endif
02522
02523 void accumulate(cidotprecision &dp, const civector_slice & sl1, const civector_slice &sl2)
02524 #if(CXSC_INDEX_CHECK)
02525 throw(OP_WITH_WRONG_DIM);
02526 #else
02527 throw();
02528 #endif
02529
02530 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
02531 #if(CXSC_INDEX_CHECK)
02532 throw(OP_WITH_WRONG_DIM);
02533 #else
02534 throw();
02535 #endif
02536
02537 void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
02538 #if(CXSC_INDEX_CHECK)
02539 throw(OP_WITH_WRONG_DIM);
02540 #else
02541 throw();
02542 #endif
02543
02544 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &rv2)
02545 #if(CXSC_INDEX_CHECK)
02546 throw(OP_WITH_WRONG_DIM);
02547 #else
02548 throw();
02549 #endif
02550
02551 void accumulate(cidotprecision &dp, const cvector_slice & rv1, const imatrix_subv &rv2)
02552 #if(CXSC_INDEX_CHECK)
02553 throw(OP_WITH_WRONG_DIM);
02554 #else
02555 throw();
02556 #endif
02557
02559 INLINE cinterval operator *(const civector & rv1, const civector &rv2)
02560 #if(CXSC_INDEX_CHECK)
02561 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02562 #else
02563 throw();
02564 #endif
02565
02566 INLINE cinterval operator *(const civector_slice &sl, const civector &rv)
02567 #if(CXSC_INDEX_CHECK)
02568 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02569 #else
02570 throw();
02571 #endif
02572
02573 INLINE cinterval operator *(const civector &rv, const civector_slice &sl)
02574 #if(CXSC_INDEX_CHECK)
02575 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02576 #else
02577 throw();
02578 #endif
02579
02580 INLINE cinterval operator *(const civector_slice & sl1, const civector_slice &sl2)
02581 #if(CXSC_INDEX_CHECK)
02582 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02583 #else
02584 throw();
02585 #endif
02586
02588 INLINE const civector &operator +(const civector &rv) throw();
02590 INLINE civector operator +(const civector_slice &sl) throw();
02591
02593 INLINE civector operator +(const civector &rv1, const civector &rv2)
02594 #if(CXSC_INDEX_CHECK)
02595 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02596 #else
02597 throw();
02598 #endif
02599
02600 INLINE civector operator +(const civector &rv, const civector_slice &sl)
02601 #if(CXSC_INDEX_CHECK)
02602 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02603 #else
02604 throw();
02605 #endif
02606
02607 INLINE civector operator +(const civector_slice &sl, const civector &rv)
02608 #if(CXSC_INDEX_CHECK)
02609 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02610 #else
02611 throw();
02612 #endif
02613
02614 INLINE civector operator +(const civector_slice &sl1, const civector_slice &sl2)
02615 #if(CXSC_INDEX_CHECK)
02616 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02617 #else
02618 throw();
02619 #endif
02620
02621 INLINE civector & operator +=(civector &rv1, const civector &rv2)
02622 #if(CXSC_INDEX_CHECK)
02623 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02624 #else
02625 throw();
02626 #endif
02627
02628 INLINE civector &operator +=(civector &rv, const civector_slice &sl)
02629 #if(CXSC_INDEX_CHECK)
02630 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02631 #else
02632 throw();
02633 #endif
02634
02636 INLINE civector operator -(const civector &rv) throw();
02638 INLINE civector operator -(const civector_slice &sl) throw();
02640 INLINE civector operator -(const civector &rv1, const civector &rv2)
02641 #if(CXSC_INDEX_CHECK)
02642 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02643 #else
02644 throw();
02645 #endif
02646
02647 INLINE civector operator -(const civector &rv, const civector_slice &sl)
02648 #if(CXSC_INDEX_CHECK)
02649 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02650 #else
02651 throw();
02652 #endif
02653
02654 INLINE civector operator -(const civector_slice &sl, const civector &rv)
02655 #if(CXSC_INDEX_CHECK)
02656 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02657 #else
02658 throw();
02659 #endif
02660
02661 INLINE civector operator -(const civector_slice &sl1, const civector_slice &sl2)
02662 #if(CXSC_INDEX_CHECK)
02663 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02664 #else
02665 throw();
02666 #endif
02667
02668 INLINE civector & operator -=(civector &rv1, const civector &rv2)
02669 #if(CXSC_INDEX_CHECK)
02670 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02671 #else
02672 throw();
02673 #endif
02674
02675 INLINE civector &operator -=(civector &rv, const civector_slice &sl)
02676 #if(CXSC_INDEX_CHECK)
02677 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02678 #else
02679 throw();
02680 #endif
02681
02683 INLINE civector operator |(const civector &rv1, const civector &rv2)
02684 #if(CXSC_INDEX_CHECK)
02685 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02686 #else
02687 throw();
02688 #endif
02689
02690 INLINE civector operator |(const civector &rv, const civector_slice &sl)
02691 #if(CXSC_INDEX_CHECK)
02692 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02693 #else
02694 throw();
02695 #endif
02696
02697 INLINE civector operator |(const civector_slice &sl, const civector &rv)
02698 #if(CXSC_INDEX_CHECK)
02699 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02700 #else
02701 throw();
02702 #endif
02703
02704 INLINE civector operator |(const civector_slice &sl1, const civector_slice &sl2)
02705 #if(CXSC_INDEX_CHECK)
02706 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02707 #else
02708 throw();
02709 #endif
02710
02711 INLINE civector & operator |=(civector &rv1, const civector &rv2)
02712 #if(CXSC_INDEX_CHECK)
02713 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02714 #else
02715 throw();
02716 #endif
02717
02718 INLINE civector &operator |=(civector &rv, const civector_slice &sl)
02719 #if(CXSC_INDEX_CHECK)
02720 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02721 #else
02722 throw();
02723 #endif
02724
02726 INLINE civector operator &(const civector &rv1, const civector &rv2)
02727 #if(CXSC_INDEX_CHECK)
02728 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02729 #else
02730 throw();
02731 #endif
02732
02733 INLINE civector operator &(const civector &rv, const civector_slice &sl)
02734 #if(CXSC_INDEX_CHECK)
02735 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02736 #else
02737 throw();
02738 #endif
02739
02740 INLINE civector operator &(const civector_slice &sl, const civector &rv)
02741 #if(CXSC_INDEX_CHECK)
02742 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02743 #else
02744 throw();
02745 #endif
02746
02747 INLINE civector operator &(const civector_slice &sl1, const civector_slice &sl2)
02748 #if(CXSC_INDEX_CHECK)
02749 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02750 #else
02751 throw();
02752 #endif
02753
02754 INLINE civector & operator &=(civector &rv1, const civector &rv2)
02755 #if(CXSC_INDEX_CHECK)
02756 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02757 #else
02758 throw();
02759 #endif
02760
02761 INLINE civector &operator &=(civector &rv, const civector_slice &sl)
02762 #if(CXSC_INDEX_CHECK)
02763 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02764 #else
02765 throw();
02766 #endif
02767
02769 INLINE bool operator ==(const civector &rv1, const civector &rv2) throw();
02771 INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) throw();
02773 INLINE bool operator ==(const civector_slice &sl, const civector &rv) throw();
02775 INLINE bool operator ==(const civector &rv, const civector_slice &sl) throw();
02777 INLINE bool operator !=(const civector &rv1, const civector &rv2) throw();
02779 INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) throw();
02781 INLINE bool operator !=(const civector_slice &sl, const civector &rv) throw();
02783 INLINE bool operator !=(const civector &rv, const civector_slice &sl) throw();
02785 INLINE bool operator <(const civector &rv1, const civector &rv2) throw();
02787 INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) throw();
02789 INLINE bool operator < (const civector_slice &sl, const civector &rv) throw();
02791 INLINE bool operator < (const civector &rv, const civector_slice &sl) throw();
02793 INLINE bool operator <=(const civector &rv1, const civector &rv2) throw();
02795 INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) throw();
02797 INLINE bool operator <=(const civector_slice &sl, const civector &rv) throw();
02799 INLINE bool operator <=(const civector &rv, const civector_slice &sl) throw();
02801 INLINE bool operator >(const civector &rv1, const civector &rv2) throw();
02803 INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) throw();
02805 INLINE bool operator >(const civector_slice &sl, const civector &rv) throw();
02807 INLINE bool operator >(const civector &rv, const civector_slice &sl) throw();
02809 INLINE bool operator >=(const civector &rv1, const civector &rv2) throw();
02811 INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) throw();
02813 INLINE bool operator >=(const civector_slice &sl, const civector &rv) throw();
02815 INLINE bool operator >=(const civector &rv, const civector_slice &sl) throw();
02816
02817
02818
02820 void accumulate(cidotprecision &dp, const rvector & rv1, const civector &rv2)
02821 #if(CXSC_INDEX_CHECK)
02822 throw(OP_WITH_WRONG_DIM);
02823 #else
02824 throw();
02825 #endif
02826
02827 void accumulate(cidotprecision &dp, const civector & rv1, const rvector &rv2)
02828 #if(CXSC_INDEX_CHECK)
02829 throw(OP_WITH_WRONG_DIM);
02830 #else
02831 throw();
02832 #endif
02833
02834 void accumulate(cidotprecision &dp, const rvector_slice & sl, const civector &rv)
02835 #if(CXSC_INDEX_CHECK)
02836 throw(OP_WITH_WRONG_DIM);
02837 #else
02838 throw();
02839 #endif
02840
02841 void accumulate(cidotprecision &dp,const civector_slice &sl,const rvector &rv)
02842 #if(CXSC_INDEX_CHECK)
02843 throw(OP_WITH_WRONG_DIM);
02844 #else
02845 throw();
02846 #endif
02847
02848 void accumulate(cidotprecision &dp, const rvector &rv, const civector_slice &sl)
02849 #if(CXSC_INDEX_CHECK)
02850 throw(OP_WITH_WRONG_DIM);
02851 #else
02852 throw();
02853 #endif
02854
02855 void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
02856 #if(CXSC_INDEX_CHECK)
02857 throw(OP_WITH_WRONG_DIM);
02858 #else
02859 throw();
02860 #endif
02861
02862 void accumulate(cidotprecision &dp, const civector & rv1, const rmatrix_subv &rv2)
02863 #if(CXSC_INDEX_CHECK)
02864 throw(OP_WITH_WRONG_DIM);
02865 #else
02866 throw();
02867 #endif
02868
02869 void accumulate(cidotprecision &dp,const civector &rv,const rvector_slice &sl)
02870 #if(CXSC_INDEX_CHECK)
02871 throw(OP_WITH_WRONG_DIM);
02872 #else
02873 throw();
02874 #endif
02875
02876 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const civector &rv2)
02877 #if(CXSC_INDEX_CHECK)
02878 throw(OP_WITH_WRONG_DIM);
02879 #else
02880 throw();
02881 #endif
02882
02883 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
02884 #if(CXSC_INDEX_CHECK)
02885 throw(OP_WITH_WRONG_DIM);
02886 #else
02887 throw();
02888 #endif
02889
02890 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rvector_slice &sl2)
02891 #if(CXSC_INDEX_CHECK)
02892 throw(OP_WITH_WRONG_DIM);
02893 #else
02894 throw();
02895 #endif
02896
02897 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const civector_slice &sl2)
02898 #if(CXSC_INDEX_CHECK)
02899 throw(OP_WITH_WRONG_DIM);
02900 #else
02901 throw();
02902 #endif
02903
02905 INLINE cinterval operator *(const rvector & rv1, const civector &rv2)
02906 #if(CXSC_INDEX_CHECK)
02907 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02908 #else
02909 throw();
02910 #endif
02911
02912 INLINE cinterval operator *(const rvector_slice &sl, const civector &rv)
02913 #if(CXSC_INDEX_CHECK)
02914 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02915 #else
02916 throw();
02917 #endif
02918
02919 INLINE cinterval operator *(const rvector &rv, const civector_slice &sl)
02920 #if(CXSC_INDEX_CHECK)
02921 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02922 #else
02923 throw();
02924 #endif
02925
02926 INLINE cinterval operator *(const rvector_slice & sl1, const civector_slice &sl2)
02927 #if(CXSC_INDEX_CHECK)
02928 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02929 #else
02930 throw();
02931 #endif
02932
02934 INLINE cinterval operator *(const civector & rv1, const rvector &rv2)
02935 #if(CXSC_INDEX_CHECK)
02936 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02937 #else
02938 throw();
02939 #endif
02940
02941 INLINE cinterval operator *(const civector_slice &sl, const rvector &rv)
02942 #if(CXSC_INDEX_CHECK)
02943 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02944 #else
02945 throw();
02946 #endif
02947
02948 INLINE cinterval operator *(const civector &rv, const rvector_slice &sl)
02949 #if(CXSC_INDEX_CHECK)
02950 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02951 #else
02952 throw();
02953 #endif
02954
02955 INLINE cinterval operator *(const civector_slice & sl1, const rvector_slice &sl2)
02956 #if(CXSC_INDEX_CHECK)
02957 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02958 #else
02959 throw();
02960 #endif
02961
02963 INLINE civector operator +(const rvector &rv1, const civector &rv2)
02964 #if(CXSC_INDEX_CHECK)
02965 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02966 #else
02967 throw();
02968 #endif
02969
02970 INLINE civector operator +(const rvector &rv, const civector_slice &sl)
02971 #if(CXSC_INDEX_CHECK)
02972 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02973 #else
02974 throw();
02975 #endif
02976
02977 INLINE civector operator +(const rvector_slice &sl, const civector &rv)
02978 #if(CXSC_INDEX_CHECK)
02979 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02980 #else
02981 throw();
02982 #endif
02983
02984 INLINE civector operator +(const rvector_slice &sl1, const civector_slice &sl2)
02985 #if(CXSC_INDEX_CHECK)
02986 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02987 #else
02988 throw();
02989 #endif
02990
02992 INLINE civector operator +(const civector &rv1, const rvector &rv2)
02993 #if(CXSC_INDEX_CHECK)
02994 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02995 #else
02996 throw();
02997 #endif
02998
02999 INLINE civector operator +(const civector &rv, const rvector_slice &sl)
03000 #if(CXSC_INDEX_CHECK)
03001 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03002 #else
03003 throw();
03004 #endif
03005
03006 INLINE civector operator +(const civector_slice &sl, const rvector &rv)
03007 #if(CXSC_INDEX_CHECK)
03008 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03009 #else
03010 throw();
03011 #endif
03012
03013 INLINE civector operator +(const civector_slice &sl1, const rvector_slice &sl2)
03014 #if(CXSC_INDEX_CHECK)
03015 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03016 #else
03017 throw();
03018 #endif
03019
03021 INLINE civector & operator +=(civector &rv1, const rvector &rv2)
03022 #if(CXSC_INDEX_CHECK)
03023 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03024 #else
03025 throw();
03026 #endif
03027
03028 INLINE civector &operator +=(civector &rv, const rvector_slice &sl)
03029 #if(CXSC_INDEX_CHECK)
03030 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03031 #else
03032 throw();
03033 #endif
03034
03036 INLINE civector operator -(const rvector &rv1, const civector &rv2)
03037 #if(CXSC_INDEX_CHECK)
03038 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03039 #else
03040 throw();
03041 #endif
03042
03043 INLINE civector operator -(const rvector &rv, const civector_slice &sl)
03044 #if(CXSC_INDEX_CHECK)
03045 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03046 #else
03047 throw();
03048 #endif
03049
03050 INLINE civector operator -(const rvector_slice &sl, const civector &rv)
03051 #if(CXSC_INDEX_CHECK)
03052 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03053 #else
03054 throw();
03055 #endif
03056
03057 INLINE civector operator -(const rvector_slice &sl1, const civector_slice &sl2)
03058 #if(CXSC_INDEX_CHECK)
03059 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03060 #else
03061 throw();
03062 #endif
03063
03065 INLINE civector operator -(const civector &rv1, const rvector &rv2)
03066 #if(CXSC_INDEX_CHECK)
03067 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03068 #else
03069 throw();
03070 #endif
03071
03072 INLINE civector operator -(const civector &rv, const rvector_slice &sl)
03073 #if(CXSC_INDEX_CHECK)
03074 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03075 #else
03076 throw();
03077 #endif
03078
03079 INLINE civector operator -(const civector_slice &sl, const rvector &rv)
03080 #if(CXSC_INDEX_CHECK)
03081 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03082 #else
03083 throw();
03084 #endif
03085
03086 INLINE civector operator -(const civector_slice &sl1, const rvector_slice &sl2)
03087 #if(CXSC_INDEX_CHECK)
03088 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03089 #else
03090 throw();
03091 #endif
03092
03094 INLINE civector & operator -=(civector &rv1, const rvector &rv2)
03095 #if(CXSC_INDEX_CHECK)
03096 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03097 #else
03098 throw();
03099 #endif
03100
03101 INLINE civector &operator -=(civector &rv, const rvector_slice &sl)
03102 #if(CXSC_INDEX_CHECK)
03103 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03104 #else
03105 throw();
03106 #endif
03107
03109 INLINE civector operator |(const rvector &rv1, const civector &rv2)
03110 #if(CXSC_INDEX_CHECK)
03111 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03112 #else
03113 throw();
03114 #endif
03115
03116 INLINE civector operator |(const rvector &rv, const civector_slice &sl)
03117 #if(CXSC_INDEX_CHECK)
03118 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03119 #else
03120 throw();
03121 #endif
03122
03123 INLINE civector operator |(const rvector_slice &sl, const civector &rv)
03124 #if(CXSC_INDEX_CHECK)
03125 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03126 #else
03127 throw();
03128 #endif
03129
03130 INLINE civector operator |(const rvector_slice &sl1, const civector_slice &sl2)
03131 #if(CXSC_INDEX_CHECK)
03132 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03133 #else
03134 throw();
03135 #endif
03136
03138 INLINE civector operator |(const civector &rv1, const rvector &rv2)
03139 #if(CXSC_INDEX_CHECK)
03140 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03141 #else
03142 throw();
03143 #endif
03144
03145 INLINE civector operator |(const civector &rv, const rvector_slice &sl)
03146 #if(CXSC_INDEX_CHECK)
03147 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03148 #else
03149 throw();
03150 #endif
03151
03152 INLINE civector operator |(const civector_slice &sl, const rvector &rv)
03153 #if(CXSC_INDEX_CHECK)
03154 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03155 #else
03156 throw();
03157 #endif
03158
03159 INLINE civector operator |(const civector_slice &sl1, const rvector_slice &sl2)
03160 #if(CXSC_INDEX_CHECK)
03161 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03162 #else
03163 throw();
03164 #endif
03165
03167 INLINE civector & operator |=(civector &rv1, const rvector &rv2)
03168 #if(CXSC_INDEX_CHECK)
03169 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03170 #else
03171 throw();
03172 #endif
03173
03174 INLINE civector &operator |=(civector &rv, const rvector_slice &sl)
03175 #if(CXSC_INDEX_CHECK)
03176 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03177 #else
03178 throw();
03179 #endif
03180
03182 INLINE civector operator &(const rvector &rv1, const civector &rv2)
03183 #if(CXSC_INDEX_CHECK)
03184 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03185 #else
03186 throw();
03187 #endif
03188
03189 INLINE civector operator &(const rvector &rv, const civector_slice &sl)
03190 #if(CXSC_INDEX_CHECK)
03191 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03192 #else
03193 throw();
03194 #endif
03195
03196 INLINE civector operator &(const rvector_slice &sl, const civector &rv)
03197 #if(CXSC_INDEX_CHECK)
03198 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03199 #else
03200 throw();
03201 #endif
03202
03203 INLINE civector operator &(const rvector_slice &sl1, const civector_slice &sl2)
03204 #if(CXSC_INDEX_CHECK)
03205 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03206 #else
03207 throw();
03208 #endif
03209
03211 INLINE civector operator &(const civector &rv1, const rvector &rv2)
03212 #if(CXSC_INDEX_CHECK)
03213 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03214 #else
03215 throw();
03216 #endif
03217
03218 INLINE civector operator &(const civector &rv, const rvector_slice &sl)
03219 #if(CXSC_INDEX_CHECK)
03220 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03221 #else
03222 throw();
03223 #endif
03224
03225 INLINE civector operator &(const civector_slice &sl, const rvector &rv)
03226 #if(CXSC_INDEX_CHECK)
03227 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03228 #else
03229 throw();
03230 #endif
03231
03232 INLINE civector operator &(const civector_slice &sl1, const rvector_slice &sl2)
03233 #if(CXSC_INDEX_CHECK)
03234 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03235 #else
03236 throw();
03237 #endif
03238
03240 INLINE civector & operator &=(civector &rv1, const rvector &rv2)
03241 #if(CXSC_INDEX_CHECK)
03242 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03243 #else
03244 throw();
03245 #endif
03246
03247 INLINE civector &operator &=(civector &rv, const rvector_slice &sl)
03248 #if(CXSC_INDEX_CHECK)
03249 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03250 #else
03251 throw();
03252 #endif
03253
03254
03256 void accumulate(cidotprecision &dp, const cvector & rv1, const civector &rv2)
03257 #if(CXSC_INDEX_CHECK)
03258 throw(OP_WITH_WRONG_DIM);
03259 #else
03260 throw();
03261 #endif
03262
03263 void accumulate(cidotprecision &dp, const civector & rv1, const cvector &rv2)
03264 #if(CXSC_INDEX_CHECK)
03265 throw(OP_WITH_WRONG_DIM);
03266 #else
03267 throw();
03268 #endif
03269
03270 void accumulate(cidotprecision &dp, const cvector_slice & sl, const civector &rv)
03271 #if(CXSC_INDEX_CHECK)
03272 throw(OP_WITH_WRONG_DIM);
03273 #else
03274 throw();
03275 #endif
03276
03277 void accumulate(cidotprecision &dp,const civector_slice &sl,const cvector &rv)
03278 #if(CXSC_INDEX_CHECK)
03279 throw(OP_WITH_WRONG_DIM);
03280 #else
03281 throw();
03282 #endif
03283
03284 void accumulate(cidotprecision &dp, const cvector &rv, const civector_slice &sl)
03285 #if(CXSC_INDEX_CHECK)
03286 throw(OP_WITH_WRONG_DIM);
03287 #else
03288 throw();
03289 #endif
03290
03291 void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
03292 #if(CXSC_INDEX_CHECK)
03293 throw(OP_WITH_WRONG_DIM);
03294 #else
03295 throw();
03296 #endif
03297
03298 void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
03299 #if(CXSC_INDEX_CHECK)
03300 throw(OP_WITH_WRONG_DIM);
03301 #else
03302 throw();
03303 #endif
03304
03305 void accumulate(cidotprecision &dp,const civector &rv,const cvector_slice &sl)
03306 #if(CXSC_INDEX_CHECK)
03307 throw(OP_WITH_WRONG_DIM);
03308 #else
03309 throw();
03310 #endif
03311
03312 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
03313 #if(CXSC_INDEX_CHECK)
03314 throw(OP_WITH_WRONG_DIM);
03315 #else
03316 throw();
03317 #endif
03318
03319 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
03320 #if(CXSC_INDEX_CHECK)
03321 throw(OP_WITH_WRONG_DIM);
03322 #else
03323 throw();
03324 #endif
03325
03326 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cvector_slice &sl2)
03327 #if(CXSC_INDEX_CHECK)
03328 throw(OP_WITH_WRONG_DIM);
03329 #else
03330 throw();
03331 #endif
03332
03333 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const civector_slice &sl2)
03334 #if(CXSC_INDEX_CHECK)
03335 throw(OP_WITH_WRONG_DIM);
03336 #else
03337 throw();
03338 #endif
03339
03340
03341
03342
03344 INLINE cinterval operator *(const cvector & rv1, const civector &rv2)
03345 #if(CXSC_INDEX_CHECK)
03346 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03347 #else
03348 throw();
03349 #endif
03350
03351 INLINE cinterval operator *(const cvector_slice &sl, const civector &rv)
03352 #if(CXSC_INDEX_CHECK)
03353 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03354 #else
03355 throw();
03356 #endif
03357
03358 INLINE cinterval operator *(const cvector &rv, const civector_slice &sl)
03359 #if(CXSC_INDEX_CHECK)
03360 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03361 #else
03362 throw();
03363 #endif
03364
03365 INLINE cinterval operator *(const cvector_slice & sl1, const civector_slice &sl2)
03366 #if(CXSC_INDEX_CHECK)
03367 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03368 #else
03369 throw();
03370 #endif
03371
03373 INLINE cinterval operator *(const civector & rv1, const cvector &rv2)
03374 #if(CXSC_INDEX_CHECK)
03375 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03376 #else
03377 throw();
03378 #endif
03379
03380 INLINE cinterval operator *(const civector_slice &sl, const cvector &rv)
03381 #if(CXSC_INDEX_CHECK)
03382 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03383 #else
03384 throw();
03385 #endif
03386
03387 INLINE cinterval operator *(const civector &rv, const cvector_slice &sl)
03388 #if(CXSC_INDEX_CHECK)
03389 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03390 #else
03391 throw();
03392 #endif
03393
03394 INLINE cinterval operator *(const civector_slice & sl1, const cvector_slice &sl2)
03395 #if(CXSC_INDEX_CHECK)
03396 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03397 #else
03398 throw();
03399 #endif
03400
03402 INLINE civector operator +(const cvector &rv1, const civector &rv2)
03403 #if(CXSC_INDEX_CHECK)
03404 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03405 #else
03406 throw();
03407 #endif
03408
03409 INLINE civector operator +(const cvector &rv, const civector_slice &sl)
03410 #if(CXSC_INDEX_CHECK)
03411 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03412 #else
03413 throw();
03414 #endif
03415
03416 INLINE civector operator +(const cvector_slice &sl, const civector &rv)
03417 #if(CXSC_INDEX_CHECK)
03418 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03419 #else
03420 throw();
03421 #endif
03422
03423 INLINE civector operator +(const cvector_slice &sl1, const civector_slice &sl2)
03424 #if(CXSC_INDEX_CHECK)
03425 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03426 #else
03427 throw();
03428 #endif
03429
03431 INLINE civector operator +(const civector &rv1, const cvector &rv2)
03432 #if(CXSC_INDEX_CHECK)
03433 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03434 #else
03435 throw();
03436 #endif
03437
03438 INLINE civector operator +(const civector &rv, const cvector_slice &sl)
03439 #if(CXSC_INDEX_CHECK)
03440 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03441 #else
03442 throw();
03443 #endif
03444
03445 INLINE civector operator +(const civector_slice &sl, const cvector &rv)
03446 #if(CXSC_INDEX_CHECK)
03447 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03448 #else
03449 throw();
03450 #endif
03451
03452 INLINE civector operator +(const civector_slice &sl1, const cvector_slice &sl2)
03453 #if(CXSC_INDEX_CHECK)
03454 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03455 #else
03456 throw();
03457 #endif
03458
03460 INLINE civector & operator +=(civector &rv1, const cvector &rv2)
03461 #if(CXSC_INDEX_CHECK)
03462 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03463 #else
03464 throw();
03465 #endif
03466
03467 INLINE civector &operator +=(civector &rv, const cvector_slice &sl)
03468 #if(CXSC_INDEX_CHECK)
03469 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03470 #else
03471 throw();
03472 #endif
03473
03475 INLINE civector operator -(const cvector &rv1, const civector &rv2)
03476 #if(CXSC_INDEX_CHECK)
03477 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03478 #else
03479 throw();
03480 #endif
03481
03482 INLINE civector operator -(const cvector &rv, const civector_slice &sl)
03483 #if(CXSC_INDEX_CHECK)
03484 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03485 #else
03486 throw();
03487 #endif
03488
03489 INLINE civector operator -(const cvector_slice &sl, const civector &rv)
03490 #if(CXSC_INDEX_CHECK)
03491 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03492 #else
03493 throw();
03494 #endif
03495
03496 INLINE civector operator -(const cvector_slice &sl1, const civector_slice &sl2)
03497 #if(CXSC_INDEX_CHECK)
03498 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03499 #else
03500 throw();
03501 #endif
03502
03504 INLINE civector operator -(const civector &rv1, const cvector &rv2)
03505 #if(CXSC_INDEX_CHECK)
03506 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03507 #else
03508 throw();
03509 #endif
03510
03511 INLINE civector operator -(const civector &rv, const cvector_slice &sl)
03512 #if(CXSC_INDEX_CHECK)
03513 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03514 #else
03515 throw();
03516 #endif
03517
03518 INLINE civector operator -(const civector_slice &sl, const cvector &rv)
03519 #if(CXSC_INDEX_CHECK)
03520 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03521 #else
03522 throw();
03523 #endif
03524
03525 INLINE civector operator -(const civector_slice &sl1, const cvector_slice &sl2)
03526 #if(CXSC_INDEX_CHECK)
03527 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03528 #else
03529 throw();
03530 #endif
03531
03533 INLINE civector & operator -=(civector &rv1, const cvector &rv2)
03534 #if(CXSC_INDEX_CHECK)
03535 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03536 #else
03537 throw();
03538 #endif
03539
03540 INLINE civector &operator -=(civector &rv, const cvector_slice &sl)
03541 #if(CXSC_INDEX_CHECK)
03542 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03543 #else
03544 throw();
03545 #endif
03546
03548 INLINE civector operator |(const cvector &rv1, const civector &rv2)
03549 #if(CXSC_INDEX_CHECK)
03550 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03551 #else
03552 throw();
03553 #endif
03554
03555 INLINE civector operator |(const cvector &rv, const civector_slice &sl)
03556 #if(CXSC_INDEX_CHECK)
03557 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03558 #else
03559 throw();
03560 #endif
03561
03562 INLINE civector operator |(const cvector_slice &sl, const civector &rv)
03563 #if(CXSC_INDEX_CHECK)
03564 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03565 #else
03566 throw();
03567 #endif
03568
03569 INLINE civector operator |(const cvector_slice &sl1, const civector_slice &sl2)
03570 #if(CXSC_INDEX_CHECK)
03571 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03572 #else
03573 throw();
03574 #endif
03575
03577 INLINE civector operator |(const civector &rv1, const cvector &rv2)
03578 #if(CXSC_INDEX_CHECK)
03579 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03580 #else
03581 throw();
03582 #endif
03583
03584 INLINE civector operator |(const civector &rv, const cvector_slice &sl)
03585 #if(CXSC_INDEX_CHECK)
03586 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03587 #else
03588 throw();
03589 #endif
03590
03591 INLINE civector operator |(const civector_slice &sl, const cvector &rv)
03592 #if(CXSC_INDEX_CHECK)
03593 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03594 #else
03595 throw();
03596 #endif
03597
03598 INLINE civector operator |(const civector_slice &sl1, const cvector_slice &sl2)
03599 #if(CXSC_INDEX_CHECK)
03600 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03601 #else
03602 throw();
03603 #endif
03604
03606 INLINE civector & operator |=(civector &rv1, const cvector &rv2)
03607 #if(CXSC_INDEX_CHECK)
03608 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03609 #else
03610 throw();
03611 #endif
03612
03613 INLINE civector &operator |=(civector &rv, const cvector_slice &sl)
03614 #if(CXSC_INDEX_CHECK)
03615 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03616 #else
03617 throw();
03618 #endif
03619
03621 INLINE civector operator &(const cvector &rv1, const civector &rv2)
03622 #if(CXSC_INDEX_CHECK)
03623 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03624 #else
03625 throw();
03626 #endif
03627
03628 INLINE civector operator &(const cvector &rv, const civector_slice &sl)
03629 #if(CXSC_INDEX_CHECK)
03630 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03631 #else
03632 throw();
03633 #endif
03634
03635 INLINE civector operator &(const cvector_slice &sl, const civector &rv)
03636 #if(CXSC_INDEX_CHECK)
03637 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03638 #else
03639 throw();
03640 #endif
03641
03642 INLINE civector operator &(const cvector_slice &sl1, const civector_slice &sl2)
03643 #if(CXSC_INDEX_CHECK)
03644 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03645 #else
03646 throw();
03647 #endif
03648
03650 INLINE civector operator &(const civector &rv1, const cvector &rv2)
03651 #if(CXSC_INDEX_CHECK)
03652 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03653 #else
03654 throw();
03655 #endif
03656
03657 INLINE civector operator &(const civector &rv, const cvector_slice &sl)
03658 #if(CXSC_INDEX_CHECK)
03659 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03660 #else
03661 throw();
03662 #endif
03663
03664 INLINE civector operator &(const civector_slice &sl, const cvector &rv)
03665 #if(CXSC_INDEX_CHECK)
03666 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03667 #else
03668 throw();
03669 #endif
03670
03671 INLINE civector operator &(const civector_slice &sl1, const cvector_slice &sl2)
03672 #if(CXSC_INDEX_CHECK)
03673 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03674 #else
03675 throw();
03676 #endif
03677
03679 INLINE civector & operator &=(civector &rv1, const cvector &rv2)
03680 #if(CXSC_INDEX_CHECK)
03681 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03682 #else
03683 throw();
03684 #endif
03685
03686 INLINE civector &operator &=(civector &rv, const cvector_slice &sl)
03687 #if(CXSC_INDEX_CHECK)
03688 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03689 #else
03690 throw();
03691 #endif
03692
03693
03694
03696 void accumulate(cidotprecision &dp, const ivector & rv1, const civector &rv2)
03697 #if(CXSC_INDEX_CHECK)
03698 throw(OP_WITH_WRONG_DIM);
03699 #else
03700 throw();
03701 #endif
03702
03703 void accumulate(cidotprecision &dp, const civector & rv1, const ivector &rv2)
03704 #if(CXSC_INDEX_CHECK)
03705 throw(OP_WITH_WRONG_DIM);
03706 #else
03707 throw();
03708 #endif
03709
03710 void accumulate(cidotprecision &dp, const ivector_slice & sl, const civector &rv)
03711 #if(CXSC_INDEX_CHECK)
03712 throw(OP_WITH_WRONG_DIM);
03713 #else
03714 throw();
03715 #endif
03716
03717 void accumulate(cidotprecision &dp,const civector_slice &sl,const ivector &rv)
03718 #if(CXSC_INDEX_CHECK)
03719 throw(OP_WITH_WRONG_DIM);
03720 #else
03721 throw();
03722 #endif
03723
03724 void accumulate(cidotprecision &dp, const ivector &rv, const civector_slice &sl)
03725 #if(CXSC_INDEX_CHECK)
03726 throw(OP_WITH_WRONG_DIM);
03727 #else
03728 throw();
03729 #endif
03730
03731 void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
03732 #if(CXSC_INDEX_CHECK)
03733 throw(OP_WITH_WRONG_DIM);
03734 #else
03735 throw();
03736 #endif
03737
03738 void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
03739 #if(CXSC_INDEX_CHECK)
03740 throw(OP_WITH_WRONG_DIM);
03741 #else
03742 throw();
03743 #endif
03744
03745 void accumulate(cidotprecision &dp,const civector &rv,const ivector_slice &sl)
03746 #if(CXSC_INDEX_CHECK)
03747 throw(OP_WITH_WRONG_DIM);
03748 #else
03749 throw();
03750 #endif
03751
03752 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
03753 #if(CXSC_INDEX_CHECK)
03754 throw(OP_WITH_WRONG_DIM);
03755 #else
03756 throw();
03757 #endif
03758
03759 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
03760 #if(CXSC_INDEX_CHECK)
03761 throw(OP_WITH_WRONG_DIM);
03762 #else
03763 throw();
03764 #endif
03765
03766 void accumulate(cidotprecision &dp, const civector_slice & sl1, const ivector_slice &sl2)
03767 #if(CXSC_INDEX_CHECK)
03768 throw(OP_WITH_WRONG_DIM);
03769 #else
03770 throw();
03771 #endif
03772
03773 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const civector_slice &sl2)
03774 #if(CXSC_INDEX_CHECK)
03775 throw(OP_WITH_WRONG_DIM);
03776 #else
03777 throw();
03778 #endif
03779
03780 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
03781 #if(CXSC_INDEX_CHECK)
03782 throw(OP_WITH_WRONG_DIM);
03783 #else
03784 throw();
03785 #endif
03786
03787 void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
03788 #if(CXSC_INDEX_CHECK)
03789 throw(OP_WITH_WRONG_DIM);
03790 #else
03791 throw();
03792 #endif
03793
03794 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector_slice &rv2)
03795 #if(CXSC_INDEX_CHECK)
03796 throw(OP_WITH_WRONG_DIM);
03797 #else
03798 throw();
03799 #endif
03800
03801 void accumulate(cidotprecision &dp, const civector_slice & rv1, const cmatrix_subv &rv2)
03802 #if(CXSC_INDEX_CHECK)
03803 throw(OP_WITH_WRONG_DIM);
03804 #else
03805 throw();
03806 #endif
03807
03809 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &sl2)
03810 #if(CXSC_INDEX_CHECK)
03811 throw(OP_WITH_WRONG_DIM);
03812 #else
03813 throw();
03814 #endif
03815
03816 void accumulate(cidotprecision &dp, const rmatrix_subv & sl1, const civector_slice &sl2)
03817 #if(CXSC_INDEX_CHECK)
03818 throw(OP_WITH_WRONG_DIM);
03819 #else
03820 throw();
03821 #endif
03822
03824 INLINE cinterval operator *(const ivector & rv1, const civector &rv2)
03825 #if(CXSC_INDEX_CHECK)
03826 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03827 #else
03828 throw();
03829 #endif
03830
03831 INLINE cinterval operator *(const ivector_slice &sl, const civector &rv)
03832 #if(CXSC_INDEX_CHECK)
03833 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03834 #else
03835 throw();
03836 #endif
03837
03838 INLINE cinterval operator *(const ivector &rv, const civector_slice &sl)
03839 #if(CXSC_INDEX_CHECK)
03840 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03841 #else
03842 throw();
03843 #endif
03844
03845 INLINE cinterval operator *(const ivector_slice & sl1, const civector_slice &sl2)
03846 #if(CXSC_INDEX_CHECK)
03847 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03848 #else
03849 throw();
03850 #endif
03851
03853 INLINE cinterval operator *(const civector & rv1, const ivector &rv2)
03854 #if(CXSC_INDEX_CHECK)
03855 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03856 #else
03857 throw();
03858 #endif
03859
03860 INLINE cinterval operator *(const civector_slice &sl, const ivector &rv)
03861 #if(CXSC_INDEX_CHECK)
03862 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03863 #else
03864 throw();
03865 #endif
03866
03867 INLINE cinterval operator *(const civector &rv, const ivector_slice &sl)
03868 #if(CXSC_INDEX_CHECK)
03869 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03870 #else
03871 throw();
03872 #endif
03873
03874 INLINE cinterval operator *(const civector_slice & sl1, const ivector_slice &sl2)
03875 #if(CXSC_INDEX_CHECK)
03876 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03877 #else
03878 throw();
03879 #endif
03880
03882 INLINE civector operator +(const ivector &rv1, const civector &rv2)
03883 #if(CXSC_INDEX_CHECK)
03884 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03885 #else
03886 throw();
03887 #endif
03888
03889 INLINE civector operator +(const ivector &rv, const civector_slice &sl)
03890 #if(CXSC_INDEX_CHECK)
03891 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03892 #else
03893 throw();
03894 #endif
03895
03896 INLINE civector operator +(const ivector_slice &sl, const civector &rv)
03897 #if(CXSC_INDEX_CHECK)
03898 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03899 #else
03900 throw();
03901 #endif
03902
03903 INLINE civector operator +(const ivector_slice &sl1, const civector_slice &sl2)
03904 #if(CXSC_INDEX_CHECK)
03905 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03906 #else
03907 throw();
03908 #endif
03909
03911 INLINE civector operator +(const civector &rv1, const ivector &rv2)
03912 #if(CXSC_INDEX_CHECK)
03913 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03914 #else
03915 throw();
03916 #endif
03917
03918 INLINE civector operator +(const civector &rv, const ivector_slice &sl)
03919 #if(CXSC_INDEX_CHECK)
03920 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03921 #else
03922 throw();
03923 #endif
03924
03925 INLINE civector operator +(const civector_slice &sl, const ivector &rv)
03926 #if(CXSC_INDEX_CHECK)
03927 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03928 #else
03929 throw();
03930 #endif
03931
03932 INLINE civector operator +(const civector_slice &sl1, const ivector_slice &sl2)
03933 #if(CXSC_INDEX_CHECK)
03934 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03935 #else
03936 throw();
03937 #endif
03938
03940 INLINE civector & operator +=(civector &rv1, const ivector &rv2)
03941 #if(CXSC_INDEX_CHECK)
03942 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03943 #else
03944 throw();
03945 #endif
03946
03947 INLINE civector &operator +=(civector &rv, const ivector_slice &sl)
03948 #if(CXSC_INDEX_CHECK)
03949 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03950 #else
03951 throw();
03952 #endif
03953
03955 INLINE civector operator -(const ivector &rv1, const civector &rv2)
03956 #if(CXSC_INDEX_CHECK)
03957 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03958 #else
03959 throw();
03960 #endif
03961
03962 INLINE civector operator -(const ivector &rv, const civector_slice &sl)
03963 #if(CXSC_INDEX_CHECK)
03964 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03965 #else
03966 throw();
03967 #endif
03968
03969 INLINE civector operator -(const ivector_slice &sl, const civector &rv)
03970 #if(CXSC_INDEX_CHECK)
03971 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03972 #else
03973 throw();
03974 #endif
03975
03976 INLINE civector operator -(const ivector_slice &sl1, const civector_slice &sl2)
03977 #if(CXSC_INDEX_CHECK)
03978 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03979 #else
03980 throw();
03981 #endif
03982
03984 INLINE civector operator -(const civector &rv1, const ivector &rv2)
03985 #if(CXSC_INDEX_CHECK)
03986 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03987 #else
03988 throw();
03989 #endif
03990
03991 INLINE civector operator -(const civector &rv, const ivector_slice &sl)
03992 #if(CXSC_INDEX_CHECK)
03993 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03994 #else
03995 throw();
03996 #endif
03997
03998 INLINE civector operator -(const civector_slice &sl, const ivector &rv)
03999 #if(CXSC_INDEX_CHECK)
04000 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04001 #else
04002 throw();
04003 #endif
04004
04005 INLINE civector operator -(const civector_slice &sl1, const ivector_slice &sl2)
04006 #if(CXSC_INDEX_CHECK)
04007 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04008 #else
04009 throw();
04010 #endif
04011
04013 INLINE civector & operator -=(civector &rv1, const ivector &rv2)
04014 #if(CXSC_INDEX_CHECK)
04015 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04016 #else
04017 throw();
04018 #endif
04019
04020 INLINE civector &operator -=(civector &rv, const ivector_slice &sl)
04021 #if(CXSC_INDEX_CHECK)
04022 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04023 #else
04024 throw();
04025 #endif
04026
04028 INLINE civector operator |(const ivector &rv1, const civector &rv2)
04029 #if(CXSC_INDEX_CHECK)
04030 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04031 #else
04032 throw();
04033 #endif
04034
04035 INLINE civector operator |(const ivector &rv, const civector_slice &sl)
04036 #if(CXSC_INDEX_CHECK)
04037 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04038 #else
04039 throw();
04040 #endif
04041
04042 INLINE civector operator |(const ivector_slice &sl, const civector &rv)
04043 #if(CXSC_INDEX_CHECK)
04044 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04045 #else
04046 throw();
04047 #endif
04048
04049 INLINE civector operator |(const ivector_slice &sl1, const civector_slice &sl2)
04050 #if(CXSC_INDEX_CHECK)
04051 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04052 #else
04053 throw();
04054 #endif
04055
04057 INLINE civector operator |(const civector &rv1, const ivector &rv2)
04058 #if(CXSC_INDEX_CHECK)
04059 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04060 #else
04061 throw();
04062 #endif
04063
04064 INLINE civector operator |(const civector &rv, const ivector_slice &sl)
04065 #if(CXSC_INDEX_CHECK)
04066 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04067 #else
04068 throw();
04069 #endif
04070
04071 INLINE civector operator |(const civector_slice &sl, const ivector &rv)
04072 #if(CXSC_INDEX_CHECK)
04073 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04074 #else
04075 throw();
04076 #endif
04077
04078 INLINE civector operator |(const civector_slice &sl1, const ivector_slice &sl2)
04079 #if(CXSC_INDEX_CHECK)
04080 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04081 #else
04082 throw();
04083 #endif
04084
04086 INLINE civector & operator |=(civector &rv1, const ivector &rv2)
04087 #if(CXSC_INDEX_CHECK)
04088 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04089 #else
04090 throw();
04091 #endif
04092
04093 INLINE civector &operator |=(civector &rv, const ivector_slice &sl)
04094 #if(CXSC_INDEX_CHECK)
04095 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04096 #else
04097 throw();
04098 #endif
04099
04101 INLINE civector operator &(const ivector &rv1, const civector &rv2)
04102 #if(CXSC_INDEX_CHECK)
04103 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04104 #else
04105 throw();
04106 #endif
04107
04108 INLINE civector operator &(const ivector &rv, const civector_slice &sl)
04109 #if(CXSC_INDEX_CHECK)
04110 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04111 #else
04112 throw();
04113 #endif
04114
04115 INLINE civector operator &(const ivector_slice &sl, const civector &rv)
04116 #if(CXSC_INDEX_CHECK)
04117 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04118 #else
04119 throw();
04120 #endif
04121
04122 INLINE civector operator &(const ivector_slice &sl1, const civector_slice &sl2)
04123 #if(CXSC_INDEX_CHECK)
04124 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04125 #else
04126 throw();
04127 #endif
04128
04130 INLINE civector operator &(const civector &rv1, const ivector &rv2)
04131 #if(CXSC_INDEX_CHECK)
04132 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04133 #else
04134 throw();
04135 #endif
04136
04137 INLINE civector operator &(const civector &rv, const ivector_slice &sl)
04138 #if(CXSC_INDEX_CHECK)
04139 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04140 #else
04141 throw();
04142 #endif
04143
04144 INLINE civector operator &(const civector_slice &sl, const ivector &rv)
04145 #if(CXSC_INDEX_CHECK)
04146 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04147 #else
04148 throw();
04149 #endif
04150
04151 INLINE civector operator &(const civector_slice &sl1, const ivector_slice &sl2)
04152 #if(CXSC_INDEX_CHECK)
04153 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04154 #else
04155 throw();
04156 #endif
04157
04159 INLINE civector & operator &=(civector &rv1, const ivector &rv2)
04160 #if(CXSC_INDEX_CHECK)
04161 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04162 #else
04163 throw();
04164 #endif
04165
04166 INLINE civector &operator &=(civector &rv, const ivector_slice &sl)
04167 #if(CXSC_INDEX_CHECK)
04168 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04169 #else
04170 throw();
04171 #endif
04172
04173
04175 INLINE civector operator |(const rvector &rv1, const cvector &rv2)
04176 #if(CXSC_INDEX_CHECK)
04177 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04178 #else
04179 throw();
04180 #endif
04181
04182 INLINE civector operator |(const cvector &rv1, const rvector &rv2)
04183 #if(CXSC_INDEX_CHECK)
04184 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04185 #else
04186 throw();
04187 #endif
04188
04189 INLINE civector operator |(const cvector &rv, const rvector_slice &sl)
04190 #if(CXSC_INDEX_CHECK)
04191 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04192 #else
04193 throw();
04194 #endif
04195
04196 INLINE civector operator |(const rvector_slice &sl,const cvector &rv)
04197 #if(CXSC_INDEX_CHECK)
04198 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04199 #else
04200 throw();
04201 #endif
04202
04203 INLINE civector operator |(const cvector_slice &sl, const rvector &rv)
04204 #if(CXSC_INDEX_CHECK)
04205 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04206 #else
04207 throw();
04208 #endif
04209
04210 INLINE civector operator |(const rvector &rv,const cvector_slice &sl)
04211 #if(CXSC_INDEX_CHECK)
04212 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04213 #else
04214 throw();
04215 #endif
04216
04217 INLINE civector operator |(const cvector_slice &sl1, const rvector_slice &sl2)
04218 #if(CXSC_INDEX_CHECK)
04219 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04220 #else
04221 throw();
04222 #endif
04223
04224 INLINE civector operator |(const rvector_slice &sl1, const cvector_slice &sl2)
04225 #if(CXSC_INDEX_CHECK)
04226 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04227 #else
04228 throw();
04229 #endif
04230
04231
04233 INLINE civector operator |(const cvector &rv1, const cvector &rv2)
04234 #if(CXSC_INDEX_CHECK)
04235 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04236 #else
04237 throw();
04238 #endif
04239
04240 INLINE civector operator |(const cvector_slice &sl, const cvector &rv)
04241 #if(CXSC_INDEX_CHECK)
04242 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04243 #else
04244 throw();
04245 #endif
04246
04247 INLINE civector operator |(const cvector &rv,const cvector_slice &sl)
04248 #if(CXSC_INDEX_CHECK)
04249 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04250 #else
04251 throw();
04252 #endif
04253
04254 INLINE civector operator |(const cvector_slice &sl1, const cvector_slice &sl2)
04255 #if(CXSC_INDEX_CHECK)
04256 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04257 #else
04258 throw();
04259 #endif
04260
04261
04262
04263
04264
04266 INLINE civector operator +(const cvector &rv1, const ivector &rv2)
04267 #if(CXSC_INDEX_CHECK)
04268 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04269 #else
04270 throw();
04271 #endif
04272
04273 INLINE civector operator +(const cvector &rv, const ivector_slice &sl)
04274 #if(CXSC_INDEX_CHECK)
04275 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04276 #else
04277 throw();
04278 #endif
04279
04280 INLINE civector operator +(const cvector_slice &sl, const ivector &rv)
04281 #if(CXSC_INDEX_CHECK)
04282 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04283 #else
04284 throw();
04285 #endif
04286
04287 INLINE civector operator +(const cvector_slice &sl1, const ivector_slice &sl2)
04288 #if(CXSC_INDEX_CHECK)
04289 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04290 #else
04291 throw();
04292 #endif
04293
04295 INLINE civector operator +(const ivector &rv1, const cvector &rv2)
04296 #if(CXSC_INDEX_CHECK)
04297 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04298 #else
04299 throw();
04300 #endif
04301
04302 INLINE civector operator +(const ivector &rv, const cvector_slice &sl)
04303 #if(CXSC_INDEX_CHECK)
04304 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04305 #else
04306 throw();
04307 #endif
04308
04309 INLINE civector operator +(const ivector_slice &sl, const cvector &rv)
04310 #if(CXSC_INDEX_CHECK)
04311 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04312 #else
04313 throw();
04314 #endif
04315
04316 INLINE civector operator +(const ivector_slice &sl1, const cvector_slice &sl2)
04317 #if(CXSC_INDEX_CHECK)
04318 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04319 #else
04320 throw();
04321 #endif
04322
04323
04325 INLINE civector operator -(const cvector &rv1, const ivector &rv2)
04326 #if(CXSC_INDEX_CHECK)
04327 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04328 #else
04329 throw();
04330 #endif
04331
04332 INLINE civector operator -(const cvector &rv, const ivector_slice &sl)
04333 #if(CXSC_INDEX_CHECK)
04334 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04335 #else
04336 throw();
04337 #endif
04338
04339 INLINE civector operator -(const cvector_slice &sl, const ivector &rv)
04340 #if(CXSC_INDEX_CHECK)
04341 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04342 #else
04343 throw();
04344 #endif
04345
04346 INLINE civector operator -(const cvector_slice &sl1, const ivector_slice &sl2)
04347 #if(CXSC_INDEX_CHECK)
04348 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04349 #else
04350 throw();
04351 #endif
04352
04354 INLINE civector operator -(const ivector &rv1, const cvector &rv2)
04355 #if(CXSC_INDEX_CHECK)
04356 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04357 #else
04358 throw();
04359 #endif
04360
04361 INLINE civector operator -(const ivector &rv, const cvector_slice &sl)
04362 #if(CXSC_INDEX_CHECK)
04363 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04364 #else
04365 throw();
04366 #endif
04367
04368 INLINE civector operator -(const ivector_slice &sl, const cvector &rv)
04369 #if(CXSC_INDEX_CHECK)
04370 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04371 #else
04372 throw();
04373 #endif
04374
04375 INLINE civector operator -(const ivector_slice &sl1, const cvector_slice &sl2)
04376 #if(CXSC_INDEX_CHECK)
04377 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04378 #else
04379 throw();
04380 #endif
04381
04382
04384 INLINE civector operator |(const cvector &rv1, const ivector &rv2)
04385 #if(CXSC_INDEX_CHECK)
04386 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04387 #else
04388 throw();
04389 #endif
04390
04391 INLINE civector operator |(const cvector &rv, const ivector_slice &sl)
04392 #if(CXSC_INDEX_CHECK)
04393 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04394 #else
04395 throw();
04396 #endif
04397
04398 INLINE civector operator |(const cvector_slice &sl, const ivector &rv)
04399 #if(CXSC_INDEX_CHECK)
04400 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04401 #else
04402 throw();
04403 #endif
04404
04405 INLINE civector operator |(const cvector_slice &sl1, const ivector_slice &sl2)
04406 #if(CXSC_INDEX_CHECK)
04407 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04408 #else
04409 throw();
04410 #endif
04411
04413 INLINE civector operator |(const ivector &rv1, const cvector &rv2)
04414 #if(CXSC_INDEX_CHECK)
04415 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04416 #else
04417 throw();
04418 #endif
04419
04420 INLINE civector operator |(const ivector &rv, const cvector_slice &sl)
04421 #if(CXSC_INDEX_CHECK)
04422 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04423 #else
04424 throw();
04425 #endif
04426
04427 INLINE civector operator |(const ivector_slice &sl, const cvector &rv)
04428 #if(CXSC_INDEX_CHECK)
04429 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04430 #else
04431 throw();
04432 #endif
04433
04434 INLINE civector operator |(const ivector_slice &sl1, const cvector_slice &sl2)
04435 #if(CXSC_INDEX_CHECK)
04436 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04437 #else
04438 throw();
04439 #endif
04440
04442 INLINE civector operator &(const cvector &rv1, const ivector &rv2)
04443 #if(CXSC_INDEX_CHECK)
04444 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04445 #else
04446 throw();
04447 #endif
04448
04449 INLINE civector operator &(const cvector &rv, const ivector_slice &sl)
04450 #if(CXSC_INDEX_CHECK)
04451 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04452 #else
04453 throw();
04454 #endif
04455
04456 INLINE civector operator &(const cvector_slice &sl, const ivector &rv)
04457 #if(CXSC_INDEX_CHECK)
04458 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04459 #else
04460 throw();
04461 #endif
04462
04463 INLINE civector operator &(const cvector_slice &sl1, const ivector_slice &sl2)
04464 #if(CXSC_INDEX_CHECK)
04465 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04466 #else
04467 throw();
04468 #endif
04469
04471 INLINE civector operator &(const ivector &rv1, const cvector &rv2)
04472 #if(CXSC_INDEX_CHECK)
04473 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04474 #else
04475 throw();
04476 #endif
04477
04478 INLINE civector operator &(const ivector &rv, const cvector_slice &sl)
04479 #if(CXSC_INDEX_CHECK)
04480 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04481 #else
04482 throw();
04483 #endif
04484
04485 INLINE civector operator &(const ivector_slice &sl, const cvector &rv)
04486 #if(CXSC_INDEX_CHECK)
04487 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04488 #else
04489 throw();
04490 #endif
04491
04492 INLINE civector operator &(const ivector_slice &sl1, const cvector_slice &sl2)
04493 #if(CXSC_INDEX_CHECK)
04494 throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04495 #else
04496 throw();
04497 #endif
04498
04500 INLINE bool in(const civector& v1, const civector& v2);
04501
04502 }
04503
04504 #ifdef _CXSC_INCL_INL
04505 #include "vector.inl"
04506 #include "civector.inl"
04507 #endif
04508
04509 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
04510 # ifdef _CXSC_INCL_INL
04511 # include "civecrmat.inl"
04512 # else
04513 # include "civecrmat.hpp"
04514 # endif
04515 #endif
04516
04517 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
04518 # ifdef _CXSC_INCL_INL
04519 # include "civeccmat.inl"
04520 # else
04521 # include "civeccmat.hpp"
04522 # endif
04523 #endif
04524
04525 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
04526 # ifdef _CXSC_INCL_INL
04527 # include "civecimat.inl"
04528 # else
04529 # include "civecimat.hpp"
04530 # endif
04531 #endif
04532
04533 #ifdef CXSC_USE_BLAS
04534 #define _CXSC_BLAS_CIVECTOR
04535 #include "cxsc_blas.inl"
04536 #endif
04537
04538
04539 #endif
