C-XSC - A C++ Class Library for Extended Scientific Computing: vector.hpp Source File

00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.1)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2011 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.20 2011/06/07 15:17:42 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