C-XSC - A C++ Class Library for Extended Scientific Computing
2.5.4
|
00001 /* 00002 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4) 00003 ** 00004 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik, 00005 ** Universitaet Karlsruhe, Germany 00006 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie 00007 ** Universitaet Wuppertal, Germany 00008 ** 00009 ** This library is free software; you can redistribute it and/or 00010 ** modify it under the terms of the GNU Library General Public 00011 ** License as published by the Free Software Foundation; either 00012 ** version 2 of the License, or (at your option) any later version. 00013 ** 00014 ** This library is distributed in the hope that it will be useful, 00015 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 ** Library General Public License for more details. 00018 ** 00019 ** You should have received a copy of the GNU Library General Public 00020 ** License along with this library; if not, write to the Free 00021 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00022 */ 00023 00024 /* CVS $Id: vector.hpp,v 1.24 2014/01/30 17:23:49 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_VECTOR_HPP_INCLUDED 00027 #define _CXSC_VECTOR_HPP_INCLUDED 00028 00029 #include "except.hpp" 00030 #include "matrix.hpp" // there are the definitions matrix x vector 00031 00032 namespace cxsc { 00033 00034 00035 template <class V> 00036 TINLINE void _vresize(V &rv) throw(); 00037 00038 template <class V,class S> 00039 TINLINE void _vresize(V &rv, const int &len) 00040 #if(CXSC_INDEX_CHECK) 00041 throw(ERROR__WRONG_BOUNDARIES<V>); 00042 #else 00043 throw(); 00044 #endif 00045 00046 template <class V,class S> 00047 TINLINE void _vresize(V &rv, const int &lb, const int &ub) 00048 #if(CXSC_INDEX_CHECK) 00049 throw(ERROR__WRONG_BOUNDARIES<V>); 00050 #else 00051 throw(); 00052 #endif 00053 00054 template <class V1,class V2,class S> 00055 TINLINE V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 00056 00057 template <class V,class S> 00058 TINLINE V & _vsassign(V &rv,const S &r) throw(); 00059 00060 template <class VS1,class VS2> 00061 TINLINE VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2) 00062 #if(CXSC_INDEX_CHECK) 00063 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00064 #else 00065 throw(); 00066 #endif 00067 00068 template <class V,class VS,class S> 00069 TINLINE V & _vvsassign(V &rv,const VS &sl) throw(); 00070 00071 template <class VS,class V> 00072 TINLINE VS & _vsvassign(VS &sl,const V &rv) 00073 #if(CXSC_INDEX_CHECK) 00074 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00075 #else 00076 throw(); 00077 #endif 00078 00079 template <class VS,class S> 00080 TINLINE VS & _vssassign(VS &sl,const S &r) throw(); 00081 00082 template <class DP,class V1,class V2> 00083 TINLINE void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 00084 #if(CXSC_INDEX_CHECK) 00085 throw(OP_WITH_WRONG_DIM); 00086 #else 00087 throw(); 00088 #endif 00089 00090 template <class DP,class VS,class V> 00091 TINLINE void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00092 #if(CXSC_INDEX_CHECK) 00093 throw(OP_WITH_WRONG_DIM); 00094 #else 00095 throw(); 00096 #endif 00097 00098 template <class V,class S,class E> 00099 TINLINE E _vsdiv(const V &rv, const S &s) throw(); 00100 00101 template <class V,class S> 00102 TINLINE V &_vsdivassign(V &rv,const S &r) throw(); 00103 00104 template <class VS,class S,class E> 00105 TINLINE E _vssdiv(const VS &sl, const S &s) throw(); 00106 00107 template <class V,class S,class E> 00108 TINLINE E _vsmult(const V &rv, const S &s) throw(); 00109 00110 template <class VS,class S,class E> 00111 TINLINE E _vssmult(const VS &sl, const S &s) throw(); 00112 00113 template <class V1,class V2,class E> 00114 TINLINE E _vvlmult(const V1 & rv1, const V2 &rv2) 00115 #if(CXSC_INDEX_CHECK) 00116 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00117 #else 00118 throw(); 00119 #endif 00120 00121 template <class VS,class V,class E> 00122 TINLINE E _vsvlmult(const VS & sl, const V &rv) 00123 #if(CXSC_INDEX_CHECK) 00124 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00125 #else 00126 throw(); 00127 #endif 00128 00129 template <class VS1,class VS2,class E> 00130 TINLINE E _vsvslmult(const VS1 & sl1, const VS2 &sl2) 00131 #if(CXSC_INDEX_CHECK) 00132 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00133 #else 00134 throw(); 00135 #endif 00136 00137 template <class V1,class V2,class E> 00138 TINLINE E _vvlimult(const V1 & rv1, const V2 &rv2) 00139 #if(CXSC_INDEX_CHECK) 00140 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00141 #else 00142 throw(); 00143 #endif 00144 00145 template <class VS,class V,class E> 00146 TINLINE E _vsvlimult(const VS & sl, const V &rv) 00147 #if(CXSC_INDEX_CHECK) 00148 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00149 #else 00150 throw(); 00151 #endif 00152 00153 template <class VS1,class VS2,class E> 00154 TINLINE E _vsvslimult(const VS1 & sl1, const VS2 &sl2) 00155 #if(CXSC_INDEX_CHECK) 00156 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00157 #else 00158 throw(); 00159 #endif 00160 00161 template <class V1,class V2,class E> 00162 TINLINE E _vvmult(const V1 & rv1, const V2 &rv2) 00163 #if(CXSC_INDEX_CHECK) 00164 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00165 #else 00166 throw(); 00167 #endif 00168 00169 template <class VS,class V,class E> 00170 TINLINE E _vsvmult(const VS & sl, const V &rv) 00171 #if(CXSC_INDEX_CHECK) 00172 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00173 #else 00174 throw(); 00175 #endif 00176 00177 template <class VS1,class VS2,class E> 00178 TINLINE E _vsvsmult(const VS1 & sl1, const VS2 &sl2) 00179 #if(CXSC_INDEX_CHECK) 00180 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00181 #else 00182 throw(); 00183 #endif 00184 00185 template <class V1,class V2,class E> 00186 TINLINE E _vvimult(const V1 & rv1, const V2 &rv2) 00187 #if(CXSC_INDEX_CHECK) 00188 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00189 #else 00190 throw(); 00191 #endif 00192 00193 template <class VS,class V,class E> 00194 TINLINE E _vsvimult(const VS & sl, const V &rv) 00195 #if(CXSC_INDEX_CHECK) 00196 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00197 #else 00198 throw(); 00199 #endif 00200 00201 template <class VS1,class VS2,class E> 00202 TINLINE E _vsvsimult(const VS1 & sl1, const VS2 &sl2) 00203 #if(CXSC_INDEX_CHECK) 00204 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00205 #else 00206 throw(); 00207 #endif 00208 00209 template <class V1,class V2,class E> 00210 TINLINE E _vvcmult(const V1 & rv1, const V2 &rv2) 00211 #if(CXSC_INDEX_CHECK) 00212 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00213 #else 00214 throw(); 00215 #endif 00216 00217 template <class VS,class V,class E> 00218 TINLINE E _vsvcmult(const VS & sl, const V &rv) 00219 #if(CXSC_INDEX_CHECK) 00220 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00221 #else 00222 throw(); 00223 #endif 00224 00225 template <class VS1,class VS2,class E> 00226 TINLINE E _vsvscmult(const VS1 & sl1, const VS2 &sl2) 00227 #if(CXSC_INDEX_CHECK) 00228 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00229 #else 00230 throw(); 00231 #endif 00232 00233 template <class V1,class V2,class E> 00234 TINLINE E _vvcimult(const V1 & rv1, const V2 &rv2) 00235 #if(CXSC_INDEX_CHECK) 00236 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00237 #else 00238 throw(); 00239 #endif 00240 00241 template <class VS,class V,class E> 00242 TINLINE E _vsvcimult(const VS & sl, const V &rv) 00243 #if(CXSC_INDEX_CHECK) 00244 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00245 #else 00246 throw(); 00247 #endif 00248 00249 template <class VS1,class VS2,class E> 00250 TINLINE E _vsvscimult(const VS1 & sl1, const VS2 &sl2) 00251 #if(CXSC_INDEX_CHECK) 00252 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00253 #else 00254 throw(); 00255 #endif 00256 00257 template <class V,class S> 00258 TINLINE V &_vsmultassign(V &rv,const S &r) throw(); 00259 00260 template <class VS,class S> 00261 TINLINE VS &_vssmultassign(VS &rv,const S &r) throw(); 00262 00263 template <class VS,class S> 00264 TINLINE VS &_vssdivassign(VS &rv,const S &r) throw(); 00265 00266 template <class V1,class V2,class E> 00267 TINLINE E _vvplus(const V1 &rv1, const V2 &rv2) 00268 #if(CXSC_INDEX_CHECK) 00269 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00270 #else 00271 throw(); 00272 #endif 00273 00274 template <class V,class VS,class E> 00275 TINLINE E _vvsplus(const V &rv,const VS &sl) 00276 #if(CXSC_INDEX_CHECK) 00277 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00278 #else 00279 throw(); 00280 #endif 00281 00282 template <class VS1,class VS2,class E> 00283 TINLINE E _vsvsplus(const VS1 &s1,const VS2 &s2) 00284 #if(CXSC_INDEX_CHECK) 00285 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00286 #else 00287 throw(); 00288 #endif 00289 00290 template <class VS1,class VS2,class E> 00291 TINLINE 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 00298 template <class V1,class V2> 00299 TINLINE V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 00300 #if(CXSC_INDEX_CHECK) 00301 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00302 #else 00303 throw(); 00304 #endif 00305 00306 template <class V,class VS> 00307 TINLINE V &_vvsplusassign(V &rv, const VS &sl) 00308 #if(CXSC_INDEX_CHECK) 00309 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00310 #else 00311 throw(); 00312 #endif 00313 00314 template <class VS,class V> 00315 TINLINE VS &_vsvplusassign(VS &sl, const V &rv) 00316 #if(CXSC_INDEX_CHECK) 00317 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00318 #else 00319 throw(); 00320 #endif 00321 00322 template <class VS1,class VS2> 00323 TINLINE VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00324 #if(CXSC_INDEX_CHECK) 00325 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00326 #else 00327 throw(); 00328 #endif 00329 00330 template <class VS1,class VS2> 00331 TINLINE VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00332 #if(CXSC_INDEX_CHECK) 00333 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00334 #else 00335 throw(); 00336 #endif 00337 00338 template <class V1,class V2> 00339 TINLINE V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 00340 #if(CXSC_INDEX_CHECK) 00341 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00342 #else 00343 throw(); 00344 #endif 00345 00346 template <class V,class VS> 00347 TINLINE V &_vvsminusassign(V &rv, const VS &sl) 00348 #if(CXSC_INDEX_CHECK) 00349 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00350 #else 00351 throw(); 00352 #endif 00353 00354 template <class VS,class V> 00355 TINLINE VS &_vsvminusassign(VS &sl, const V &rv) 00356 #if(CXSC_INDEX_CHECK) 00357 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00358 #else 00359 throw(); 00360 #endif 00361 00362 template <class V> 00363 TINLINE V _vminus(const V &rv) throw(); 00364 00365 template <class VS,class V> 00366 TINLINE V _vsminus(const VS &sl) throw(); 00367 00368 template <class V1,class V2,class E> 00369 TINLINE E _vvminus(const V1 &rv1, const V2 &rv2) 00370 #if(CXSC_INDEX_CHECK) 00371 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00372 #else 00373 throw(); 00374 #endif 00375 00376 template <class V,class VS,class E> 00377 TINLINE E _vvsminus(const V &rv, const VS &sl) 00378 #if(CXSC_INDEX_CHECK) 00379 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00380 #else 00381 throw(); 00382 #endif 00383 00384 template <class VS,class V,class E> 00385 TINLINE E _vsvminus(const VS &sl,const V &rv) 00386 #if(CXSC_INDEX_CHECK) 00387 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00388 #else 00389 throw(); 00390 #endif 00391 00392 template <class V1,class V2,class E> 00393 TINLINE E _vvconv(const V1 &rv1, const V2 &rv2) 00394 #if(CXSC_INDEX_CHECK) 00395 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00396 #else 00397 throw(); 00398 #endif 00399 00400 template <class V,class VS,class E> 00401 TINLINE E _vvsconv(const V &rv,const VS &sl) 00402 #if(CXSC_INDEX_CHECK) 00403 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00404 #else 00405 throw(); 00406 #endif 00407 00408 template <class VS1,class VS2,class E> 00409 TINLINE E _vsvsconv(const VS1 &s1,const VS2 &s2) 00410 #if(CXSC_INDEX_CHECK) 00411 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00412 #else 00413 throw(); 00414 #endif 00415 00416 template <class V1,class V2> 00417 TINLINE V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 00418 #if(CXSC_INDEX_CHECK) 00419 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00420 #else 00421 throw(); 00422 #endif 00423 00424 template <class V,class VS> 00425 TINLINE V &_vvsconvassign(V &rv, const VS &sl) 00426 #if(CXSC_INDEX_CHECK) 00427 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00428 #else 00429 throw(); 00430 #endif 00431 00432 template <class VS,class V> 00433 TINLINE VS &_vsvconvassign(VS &sl, const V &rv) 00434 #if(CXSC_INDEX_CHECK) 00435 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00436 #else 00437 throw(); 00438 #endif 00439 00440 template <class VS1,class VS2> 00441 TINLINE VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 00442 #if(CXSC_INDEX_CHECK) 00443 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00444 #else 00445 throw(); 00446 #endif 00447 00448 template <class V1,class V2,class E> 00449 TINLINE E _vvsect(const V1 &rv1, const V2 &rv2) 00450 #if(CXSC_INDEX_CHECK) 00451 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00452 #else 00453 throw(); 00454 #endif 00455 00456 template <class V,class VS,class E> 00457 TINLINE E _vvssect(const V &rv,const VS &sl) 00458 #if(CXSC_INDEX_CHECK) 00459 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00460 #else 00461 throw(); 00462 #endif 00463 00464 template <class VS1,class VS2,class E> 00465 TINLINE E _vsvssect(const VS1 &s1,const VS2 &s2) 00466 #if(CXSC_INDEX_CHECK) 00467 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00468 #else 00469 throw(); 00470 #endif 00471 00472 template <class V1,class V2> 00473 TINLINE V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 00474 #if(CXSC_INDEX_CHECK) 00475 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00476 #else 00477 throw(); 00478 #endif 00479 00480 template <class V,class VS> 00481 TINLINE V &_vvssectassign(V &rv, const VS &sl) 00482 #if(CXSC_INDEX_CHECK) 00483 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00484 #else 00485 throw(); 00486 #endif 00487 00488 template <class VS,class V> 00489 TINLINE VS &_vsvsectassign(VS &sl, const V &rv) 00490 #if(CXSC_INDEX_CHECK) 00491 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00492 #else 00493 throw(); 00494 #endif 00495 00496 template <class VS1,class VS2> 00497 TINLINE VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 00498 #if(CXSC_INDEX_CHECK) 00499 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00500 #else 00501 throw(); 00502 #endif 00503 00504 template <class V1,class V2> 00505 TINLINE bool _vveq(const V1 &rv1, const V2 &rv2) throw(); 00506 00507 template <class VS,class V> 00508 TINLINE bool _vsveq(const VS &sl, const V &rv) throw(); 00509 00510 template <class V1,class V2> 00511 TINLINE bool _vvneq(const V1 &rv1, const V2 &rv2) throw(); 00512 00513 template <class VS,class V> 00514 TINLINE bool _vsvneq(const VS &sl, const V &rv) throw(); 00515 00516 template <class V1,class V2> 00517 TINLINE bool _vvless(const V1 &rv1, const V2 &rv2) throw(); 00518 00519 template <class VS,class V> 00520 TINLINE bool _vsvless(const VS &sl, const V &rv) throw(); 00521 00522 template <class V1,class V2> 00523 TINLINE bool _vvleq(const V1 &rv1, const V2 &rv2) throw(); 00524 00525 template <class VS,class V> 00526 TINLINE bool _vsvleq(const VS &sl, const V &rv) throw(); 00527 00528 template <class V,class VS> 00529 TINLINE bool _vvsless(const V &rv, const VS &sl) throw(); 00530 00531 template <class V,class VS> 00532 TINLINE bool _vvsleq(const V &rv, const VS &sl) throw(); 00533 00534 template <class V> 00535 TINLINE bool _vnot(const V &rv) throw(); 00536 00537 template <class V> 00538 TINLINE void *_vvoid(const V &rv) throw(); 00539 00540 template <class V> 00541 TINLINE V _vconj(const V &rv) throw(); 00542 00543 template <class VS,class E> 00544 TINLINE E _vsconj(const VS &sl) throw(); 00545 00546 template <class V,class E> 00547 TINLINE E _vabs(const V &rv) throw(); 00548 00549 template <class VS,class E> 00550 TINLINE E _vsabs(const VS &sl) throw(); 00551 00552 template <class V,class E> 00553 TINLINE E _vdiam(const V &rv) throw(); 00554 00555 template <class VS,class E> 00556 TINLINE E _vsdiam(const VS &sl) throw(); 00557 00558 template <class V,class E> 00559 TINLINE E _vmid(const V &rv) throw(); 00560 00561 template <class VS,class E> 00562 TINLINE E _vsmid(const VS &sl) throw(); 00563 00564 template <class V,class E> 00565 TINLINE E _vinf(const V &rv) throw(); 00566 00567 template <class VS,class E> 00568 TINLINE E _vsinf(const VS &sl) throw(); 00569 00570 template <class V,class E> 00571 TINLINE E _vsup(const V &rv) throw(); 00572 00573 template <class VS,class E> 00574 TINLINE E _vssup(const VS &sl) throw(); 00575 00576 template <class V,class E> 00577 TINLINE E _vre(const V &rv) throw(); 00578 00579 template <class VS,class E> 00580 TINLINE E _vsre(const VS &sl) throw(); 00581 00582 template <class V,class E> 00583 TINLINE E _vim(const V &rv) throw(); 00584 00585 template <class VS,class E> 00586 TINLINE E _vsim(const VS &sl) throw(); 00587 00588 template <class V,class S> 00589 TINLINE V &_vsusetsup(V &v, const S &s) throw(); 00590 00591 template <class V,class S> 00592 TINLINE V &_vsusetinf(V &v, const S &s) throw(); 00593 00594 template <class V,class S> 00595 TINLINE V &_vssetinf(V &v, const S &s) throw(); 00596 00597 template <class V,class S> 00598 TINLINE V &_vssetsup(V &v, const S &s) throw(); 00599 00600 template <class V,class S> 00601 TINLINE V &_vssetre(V &v, const S &s) throw(); 00602 00603 template <class V,class S> 00604 TINLINE V &_vssetim(V &v, const S &s) throw(); 00605 00606 template <class VS,class S> 00607 TINLINE VS &_vssusetsup(VS &vs, const S &s) throw(); 00608 00609 template <class VS,class S> 00610 TINLINE VS &_vssusetinf(VS &vs, const S &s) throw(); 00611 00612 template <class VS,class S> 00613 TINLINE VS &_vsssetinf(VS &vs, const S &s) throw(); 00614 00615 template <class VS,class S> 00616 TINLINE VS &_vsssetsup(VS &vs, const S &s) throw(); 00617 00618 template <class VS,class S> 00619 TINLINE VS &_vsssetre(VS &vs, const S &s) throw(); 00620 00621 template <class VS,class S> 00622 TINLINE VS &_vsssetim(VS &vs, const S &s) throw(); 00623 00624 template <class V1,class V2> 00625 TINLINE V1 &_vvsetinf(V1 &rv1, const V2 &rv2) 00626 #if(CXSC_INDEX_CHECK) 00627 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00628 #else 00629 throw(); 00630 #endif 00631 00632 template <class V,class VS> 00633 TINLINE V &_vvssetinf(V &rv, const VS &sl) 00634 #if(CXSC_INDEX_CHECK) 00635 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00636 #else 00637 throw(); 00638 #endif 00639 00640 template <class VS,class V> 00641 TINLINE VS &_vsvsetinf(VS &sl, const V &rv) 00642 #if(CXSC_INDEX_CHECK) 00643 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00644 #else 00645 throw(); 00646 #endif 00647 00648 template <class VS1,class VS2> 00649 TINLINE VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2) 00650 #if(CXSC_INDEX_CHECK) 00651 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00652 #else 00653 throw(); 00654 #endif 00655 00656 template <class V1,class V2> 00657 TINLINE V1 &_vvsetsup(V1 &rv1, const V2 &rv2) 00658 #if(CXSC_INDEX_CHECK) 00659 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00660 #else 00661 throw(); 00662 #endif 00663 00664 template <class V,class VS> 00665 TINLINE V &_vvssetsup(V &rv, const VS &sl) 00666 #if(CXSC_INDEX_CHECK) 00667 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00668 #else 00669 throw(); 00670 #endif 00671 00672 template <class VS,class V> 00673 TINLINE VS &_vsvsetsup(VS &sl, const V &rv) 00674 #if(CXSC_INDEX_CHECK) 00675 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00676 #else 00677 throw(); 00678 #endif 00679 00680 template <class VS1,class VS2> 00681 TINLINE VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2) 00682 #if(CXSC_INDEX_CHECK) 00683 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00684 #else 00685 throw(); 00686 #endif 00687 00688 template <class V1,class V2> 00689 TINLINE V1 &_vvusetinf(V1 &rv1, const V2 &rv2) 00690 #if(CXSC_INDEX_CHECK) 00691 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00692 #else 00693 throw(); 00694 #endif 00695 00696 template <class V,class VS> 00697 TINLINE V &_vvsusetinf(V &rv, const VS &sl) 00698 #if(CXSC_INDEX_CHECK) 00699 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00700 #else 00701 throw(); 00702 #endif 00703 00704 template <class VS,class V> 00705 TINLINE VS &_vsvusetinf(VS &sl, const V &rv) 00706 #if(CXSC_INDEX_CHECK) 00707 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00708 #else 00709 throw(); 00710 #endif 00711 00712 template <class VS1,class VS2> 00713 TINLINE VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2) 00714 #if(CXSC_INDEX_CHECK) 00715 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00716 #else 00717 throw(); 00718 #endif 00719 00720 template <class V1,class V2> 00721 TINLINE V1 &_vvusetsup(V1 &rv1, const V2 &rv2) 00722 #if(CXSC_INDEX_CHECK) 00723 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00724 #else 00725 throw(); 00726 #endif 00727 00728 template <class V,class VS> 00729 TINLINE V &_vvsusetsup(V &rv, const VS &sl) 00730 #if(CXSC_INDEX_CHECK) 00731 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00732 #else 00733 throw(); 00734 #endif 00735 00736 template <class VS,class V> 00737 TINLINE VS &_vsvusetsup(VS &sl, const V &rv) 00738 #if(CXSC_INDEX_CHECK) 00739 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00740 #else 00741 throw(); 00742 #endif 00743 00744 template <class VS1,class VS2> 00745 TINLINE VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2) 00746 #if(CXSC_INDEX_CHECK) 00747 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00748 #else 00749 throw(); 00750 #endif 00751 00752 template <class V1,class V2> 00753 TINLINE V1 &_vvsetim(V1 &rv1, const V2 &rv2) 00754 #if(CXSC_INDEX_CHECK) 00755 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00756 #else 00757 throw(); 00758 #endif 00759 00760 template <class V,class VS> 00761 TINLINE V &_vvssetim(V &rv, const VS &sl) 00762 #if(CXSC_INDEX_CHECK) 00763 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00764 #else 00765 throw(); 00766 #endif 00767 00768 template <class VS,class V> 00769 TINLINE VS &_vsvsetim(VS &sl, const V &rv) 00770 #if(CXSC_INDEX_CHECK) 00771 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00772 #else 00773 throw(); 00774 #endif 00775 00776 template <class VS1,class VS2> 00777 TINLINE VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2) 00778 #if(CXSC_INDEX_CHECK) 00779 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00780 #else 00781 throw(); 00782 #endif 00783 00784 template <class V1,class V2> 00785 TINLINE V1 &_vvsetre(V1 &rv1, const V2 &rv2) 00786 #if(CXSC_INDEX_CHECK) 00787 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00788 #else 00789 throw(); 00790 #endif 00791 00792 template <class V,class VS> 00793 TINLINE V &_vvssetre(V &rv, const VS &sl) 00794 #if(CXSC_INDEX_CHECK) 00795 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00796 #else 00797 throw(); 00798 #endif 00799 00800 template <class VS,class V> 00801 TINLINE VS &_vsvsetre(VS &sl, const V &rv) 00802 #if(CXSC_INDEX_CHECK) 00803 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00804 #else 00805 throw(); 00806 #endif 00807 00808 template <class VS1,class VS2> 00809 TINLINE VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2) 00810 #if(CXSC_INDEX_CHECK) 00811 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00812 #else 00813 throw(); 00814 #endif 00815 00816 template <class DP,class VS1,class VS2> 00817 TINLINE void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 00818 #if(CXSC_INDEX_CHECK) 00819 throw(OP_WITH_WRONG_DIM); 00820 #else 00821 throw(); 00822 #endif 00823 00824 template <class VS1,class VS2> 00825 TINLINE bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00826 00827 template <class VS1,class VS2> 00828 TINLINE bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00829 00830 template <class VS1,class VS2> 00831 TINLINE bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00832 00833 template <class VS1,class VS2> 00834 TINLINE bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00835 00836 template <class VS> 00837 TINLINE bool _vsnot(const VS &sl) throw(); 00838 00839 template <class VS> 00840 TINLINE void *_vsvoid(const VS &sl) throw(); 00841 00842 template <class V> 00843 std::ostream &_vout(std::ostream &s, const V &rv) throw(); 00844 00845 template <class V> 00846 std::istream &_vin(std::istream &s, V &rv) throw(); 00847 00848 template <class V> 00849 std::ostream &_vsout(std::ostream &s, const V &rv) throw(); 00850 00851 template <class V> 00852 std::istream &_vsin(std::istream &s, V &rv) throw(); 00853 00854 } // namespace cxsc 00855 00856 #endif 00857