odeiv2.hpp

Go to the documentation of this file.

/*
 * $Id: odeiv2.hpp 293 2012-12-17 20:27:36Z jdl3 $
 * Copyright (C) 2012, 2020 John D Lamb
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
#ifndef CCGSL_ODEIV2_HPP
#define CCGSL_ODEIV2_HPP
 
#include<new>
#include<string>
#include"odeiv2_system.hpp"
 
namespace gsl {
  namespace odeiv2 {
    class driver;
    class step {
    public:
      typedef gsl_odeiv2_step_type type;
      step(){
    ccgsl_pointer = 0;
    count = 0; // initially nullptr will do
      }
      // Refines random access container
      // Refines assignable
      step( step::type const* T, size_t dim ){
    ccgsl_pointer = gsl_odeiv2_step_alloc( T, dim );
    // just plausibly we could allocate step but not count
    try { count = new size_t; } catch( std::bad_alloc& e ){
      // try to tidy up before rethrowing
      gsl_odeiv2_step_free( ccgsl_pointer );
      throw e;
    }
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      explicit step( gsl_odeiv2_step* v ){
    ccgsl_pointer = v;
    // just plausibly we could fail to allocate count: no further action needed.
    count = new size_t;
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      // copy constructor
      step( step const& v ){ ccgsl_pointer = v.ccgsl_pointer;
    count = v.count; if( count != 0 ) ++*count; }
      // assignment operator
      step& operator=( step const& v ){
    // first, possibly delete anything pointed to by this
    if( count == 0 or --*count == 0 ){
      if( ccgsl_pointer != 0 ) gsl_odeiv2_step_free( ccgsl_pointer );
      delete count;
    } // Then copy
    ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
      }
      // destructor
      ~step(){
    if( count == 0 or --*count == 0 ){
      // could have allocated null pointer
      if( ccgsl_pointer != 0 ) gsl_odeiv2_step_free( ccgsl_pointer );
      delete count;
    }
      }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    step( step&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    step& operator=( step&& v ){
      step( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
      // Refines equality comparable
      // == operator
      bool operator==( step const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
      // != operator
      bool operator!=( step const& v ) const { return not operator==( v ); }
      // Refines forward container
      // Refines less than comparable
      // operator<
      bool operator<( step const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
      // operator>
      bool operator>( step const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
      // operator<=
      bool operator<=( step const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
      // operator>=
      bool operator>=( step const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
      bool empty() const { return ccgsl_pointer == 0; }
      // swap() --- should work even if sizes don't match
      void swap( step& v ){
    std::swap( ccgsl_pointer, v.ccgsl_pointer );
    std::swap( count, v.count );
      }
    private:
      gsl_odeiv2_step* ccgsl_pointer;
      size_t* count;
    public:
      // shared reference functions
      gsl_odeiv2_step* get() const { return ccgsl_pointer; }
      bool unique() const { return count != 0 and *count == 1; }
      size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
#endif
      operator bool() const { return ccgsl_pointer != 0; }
 
      // Step-specific functions
      int reset(){ return gsl_odeiv2_step_reset( get() ); }
      char const* name() const { return gsl_odeiv2_step_name( get() ); }
      unsigned int order(){ return gsl_odeiv2_step_order( get() ); }
#ifndef DOXYGEN_SKIP
      int apply( double t, double h, double y[], double yerr[], double const dydt_in[],
         double dydt_out[], system const* sys ){
    return gsl_odeiv2_step_apply( get(), t, h, y, yerr, dydt_in, dydt_out, sys ); }
#endif // DOXYGEN_SKIP
#ifndef DOXYGEN_SKIP
      template<typename Y,typename YERR>
      int apply( double t, double h, Y& y, YERR& yerr, double const dydt_in[],
         double dydt_out[], system const* sys ){
    return gsl_odeiv2_step_apply( get(), t, h, y.data(), yerr.data(),
                      dydt_in, dydt_out, sys ); }
      template<typename Y,typename YERR,typename DYDT_IN>
      int apply( double t, double h, Y& y, YERR& yerr, DYDT_IN const& dydt_in,
         double dydt_out[], system const* sys ){
    return gsl_odeiv2_step_apply( get(), t, h, y.data(), yerr.data(),
                      dydt_in.data(), dydt_out, sys ); }
      template<typename Y,typename YERR,typename DYDT_OUT>
      int apply( double t, double h, Y& y, YERR& yerr, double const dydt_in[],
         DYDT_OUT& dydt_out, system const& sys ){
    return gsl_odeiv2_step_apply( get(), t, h, y.data, yerr.data,
                      dydt_in, dydt_out.data(), &sys ); }
#endif
      template<typename Y,typename YERR,typename DYDT_IN,typename DYDT_OUT>
      int apply( double t, double h, Y& y, YERR& yerr, DYDT_IN const& dydt_in,
         DYDT_OUT dydt_out, system const& sys ){
    return gsl_odeiv2_step_apply( get(), t, h, y.data(), yerr.data(),
                      dydt_in.data(), dydt_out.data(), &sys ); }
      int set_driver( driver const& d );//{ return gsl_odeiv2_step_set_driver( get(), d.get() ); }
 
      // Step types
      inline static type const* rk2(){ return gsl_odeiv2_step_rk2; }
      inline static type const* rk4(){ return gsl_odeiv2_step_rk4; }
      inline static type const* rkf45(){ return gsl_odeiv2_step_rkf45; }
      inline static type const* rkck(){ return gsl_odeiv2_step_rkck; }
      inline static type const* rk8pd(){ return gsl_odeiv2_step_rk8pd; }
      inline static type const* rk2imp(){ return gsl_odeiv2_step_rk2imp; }
      inline static type const* rk4imp(){ return gsl_odeiv2_step_rk4imp; }
      inline static type const* bsimp(){ return gsl_odeiv2_step_bsimp; }
      inline static type const* rk1imp(){ return gsl_odeiv2_step_rk1imp; }
      inline static type const* msadams(){ return gsl_odeiv2_step_msadams; }
      inline static type const* msbdf(){ return gsl_odeiv2_step_msbdf; }
    };
 
    class control {
    public:
      typedef gsl_odeiv2_control_type type;
      control(){
    ccgsl_pointer = 0;
    count = 0; // initially nullptr will do
      }
      // Refines random access container
      // Refines assignable
      explicit control( type const* T ){
    ccgsl_pointer = gsl_odeiv2_control_alloc( T );
    // just plausibly we could allocate control but not count
    try { count = new size_t; } catch( std::bad_alloc& e ){
      // try to tidy up before rethrowing
      gsl_odeiv2_control_free( ccgsl_pointer );
      throw e;
    }
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      explicit control( gsl_odeiv2_control* v ){
    ccgsl_pointer = v;
    // just plausibly we could fail to allocate count: no further action needed.
    count = new size_t;
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      // copy constructor
      control( control const& v ){ ccgsl_pointer = v.ccgsl_pointer;
    count = v.count; if( count != 0 ) ++*count; }
      // assignment operator
      control& operator=( control const& v ){
    // first, possibly delete anything pointed to by this
    if( count == 0 or --*count == 0 ){
      if( ccgsl_pointer != 0 ) gsl_odeiv2_control_free( ccgsl_pointer );
      delete count;
    } // Then copy
    ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
      }
      // destructor
      ~control(){
    if( count == 0 or --*count == 0 ){
      // could have allocated null pointer
      if( ccgsl_pointer != 0 ) gsl_odeiv2_control_free( ccgsl_pointer );
      delete count;
    }
      }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    control( control&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    control& operator=( control&& v ){
      control( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
      // Refines equality comparable
      // == operator
      bool operator==( control const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
      // != operator
      bool operator!=( control const& v ) const { return not operator==( v ); }
      // Refines forward container
      // Refines less than comparable
      // operator<
      bool operator<( control const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
      // operator>
      bool operator>( control const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
      // operator<=
      bool operator<=( control const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
      // operator>=
      bool operator>=( control const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
      bool empty() const { return ccgsl_pointer == 0; }
      // swap() --- should work even if sizes don't match
      void swap( control& v ){
    std::swap( ccgsl_pointer, v.ccgsl_pointer );
    std::swap( count, v.count );
      }
    private:
      gsl_odeiv2_control* ccgsl_pointer;
      size_t* count;
    public:
      // shared reference functions
      gsl_odeiv2_control* get() const { return ccgsl_pointer; }
      bool unique() const { return count != 0 and *count == 1; }
      size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
#endif
      operator bool() const { return ccgsl_pointer != 0; }
 
      // Extra functions
      int init( double eps_abs, double eps_rel, double a_y, double a_dydt ){
    return gsl_odeiv2_control_init( get(), eps_abs, eps_rel, a_y, a_dydt ); }
 
      int hadjust( step& s, double const y[], double const yerr[],
           double const dydt[], double* h ){
    return gsl_odeiv2_control_hadjust( get(), s.get(), y, yerr, dydt, h ); }
      template<typename Y,typename YERR,typename DYDT>
      int hadjust( step& s, Y const& y, YERR const& yerr, DYDT const& dydt, double& h ){
    return gsl_odeiv2_control_hadjust( get(), s.get(), y.data(), yerr.data(), dydt.data(),
                       &h ); }
 
      char const* name() const { return gsl_odeiv2_control_name( get() ); }
 
#ifndef DOXYGEN_SKIP
      int errlevel( double const y, double const dydt, double const h,
            size_t const ind, double* errlev ){
    return gsl_odeiv2_control_errlevel( get(), y, dydt, h, ind, errlev ); }
#endif // DOXYGEN_SKIP
      int errlevel( double const y, double const dydt, double const h,
            size_t const ind, double& errlev ){
    return gsl_odeiv2_control_errlevel( get(), y, dydt, h, ind, &errlev ); }
 
      int set_driver( driver const& d );
      //{ return gsl_odeiv2_control_set_driver( get(), d.get() ); } 
 
      inline static control standard_new( double eps_abs, double eps_rel,
                      double a_y, double a_dydt ){
    return control( gsl_odeiv2_control_standard_new( eps_abs, eps_rel, a_y, a_dydt ) ); }
 
      inline static control y_new( double eps_abs, double eps_rel ){
    return control( gsl_odeiv2_control_y_new( eps_abs, eps_rel ) ); }
 
      inline static control yp_new( double eps_abs, double eps_rel ){
    return control( gsl_odeiv2_control_yp_new( eps_abs, eps_rel ) ); }
 
#ifndef DOXYGEN_SKIP
      inline static control scaled_new( double eps_abs, double eps_rel, double a_y,
                    double a_dydt, double const scale_abs[], size_t dim ){
    return control( gsl_odeiv2_control_scaled_new( eps_abs, eps_rel, a_y, a_dydt,
                               scale_abs, dim ) ); }
#endif // DOXYGEN_SKIP
      template<typename SCALE_ABS>
      inline static control scaled_new( double eps_abs, double eps_rel, double a_y,
                    double a_dydt, SCALE_ABS const& scale_abs ){
    return control( gsl_odeiv2_control_scaled_new( eps_abs, eps_rel, a_y, a_dydt,
                               scale_abs.data(), scale_abs.size() ) ); }
    };
 
    class evolve {
    public:
      evolve(){
    ccgsl_pointer = 0;
    count = 0; // initially nullptr will do
      }
      // Refines random access container
      // Refines assignable
      explicit evolve( size_t const dim ){
    ccgsl_pointer = gsl_odeiv2_evolve_alloc( dim );
    // just plausibly we could allocate evolve but not count
    try { count = new size_t; } catch( std::bad_alloc& e ){
      // try to tidy up before rethrowing
      gsl_odeiv2_evolve_free( ccgsl_pointer );
      throw e;
    }
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      explicit evolve( gsl_odeiv2_evolve* v ){
    ccgsl_pointer = v;
    // just plausibly we could fail to allocate count: no further action needed.
    count = new size_t;
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      // copy constructor
      evolve( evolve const& v ){ ccgsl_pointer = v.ccgsl_pointer;
    count = v.count; if( count != 0 ) ++*count; }
      // assignment operator
      evolve& operator=( evolve const& v ){
    // first, possibly delete anything pointed to by this
    if( count == 0 or --*count == 0 ){
      if( ccgsl_pointer != 0 ) gsl_odeiv2_evolve_free( ccgsl_pointer );
      delete count;
    } // Then copy
    ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
      }
      // destructor
      ~evolve(){
    if( count == 0 or --*count == 0 ){
      // could have allocated null pointer
      if( ccgsl_pointer != 0 ) gsl_odeiv2_evolve_free( ccgsl_pointer );
      delete count;
    }
      }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    evolve( evolve&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    evolve& operator=( evolve&& v ){
      evolve( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
      // Refines equality comparable
      // == operator
      bool operator==( evolve const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
      // != operator
      bool operator!=( evolve const& v ) const { return not operator==( v ); }
      // Refines forward container
      // Refines less than comparable
      // operator<
      bool operator<( evolve const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
      // operator>
      bool operator>( evolve const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
      // operator<=
      bool operator<=( evolve const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
      // operator>=
      bool operator>=( evolve const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
      bool empty() const { return ccgsl_pointer == 0; }
      // swap() --- should work even if sizes don't match
      void swap( evolve& v ){
    std::swap( ccgsl_pointer, v.ccgsl_pointer );
    std::swap( count, v.count );
      }
    private:
      gsl_odeiv2_evolve* ccgsl_pointer;
      size_t* count;
    public:
      // shared reference functions
      gsl_odeiv2_evolve* get() const { return ccgsl_pointer; }
      bool unique() const { return count != 0 and *count == 1; }
      size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
#endif
      operator bool() const { return ccgsl_pointer != 0; }
      
      // extra functions
 
#ifndef DOXYGEN_SKIP
      int apply( control& con, step& step, system const* dydt,
         double* t, double t1, double* h, double y[] ){
    return gsl_odeiv2_evolve_apply( get(), con.get(), step.get(), dydt,
                    t, t1, h, y ); }
#endif // DOXYGEN_SKIP
      template<typename Y>
      int apply( control& con, step& step, system const& dydt,
         double& t, double t1, double& h, Y& y ){
    return gsl_odeiv2_evolve_apply( get(), con.get(), step.get(), &dydt,
                    &t, t1, &h, y.data() ); }
 
#ifndef DOXYGEN_SKIP
      int apply_fixed_step( control& con, step& step, system const* dydt,
                double* t, double const h0, double y[] ){
    return gsl_odeiv2_evolve_apply_fixed_step( get(), con.get(), step.get(), dydt,
                           t, h0, y ); }
#endif // DOXYGEN_SKIP
      template<typename Y>
      int apply_fixed_step( control& con, step& step, system const& dydt,
                double& t, double const h0, Y& y ){
    return gsl_odeiv2_evolve_apply_fixed_step( get(), con.get(), step.get(), &dydt,
                           &t, h0, y.data() ); }
 
      int reset(){ return gsl_odeiv2_evolve_reset( get() ); }
 
      int set_driver( driver const& d );
      //{ return gsl_odeiv2_evolve_set_driver( get(), d.get() ); }
    };
    
    class driver {
    public:
      driver(){
    ccgsl_pointer = 0;
    count = 0; // initially nullptr will do
      }
      // Refines random access container
      // Refines assignable
      explicit driver( gsl_odeiv2_driver* v ){
    ccgsl_pointer = v;
    // just plausibly we could fail to allocate count: no further action needed.
    count = new size_t;
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      // copy constructor
      driver( driver const& v ){ ccgsl_pointer = v.ccgsl_pointer;
    count = v.count; if( count != 0 ) ++*count; }
      // assignment operator
      driver& operator=( driver const& v ){
    // first, possibly delete anything pointed to by this
    if( count == 0 or --*count == 0 ){
      if( ccgsl_pointer != 0 ) gsl_odeiv2_driver_free( ccgsl_pointer );
      delete count;
    } // Then copy
    ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
      }
      // destructor
      ~driver(){
    if( count == 0 or --*count == 0 ){
      // could have allocated null pointer
      if( ccgsl_pointer != 0 ) gsl_odeiv2_driver_free( ccgsl_pointer );
      delete count;
    }
      }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    driver( driver&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    driver& operator=( driver&& v ){
      driver( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
      // Refines equality comparable
      // == operator
      bool operator==( driver const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
      // != operator
      bool operator!=( driver const& v ) const { return not operator==( v ); }
      // Refines forward container
      // Refines less than comparable
      // operator<
      bool operator<( driver const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
      // operator>
      bool operator>( driver const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
      // operator<=
      bool operator<=( driver const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
      // operator>=
      bool operator>=( driver const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
      bool empty() const { return ccgsl_pointer == 0; }
      // swap() --- should work even if sizes don't match
      void swap( driver& v ){
    std::swap( ccgsl_pointer, v.ccgsl_pointer );
    std::swap( count, v.count );
      }
    private:
      gsl_odeiv2_driver* ccgsl_pointer;
      size_t* count;
    public:
      // shared reference functions
      gsl_odeiv2_driver* get() const { return ccgsl_pointer; }
      bool unique() const { return count != 0 and *count == 1; }
      size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
#endif
      operator bool() const { return ccgsl_pointer != 0; }
 
      // Extra functions
 
      inline static driver y_new( system const* sys, step::type const* T,
                  double const hstart, double const epsabs, double const epsrel ){
    return driver( gsl_odeiv2_driver_alloc_y_new( sys, T, hstart, epsabs, epsrel ) ); }
 
      inline static driver
      yp_new( system const* sys, step::type const* T,
          double const hstart, double const epsabs, double const epsrel ){
      return driver( gsl_odeiv2_driver_alloc_yp_new( sys, T, hstart, epsabs, epsrel ) ); }
 
#ifndef DOXYGEN_SKIP
      inline static driver
      scaled_new( system const& sys, step::type const* T, double const hstart,
          double const epsabs,
          double const epsrel, double const a_y, double const a_dydt,
          double const scale_abs[] ){
    return driver( gsl_odeiv2_driver_alloc_scaled_new( &sys, T, hstart, epsabs, epsrel,
                               a_y, a_dydt, scale_abs ) ); }
#endif // DOXYGEN_SKIP
      template<typename SCALE_ABS>
      inline static driver
      scaled_new( system const& sys, step::type const* T, double const hstart,
          double const epsabs,
          double const epsrel, double const a_y, double const a_dydt,
          SCALE_ABS const& scale_abs ){
    return driver( gsl_odeiv2_driver_alloc_scaled_new( &sys, T, hstart, epsabs, epsrel,
                               a_y, a_dydt, scale_abs.data() ) ); }
 
      inline static driver
      standard_new( system const& sys, step::type const* T, double const hstart,
            double const epsabs,
            double const epsrel, double const a_y, double const a_dydt ){
    return driver( gsl_odeiv2_driver_alloc_standard_new( &sys, T, hstart, epsabs,
                                 epsrel, a_y, a_dydt ) ); }
 
      int set_hmin( double const hmin ){ return gsl_odeiv2_driver_set_hmin( get(), hmin ); }
 
      int set_hmax( double const hmax ){ return gsl_odeiv2_driver_set_hmax( get(), hmax ); }
 
      int set_nmax( unsigned long int const nmax ){
    return gsl_odeiv2_driver_set_nmax( get(), nmax ); }
 
#ifndef DOXYGEN_SKIP
      int apply( double* t, double const t1, double y[] ){
    return gsl_odeiv2_driver_apply( get(), t, t1, y ); }
#endif // DOXYGEN_SKIP
      template<typename Y>
      int apply( double& t, double const t1, Y& y ){
    return gsl_odeiv2_driver_apply( get(), &t, t1, y.data() ); }
 
#ifndef DOXYGEN_SKIP
      int apply_fixed_step( double* t, double const h, unsigned long int const n, double y[] ){
    return gsl_odeiv2_driver_apply_fixed_step( get(), t, h, n, y ); }
#endif // DOXYGEN_SKIP
      template<typename Y>
      int apply_fixed_step( double& t, double const h, unsigned long int const n, Y& y ){
    return gsl_odeiv2_driver_apply_fixed_step( get(), &t, h, n, y.data() ); }
 
      int reset(){ return gsl_odeiv2_driver_reset( get() ); }
 
    };
    
    inline int step::set_driver( driver const& d ){
      return gsl_odeiv2_step_set_driver( get(), d.get() ); }
    inline int control::set_driver( driver const& d ){
      return gsl_odeiv2_control_set_driver( get(), d.get() ); } 
    inline int evolve::set_driver( driver const& d ){
      return gsl_odeiv2_evolve_set_driver( get(), d.get() ); } 
  }
}
#endif