Object-oriented Scientific Computing Library: Version 0.910
ovector_rev_tlate.h
Go to the documentation of this file.
00001 /*
00002   -------------------------------------------------------------------
00003   
00004   Copyright (C) 2006-2012, Andrew W. Steiner
00005   
00006   This file is part of O2scl.
00007   
00008   O2scl is free software; you can redistribute it and/or modify
00009   it under the terms of the GNU General Public License as published by
00010   the Free Software Foundation; either version 3 of the License, or
00011   (at your option) any later version.
00012   
00013   O2scl is distributed in the hope that it will be useful,
00014   but WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016   GNU General Public License for more details.
00017   
00018   You should have received a copy of the GNU General Public License
00019   along with O2scl. If not, see <http://www.gnu.org/licenses/>.
00020 
00021   -------------------------------------------------------------------
00022 */
00023 #ifndef O2SCL_OVECTOR_REV_TLATE_H
00024 #define O2SCL_OVECTOR_REV_TLATE_H
00025 
00026 /** \file ovector_rev_tlate.h
00027     \brief File for definitions of reversed vectors
00028 */
00029 
00030 #include <iostream>
00031 #include <cstdlib>
00032 #include <string>
00033 #include <fstream>
00034 #include <sstream>
00035 #include <vector>
00036 #include <gsl/gsl_vector.h>
00037 #include <o2scl/err_hnd.h>
00038 #include <o2scl/string_conv.h>
00039 #include <o2scl/ovector_tlate.h>
00040 #include <o2scl/array.h>
00041 #include <o2scl/vector.h>
00042 
00043 #ifndef DOXYGENP
00044 namespace o2scl {
00045 #endif
00046 
00047   /** \brief Reversed view of a vector
00048 
00049       \note Note that you can't reverse a reversed vector, and this
00050       is why this class does not have a constructor of the form
00051       <tt>ovector_reverse(ovector_reverse &v)</tt>.
00052       
00053   */
00054   template<class data_t, class vparent_t, class block_t> 
00055     class ovector_reverse_tlate : 
00056   public ovector_base_tlate<data_t,vparent_t,block_t> {
00057 
00058   public:
00059 
00060     /** \brief Create a vector from \c dat with size \c n and stride \c s 
00061      */
00062     ovector_reverse_tlate(ovector_tlate<data_t,vparent_t,block_t> &v) {
00063       vparent_t::block=v.block;
00064       vparent_t::data=v.data;
00065       vparent_t::size=v.size();
00066       vparent_t::stride=v.stride();
00067       vparent_t::owner=0;
00068     }
00069 
00070     /** \brief Create a vector from \c dat with size \c n and stride \c s 
00071      */
00072     ovector_reverse_tlate(ovector_view_tlate<data_t,vparent_t,block_t> &v) {
00073       vparent_t::block=v.block;
00074       vparent_t::data=v.data;
00075       vparent_t::size=v.size();
00076       vparent_t::stride=v.stride();
00077       vparent_t::owner=0;
00078     }
00079 
00080     /// \name Get and set methods
00081     //@{
00082     /** \brief Array-like indexing 
00083     */
00084     data_t &operator[](size_t i) {
00085 #if O2SCL_NO_RANGE_CHECK
00086 #else
00087       if (i>=vparent_t::size) {
00088         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00089                    +" in ovector_reverse_tlate::operator[]. Size: "+
00090                    itos(vparent_t::size)+
00091                    " (index should be less than size).").c_str(),gsl_eindex);
00092         return vparent_t::data[0];
00093       }
00094 #endif
00095       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00096     }
00097     
00098     /** \brief Array-like indexing 
00099     */
00100     const data_t &operator[](size_t i) const {
00101 #if O2SCL_NO_RANGE_CHECK
00102 #else
00103       if (i>=vparent_t::size) {
00104         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00105                    +" in ovector_reverse_tlate::operator[]. Size: "+
00106                    itos(vparent_t::size)+
00107                    " (index should be less than size).").c_str(),gsl_eindex);
00108         return vparent_t::data[0];
00109       }
00110 #endif
00111       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00112     }
00113     
00114     /** \brief Array-like indexing 
00115     */
00116     data_t &operator()(size_t i) {
00117 #if O2SCL_NO_RANGE_CHECK
00118 #else
00119       if (i>=vparent_t::size) {
00120         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00121                    +" in ovector_reverse_tlate::operator(). Size: "+
00122                    itos(vparent_t::size)+
00123                    " (index should be less than size).").c_str(),gsl_eindex);
00124         return vparent_t::data[0];
00125       }
00126 #endif
00127       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00128     }
00129     
00130     /** \brief Array-like indexing 
00131     */
00132     const data_t &operator()(size_t i) const {
00133 #if O2SCL_NO_RANGE_CHECK
00134 #else
00135       if (i>=vparent_t::size) {
00136         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00137                    +" in ovector_reverse_tlate::operator(). Size: "+
00138                    itos(vparent_t::size)+
00139                    " (index should be less than size).").c_str(),gsl_eindex);
00140         return vparent_t::data[0];
00141       }
00142 #endif
00143       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00144     }
00145     
00146     /** \brief Get (with optional range-checking) */
00147     data_t get(size_t i) const {
00148 #if O2SCL_NO_RANGE_CHECK
00149 #else
00150       if (i>=vparent_t::size) {
00151         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00152                    +" in ovector_reverse_tlate::get(). Size: "+
00153                    itos(vparent_t::size)+
00154                    " (index should be less than size).").c_str(),gsl_eindex);
00155         return vparent_t::data[0];
00156       }
00157 #endif
00158       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00159     }
00160     
00161     /** \brief Get pointer (with optional range-checking) */
00162     data_t *get_ptr(size_t i) {
00163 #if O2SCL_NO_RANGE_CHECK
00164 #else
00165       if (i>=vparent_t::size) {
00166         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00167                    +" in ovector_reverse_tlate::get_ptr(). Size: "+
00168                    itos(vparent_t::size)+
00169                    " (index should be less than size).").c_str(),gsl_eindex);
00170         return vparent_t::data;
00171       }
00172 #endif
00173       return vparent_t::data+(vparent_t::size-1-i)*vparent_t::stride;
00174     }
00175     
00176     /** \brief Get pointer (with optional range-checking) */
00177     const data_t *get_const_ptr(size_t i) const {
00178 #if O2SCL_NO_RANGE_CHECK
00179 #else
00180       if (i>=vparent_t::size) {
00181         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00182                    +" in ovector_reverse_tlate::get_const_ptr(). Size: "+
00183                    itos(vparent_t::size)+
00184                    " (index should be less than size).").c_str(),gsl_eindex);
00185         return (const data_t *)vparent_t::data;
00186       }
00187 #endif
00188       return (const data_t *)(vparent_t::data+
00189                               (vparent_t::size-1-i)*vparent_t::stride);
00190     }
00191     
00192     /** \brief Set (with optional range-checking) */
00193     int set(size_t i, data_t val) {
00194 #if O2SCL_NO_RANGE_CHECK
00195 #else
00196       if (i>=vparent_t::size) {
00197         O2SCL_ERR_RET((((std::string)"Array index ")+itos(i)+" out of bounds"
00198                        +" in ovector_reverse_tlate::set(). Size: "+
00199                        itos(vparent_t::size)+
00200                        " (index should be less than size).").c_str(),
00201                       gsl_eindex);
00202       }
00203 #endif
00204       vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride]=val;
00205       return 0;
00206     }
00207 
00208     /** \brief Set all of the value to be the value \c val */
00209     int set_all(double val) {
00210       for(size_t i=0;i<vparent_t::size;i++) {
00211         vparent_t::data[i*vparent_t::stride]=val;
00212       }
00213       return 0;
00214     }
00215 
00216   };
00217 
00218   /** \brief Reversed view of a vector
00219 
00220       \warning At present, reversing a reversed vector does not give
00221       the original ordering.
00222 
00223       \future I think that maybe in order to ensure that this isn't
00224       created from an already reversed vector, this class has to be
00225       separated from the hierarchy altogether. However, I think this
00226       might break the smart interpolation stuff. 
00227   */
00228   template<class data_t, class vparent_t, class block_t> 
00229     class ovector_const_reverse_tlate : 
00230   public ovector_const_view_tlate<data_t,vparent_t,block_t> {
00231   public:
00232 
00233     /** \brief Create a vector from \c dat with size \c n and stride \c s 
00234      */
00235     ovector_const_reverse_tlate
00236       (const ovector_const_view_tlate<data_t,vparent_t,block_t> &v) {
00237       vparent_t::block=v.block;
00238       vparent_t::data=v.data;
00239       vparent_t::size=v.size();
00240       vparent_t::stride=v.stride();
00241       vparent_t::owner=0;
00242     }
00243 
00244     /// \name Get and set methods
00245     //@{
00246     /** \brief Array-like indexing
00247     */
00248     const data_t &operator[](size_t i) const {
00249 #if O2SCL_NO_RANGE_CHECK
00250 #else
00251       if (i>=vparent_t::size) {
00252         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00253                    +" in ovector_const_reverse_tlate::operator[]. Size: "+
00254                    itos(vparent_t::size)+
00255                    " (index should be less than size).").c_str(),gsl_eindex);
00256         return vparent_t::data[0];
00257       }
00258 #endif
00259       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00260     }
00261 
00262     /** \brief Array-like indexing
00263     */
00264     const data_t &operator()(size_t i) const {
00265 #if O2SCL_NO_RANGE_CHECK
00266 #else
00267       if (i>=vparent_t::size) {
00268         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00269                    +" in ovector_const_reverse_tlate::operator(). Size: "+
00270                    itos(vparent_t::size)+
00271                    " (index should be less than size).").c_str(),gsl_eindex);
00272         return vparent_t::data[0];
00273       }
00274 #endif
00275       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00276     }
00277 
00278     /** \brief Get (with optional range-checking) */
00279     data_t get(size_t i) const {
00280 #if O2SCL_NO_RANGE_CHECK
00281 #else
00282       if (i>=vparent_t::size) {
00283         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00284                    +" in ovector_const_reverse_tlate::get(). Size: "+
00285                    itos(vparent_t::size)+
00286                    " (index should be less than size).").c_str(),gsl_eindex);
00287         return vparent_t::data[0];
00288       }
00289 #endif
00290       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00291     }
00292 
00293     /** \brief Get pointer (with optional range-checking) */
00294     const data_t *get_const_ptr(size_t i) const {
00295 #if O2SCL_NO_RANGE_CHECK
00296 #else
00297       if (i>=vparent_t::size) {
00298         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00299                    +" in ovector_const_reverse_tlate::get_const_ptr(). Size: "+
00300                    itos(vparent_t::size)+
00301                    " (index should be less than size).").c_str(),gsl_eindex);
00302         return (const data_t *)vparent_t::data;
00303       }
00304 #endif
00305       return (const data_t *)(vparent_t::data+
00306                               (vparent_t::size-1-i)*vparent_t::stride);
00307     }
00308 
00309   };
00310 
00311   /** \brief Reversed view of a subvector
00312 
00313       \warning At present, reversing a reversed vector does not give
00314       the original ordering.
00315   */
00316   template<class data_t, class vparent_t, class block_t> 
00317     class ovector_subvector_reverse_tlate : 
00318   public ovector_base_tlate<data_t,vparent_t,block_t> {
00319   public:
00320     /** \brief Create a vector from \c dat with size \c n and stride \c s 
00321      */
00322     ovector_subvector_reverse_tlate
00323       (ovector_base_tlate<data_t,vparent_t,block_t> &v, size_t offset, 
00324        size_t n) {
00325       vparent_t::data=0;
00326       vparent_t::size=0;
00327       vparent_t::stride=0;
00328       if (offset+n-1<v.size()) {
00329         vparent_t::block=0;
00330         vparent_t::data=v.data+offset*v.stride();
00331         vparent_t::size=n;
00332         vparent_t::stride=v.stride();
00333         vparent_t::owner=0;
00334       } else {
00335         O2SCL_ERR("Failed in ovector_sub_reverse() constructor.",gsl_einval);
00336       }
00337     }
00338 
00339     /// \name Get and set methods
00340     //@{
00341     /** \brief Array-like indexing 
00342     */
00343     data_t &operator[](size_t i) {
00344 #if O2SCL_NO_RANGE_CHECK
00345 #else
00346       if (i>=vparent_t::size) {
00347         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00348                    +" in ovector_subvector_reverse_tlate::operator[]. Size: "+
00349                    itos(vparent_t::size)+
00350                    " (index should be less than size).").c_str(),gsl_eindex);
00351         return vparent_t::data[0];
00352       }
00353 #endif
00354       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00355     }
00356     
00357     /** \brief Array-like indexing 
00358     */
00359     const data_t &operator[](size_t i) const {
00360 #if O2SCL_NO_RANGE_CHECK
00361 #else
00362       if (i>=vparent_t::size) {
00363         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00364                    +" in ovector_subvector_reverse_tlate::operator[]. Size: "+
00365                    itos(vparent_t::size)+
00366                    " (index should be less than size).").c_str(),gsl_eindex);
00367         return vparent_t::data[0];
00368       }
00369 #endif
00370       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00371     }
00372     
00373     /** \brief Array-like indexing 
00374     */
00375     data_t &operator()(size_t i) {
00376 #if O2SCL_NO_RANGE_CHECK
00377 #else
00378       if (i>=vparent_t::size) {
00379         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00380                    +" in ovector_subvector_reverse_tlate::operator(). Size: "+
00381                    itos(vparent_t::size)+
00382                    " (index should be less than size).").c_str(),gsl_eindex);
00383         return vparent_t::data[0];
00384       }
00385 #endif
00386       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00387     }
00388     
00389     /** \brief Array-like indexing 
00390     */
00391     const data_t &operator()(size_t i) const {
00392 #if O2SCL_NO_RANGE_CHECK
00393 #else
00394       if (i>=vparent_t::size) {
00395         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00396                    +" in ovector_subvector_reverse_tlate::operator(). Size: "+
00397                    itos(vparent_t::size)+
00398                    " (index should be less than size).").c_str(),gsl_eindex);
00399         return vparent_t::data[0];
00400       }
00401 #endif
00402       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00403     }
00404     
00405     /** \brief Get (with optional range-checking) */
00406     data_t get(size_t i) const {
00407 #if O2SCL_NO_RANGE_CHECK
00408 #else
00409       if (i>=vparent_t::size) {
00410         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00411                    +" in ovector_subvector_reverse_tlate::get(). Size: "+
00412                    itos(vparent_t::size)+
00413                    " (index should be less than size).").c_str(),gsl_eindex);
00414         return vparent_t::data[0];
00415       }
00416 #endif
00417       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00418     }
00419     
00420     /** \brief Get pointer (with optional range-checking) */
00421     data_t *get_ptr(size_t i) {
00422 #if O2SCL_NO_RANGE_CHECK
00423 #else
00424       if (i>=vparent_t::size) {
00425         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"
00426                    +" in ovector_subvector_reverse_tlate::get_ptr(). Size: "+
00427                    itos(vparent_t::size)+
00428                    " (index should be less than size).").c_str(),gsl_eindex);
00429         return vparent_t::data;
00430       }
00431 #endif
00432       return vparent_t::data+(vparent_t::size-1-i)*vparent_t::stride;
00433     }
00434     
00435     /** \brief Get pointer (with optional range-checking) */
00436     const data_t *get_const_ptr(size_t i) const {
00437 #if O2SCL_NO_RANGE_CHECK
00438 #else
00439       if (i>=vparent_t::size) {
00440         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds in "
00441                    +"ovector_subvector_reverse_tlate::get_const_ptr(). Size: "+
00442                    itos(vparent_t::size)+
00443                    " (index should be less than size).").c_str(),gsl_eindex);
00444         return (const data_t *)vparent_t::data;
00445       }
00446 #endif
00447       return (const data_t *)(vparent_t::data+
00448                               (vparent_t::size-1-i)*vparent_t::stride);
00449     }
00450     
00451     /** \brief Set (with optional range-checking) */
00452     int set(size_t i, data_t val) {
00453 #if O2SCL_NO_RANGE_CHECK
00454 #else
00455       if (i>=vparent_t::size) {
00456         O2SCL_ERR_RET((((std::string)"Array index ")+itos(i)+" out of bounds "
00457                        +" in ovector_subvector_reverse_tlate::"+
00458                        "get_const_ptr(). Size: "+itos(vparent_t::size)+
00459                        " (index should be less than size).").c_str(),
00460                       gsl_eindex);
00461       }
00462 #endif
00463       vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride]=val;
00464       return 0;
00465     }
00466 
00467     /** \brief Set all of the value to be the value \c val */
00468     int set_all(double val) {
00469       for(size_t i=0;i<vparent_t::size;i++) {
00470         vparent_t::data[i*vparent_t::stride]=val;
00471       }
00472       return 0;
00473     }
00474 
00475   };
00476 
00477   /** \brief Reversed view of a const subvector
00478       
00479       \warning At present, reversing a reversed vector does not give
00480       the original ordering.
00481   */
00482   template<class data_t, class vparent_t, class block_t> 
00483     class ovector_const_subvector_reverse_tlate : 
00484   public ovector_const_view_tlate<data_t,vparent_t,block_t> {
00485 
00486   public:
00487 
00488     /** \brief Create a vector from \c dat with size \c n and stride \c s 
00489      */
00490     ovector_const_subvector_reverse_tlate
00491       (const ovector_const_view_tlate<data_t,vparent_t,block_t> &v, 
00492        size_t offset,
00493        size_t n) {
00494       if (offset+n-1<v.size()) {
00495         vparent_t::block=0;
00496         vparent_t::data=v.data+offset*v.stride();
00497         vparent_t::size=n;
00498         vparent_t::stride=v.stride();
00499         vparent_t::owner=0;
00500       } else {
00501         O2SCL_ERR("Subvector failed in ovector_sub_reverse().",gsl_einval);
00502       }
00503     }
00504 
00505     /// \name Get and set methods
00506     //@{
00507     /** \brief Array-like indexing 
00508     */
00509     const data_t &operator[](size_t i) const {
00510 #if O2SCL_NO_RANGE_CHECK
00511 #else
00512       if (i>=vparent_t::size) {
00513         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"+
00514                    " in ovector_const_subvector_reverse_tlate::operator[]."+
00515                    " Size: "+itos(vparent_t::size)+
00516                    " (index should be less than size).").c_str(),gsl_eindex);
00517         return vparent_t::data[0];
00518       }
00519 #endif
00520       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00521     }
00522     
00523     /** \brief Array-like indexing 
00524     */
00525     const data_t &operator()(size_t i) const {
00526 #if O2SCL_NO_RANGE_CHECK
00527 #else
00528       if (i>=vparent_t::size) {
00529         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"+
00530                    " in ovector_const_subvector_reverse_tlate::operator()."+
00531                    " Size: "+itos(vparent_t::size)+
00532                    " (index should be less than size).").c_str(),gsl_eindex);
00533         return vparent_t::data[0];
00534       }
00535 #endif
00536       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00537     }
00538     
00539     /** \brief Get (with optional range-checking) */
00540     data_t get(size_t i) const {
00541 #if O2SCL_NO_RANGE_CHECK
00542 #else
00543       if (i>=vparent_t::size) {
00544         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds"+
00545                    " in ovector_const_subvector_reverse_tlate::get()."+
00546                    " Size: "+itos(vparent_t::size)+
00547                    " (index should be less than size).").c_str(),gsl_eindex);
00548         return vparent_t::data[0];
00549       }
00550 #endif
00551       return vparent_t::data[(vparent_t::size-1-i)*vparent_t::stride];
00552     }
00553     
00554     /** \brief Get pointer (with optional range-checking) */
00555     const data_t *get_const_ptr(size_t i) const {
00556 #if O2SCL_NO_RANGE_CHECK
00557 #else
00558       if (i>=vparent_t::size) {
00559         O2SCL_ERR((((std::string)"Array index ")+itos(i)+" out of bounds in "+
00560                    "ovector_const_subvector_reverse_tlate::get_const_ptr()."+
00561                    " Size: "+itos(vparent_t::size)+
00562                    " (index should be less than size).").c_str(),gsl_eindex);
00563         return (const data_t *)vparent_t::data;
00564       }
00565 #endif
00566       return (const data_t *)(vparent_t::data+
00567                               (vparent_t::size-1-i)*vparent_t::stride);
00568     }
00569     
00570   };
00571 
00572   /// ovector_reverse typedef
00573   typedef ovector_reverse_tlate<double,gsl_vector_norm,gsl_block> 
00574     ovector_reverse;
00575   /// ovector_const_reverse typedef
00576   typedef ovector_const_reverse_tlate<double,gsl_vector_norm,gsl_block> 
00577     ovector_const_reverse;
00578   /// ovector_subvector_reverse typedef
00579   typedef ovector_subvector_reverse_tlate<double,gsl_vector_norm,gsl_block> 
00580     ovector_subvector_reverse;
00581   /// ovector_const_subvector_reverse typedef
00582   typedef ovector_const_subvector_reverse_tlate<double,gsl_vector_norm,
00583     gsl_block> ovector_const_subvector_reverse;
00584   
00585 
00586   /// ovector_int_reverse typedef
00587   typedef ovector_reverse_tlate<int,gsl_vector_int,gsl_block_int> 
00588     ovector_int_reverse;
00589   /// ovector_int_const_reverse typedef
00590   typedef ovector_const_reverse_tlate<int,gsl_vector_int,gsl_block_int> 
00591     ovector_int_const_reverse;
00592   /// ovector_int_subvector_reverse typedef
00593   typedef ovector_subvector_reverse_tlate<int,gsl_vector_int,gsl_block_int> 
00594     ovector_int_subvector_reverse;
00595   /// ovector_int_const_subvector_reverse typedef
00596   typedef ovector_const_subvector_reverse_tlate<int,gsl_vector_int,
00597     gsl_block_int> ovector_int_const_subvector_reverse;
00598 
00599 
00600 #ifndef DOXYGENP
00601 }
00602 #endif
00603 
00604 #endif
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Documentation generated with Doxygen. Provided under the GNU Free Documentation License (see License Information).

Get Object-oriented Scientific Computing
Lib at SourceForge.net. Fast, secure and Free Open Source software
downloads.