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