apidoc/html/vector_8inl_source.html

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