monte.hpp

Go to the documentation of this file.

/*
 * $Id$
 * Copyright (C) 2010, 2011, 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_MONTE_HPP
#define CCGSL_MONTE_HPP
 
#include<gsl/gsl_monte.h>
#include"vector.hpp"
#include"rng.hpp"
 
namespace gsl {
  namespace monte {
    class function : public gsl_monte_function {
#ifndef DOXYGEN_SKIP
    private:
      struct base_F {
        typedef double (*function_t)(double*,size_t,void*);
    virtual ~base_F(){};
        virtual function_t function() = 0;
      };
      class Fuvcr : public base_F {
      public:
        Fuvcr( double (*const f)(gsl::vector const&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double (*const f)(gsl::vector const&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          Fuvcr* ft = reinterpret_cast<Fuvcr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FuvCr : public base_F {
      public:
        FuvCr( double (*const f)(gsl::vector const volatile&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double (*const f)(gsl::vector const volatile&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FuvCr* ft = reinterpret_cast<FuvCr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class Fcvcr : public base_F {
      public:
        Fcvcr( double const (*const f)(gsl::vector const&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double const (*const f)(gsl::vector const&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          Fcvcr* ft = reinterpret_cast<Fcvcr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FcvCr : public base_F {
      public:
        FcvCr( double const (*const f)(gsl::vector const volatile&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double const (*const f)(gsl::vector const volatile&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FcvCr* ft = reinterpret_cast<FcvCr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class Furcr : public base_F {
      public:
        Furcr( double& (*const f)(gsl::vector const&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double& (*const f)(gsl::vector const&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          Furcr* ft = reinterpret_cast<Furcr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FurCr : public base_F {
      public:
        FurCr( double& (*const f)(gsl::vector const volatile&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double& (*const f)(gsl::vector const volatile&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FurCr* ft = reinterpret_cast<FurCr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class Fcrcr : public base_F {
      public:
        Fcrcr( double const& (*const f)(gsl::vector const&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double const& (*const f)(gsl::vector const&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          Fcrcr* ft = reinterpret_cast<Fcrcr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FcrCr : public base_F {
      public:
        FcrCr( double const& (*const f)(gsl::vector const volatile&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double const& (*const f)(gsl::vector const volatile&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FcrCr* ft = reinterpret_cast<FcrCr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FVrcr : public base_F {
      public:
        FVrcr( double volatile& (*const f)(gsl::vector const&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double volatile& (*const f)(gsl::vector const&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FVrcr* ft = reinterpret_cast<FVrcr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FVrCr : public base_F {
      public:
        FVrCr( double volatile& (*const f)(gsl::vector const volatile&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double volatile& (*const f)(gsl::vector const volatile&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FVrCr* ft = reinterpret_cast<FVrCr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FCrcr : public base_F {
      public:
        FCrcr( double const volatile& (*const f)(gsl::vector const&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double const volatile& (*const f)(gsl::vector const&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FCrcr* ft = reinterpret_cast<FCrcr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      class FCrCr : public base_F {
      public:
        FCrCr( double const volatile& (*const f)(gsl::vector const volatile&), size_t const dim ) : f( f ), xv( dim ){}
        function_t function(){ return &fn; }
      private:
        double const volatile& (*const f)(gsl::vector const volatile&);
        gsl::vector xv;
        static double fn( double* x, size_t dim, void* params ){
          FCrCr* ft = reinterpret_cast<FCrCr*>( params );
          if( dim != ft->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(ft->xv.get()->data, x);
          double result = ft->f( ft->xv );
          std::swap(ft->xv.get()->data, x);
          return result;
        }
      };
      template<typename T>
      class Fuvcru : public base_F {
      public:
        Fuvcru( T& c, double (T::*f)(gsl::vector const&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Fuvcru<T>* const cl = reinterpret_cast<Fuvcru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const&);
      };
      template<typename T>
      class FuvCru : public base_F {
      public:
        FuvCru( T& c, double (T::*f)(gsl::vector const volatile&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FuvCru<T>* const cl = reinterpret_cast<FuvCru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const volatile&);
      };
      template<typename T>
      class Fcvcru : public base_F {
      public:
        Fcvcru( T& c, double const (T::*f)(gsl::vector const&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Fcvcru<T>* const cl = reinterpret_cast<Fcvcru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const&);
      };
      template<typename T>
      class FcvCru : public base_F {
      public:
        FcvCru( T& c, double const (T::*f)(gsl::vector const volatile&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcvCru<T>* const cl = reinterpret_cast<FcvCru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const volatile&);
      };
      template<typename T>
      class Furcru : public base_F {
      public:
        Furcru( T& c, double& (T::*f)(gsl::vector const&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Furcru<T>* const cl = reinterpret_cast<Furcru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const&);
      };
      template<typename T>
      class FurCru : public base_F {
      public:
        FurCru( T& c, double& (T::*f)(gsl::vector const volatile&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FurCru<T>* const cl = reinterpret_cast<FurCru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const volatile&);
      };
      template<typename T>
      class Fcrcru : public base_F {
      public:
        Fcrcru( T& c, double const& (T::*f)(gsl::vector const&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Fcrcru<T>* const cl = reinterpret_cast<Fcrcru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const&);
      };
      template<typename T>
      class FcrCru : public base_F {
      public:
        FcrCru( T& c, double const& (T::*f)(gsl::vector const volatile&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcrCru<T>* const cl = reinterpret_cast<FcrCru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const volatile&);
      };
      template<typename T>
      class FVrcru : public base_F {
      public:
        FVrcru( T& c, double volatile& (T::*f)(gsl::vector const&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrcru<T>* const cl = reinterpret_cast<FVrcru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const&);
      };
      template<typename T>
      class FVrCru : public base_F {
      public:
        FVrCru( T& c, double volatile& (T::*f)(gsl::vector const volatile&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrCru<T>* const cl = reinterpret_cast<FVrCru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const volatile&);
      };
      template<typename T>
      class FCrcru : public base_F {
      public:
        FCrcru( T& c, double const volatile& (T::*f)(gsl::vector const&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrcru<T>* const cl = reinterpret_cast<FCrcru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const&);
      };
      template<typename T>
      class FCrCru : public base_F {
      public:
        FCrCru( T& c, double const volatile& (T::*f)(gsl::vector const volatile&), size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrCru<T>* const cl = reinterpret_cast<FCrCru<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const volatile&);
      };
      template<typename T>
      class Fuvcrc : public base_F {
      public:
        Fuvcrc( T& c, double (T::*f)(gsl::vector const&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Fuvcrc<T>* const cl = reinterpret_cast<Fuvcrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const&) const;
      };
      template<typename T>
      class FuvCrc : public base_F {
      public:
        FuvCrc( T& c, double (T::*f)(gsl::vector const volatile&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FuvCrc<T>* const cl = reinterpret_cast<FuvCrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const volatile&) const;
      };
      template<typename T>
      class Fcvcrc : public base_F {
      public:
        Fcvcrc( T& c, double const (T::*f)(gsl::vector const&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Fcvcrc<T>* const cl = reinterpret_cast<Fcvcrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const&) const;
      };
      template<typename T>
      class FcvCrc : public base_F {
      public:
        FcvCrc( T& c, double const (T::*f)(gsl::vector const volatile&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcvCrc<T>* const cl = reinterpret_cast<FcvCrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const volatile&) const;
      };
      template<typename T>
      class Furcrc : public base_F {
      public:
        Furcrc( T& c, double& (T::*f)(gsl::vector const&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Furcrc<T>* const cl = reinterpret_cast<Furcrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const&) const;
      };
      template<typename T>
      class FurCrc : public base_F {
      public:
        FurCrc( T& c, double& (T::*f)(gsl::vector const volatile&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FurCrc<T>* const cl = reinterpret_cast<FurCrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const volatile&) const;
      };
      template<typename T>
      class Fcrcrc : public base_F {
      public:
        Fcrcrc( T& c, double const& (T::*f)(gsl::vector const&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          Fcrcrc<T>* const cl = reinterpret_cast<Fcrcrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const&) const;
      };
      template<typename T>
      class FcrCrc : public base_F {
      public:
        FcrCrc( T& c, double const& (T::*f)(gsl::vector const volatile&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcrCrc<T>* const cl = reinterpret_cast<FcrCrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const volatile&) const;
      };
      template<typename T>
      class FVrcrc : public base_F {
      public:
        FVrcrc( T& c, double volatile& (T::*f)(gsl::vector const&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrcrc<T>* const cl = reinterpret_cast<FVrcrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const&) const;
      };
      template<typename T>
      class FVrCrc : public base_F {
      public:
        FVrCrc( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrCrc<T>* const cl = reinterpret_cast<FVrCrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const volatile&) const;
      };
      template<typename T>
      class FCrcrc : public base_F {
      public:
        FCrcrc( T& c, double const volatile& (T::*f)(gsl::vector const&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrcrc<T>* const cl = reinterpret_cast<FCrcrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const&) const;
      };
      template<typename T>
      class FCrCrc : public base_F {
      public:
        FCrCrc( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrCrc<T>* const cl = reinterpret_cast<FCrCrc<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const volatile&) const;
      };
      template<typename T>
      class FuvcrV : public base_F {
      public:
        FuvcrV( T& c, double (T::*f)(gsl::vector const&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FuvcrV<T>* const cl = reinterpret_cast<FuvcrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const&) volatile;
      };
      template<typename T>
      class FuvCrV : public base_F {
      public:
        FuvCrV( T& c, double (T::*f)(gsl::vector const volatile&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FuvCrV<T>* const cl = reinterpret_cast<FuvCrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const volatile&) volatile;
      };
      template<typename T>
      class FcvcrV : public base_F {
      public:
        FcvcrV( T& c, double const (T::*f)(gsl::vector const&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcvcrV<T>* const cl = reinterpret_cast<FcvcrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const&) volatile;
      };
      template<typename T>
      class FcvCrV : public base_F {
      public:
        FcvCrV( T& c, double const (T::*f)(gsl::vector const volatile&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcvCrV<T>* const cl = reinterpret_cast<FcvCrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const volatile&) volatile;
      };
      template<typename T>
      class FurcrV : public base_F {
      public:
        FurcrV( T& c, double& (T::*f)(gsl::vector const&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FurcrV<T>* const cl = reinterpret_cast<FurcrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const&) volatile;
      };
      template<typename T>
      class FurCrV : public base_F {
      public:
        FurCrV( T& c, double& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FurCrV<T>* const cl = reinterpret_cast<FurCrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const volatile&) volatile;
      };
      template<typename T>
      class FcrcrV : public base_F {
      public:
        FcrcrV( T& c, double const& (T::*f)(gsl::vector const&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcrcrV<T>* const cl = reinterpret_cast<FcrcrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const&) volatile;
      };
      template<typename T>
      class FcrCrV : public base_F {
      public:
        FcrCrV( T& c, double const& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcrCrV<T>* const cl = reinterpret_cast<FcrCrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const volatile&) volatile;
      };
      template<typename T>
      class FVrcrV : public base_F {
      public:
        FVrcrV( T& c, double volatile& (T::*f)(gsl::vector const&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrcrV<T>* const cl = reinterpret_cast<FVrcrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const&) volatile;
      };
      template<typename T>
      class FVrCrV : public base_F {
      public:
        FVrCrV( T& c, double volatile& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrCrV<T>* const cl = reinterpret_cast<FVrCrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const volatile&) volatile;
      };
      template<typename T>
      class FCrcrV : public base_F {
      public:
        FCrcrV( T& c, double const volatile& (T::*f)(gsl::vector const&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrcrV<T>* const cl = reinterpret_cast<FCrcrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const&) volatile;
      };
      template<typename T>
      class FCrCrV : public base_F {
      public:
        FCrCrV( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrCrV<T>* const cl = reinterpret_cast<FCrCrV<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const volatile&) volatile;
      };
      template<typename T>
      class FuvcrC : public base_F {
      public:
        FuvcrC( T& c, double (T::*f)(gsl::vector const&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FuvcrC<T>* const cl = reinterpret_cast<FuvcrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const&) const volatile;
      };
      template<typename T>
      class FuvCrC : public base_F {
      public:
        FuvCrC( T& c, double (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FuvCrC<T>* const cl = reinterpret_cast<FuvCrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double (T::*f)(gsl::vector const volatile&) const volatile;
      };
      template<typename T>
      class FcvcrC : public base_F {
      public:
        FcvcrC( T& c, double const (T::*f)(gsl::vector const&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcvcrC<T>* const cl = reinterpret_cast<FcvcrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const&) const volatile;
      };
      template<typename T>
      class FcvCrC : public base_F {
      public:
        FcvCrC( T& c, double const (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcvCrC<T>* const cl = reinterpret_cast<FcvCrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const (T::*f)(gsl::vector const volatile&) const volatile;
      };
      template<typename T>
      class FurcrC : public base_F {
      public:
        FurcrC( T& c, double& (T::*f)(gsl::vector const&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FurcrC<T>* const cl = reinterpret_cast<FurcrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const&) const volatile;
      };
      template<typename T>
      class FurCrC : public base_F {
      public:
        FurCrC( T& c, double& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FurCrC<T>* const cl = reinterpret_cast<FurCrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double& (T::*f)(gsl::vector const volatile&) const volatile;
      };
      template<typename T>
      class FcrcrC : public base_F {
      public:
        FcrcrC( T& c, double const& (T::*f)(gsl::vector const&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcrcrC<T>* const cl = reinterpret_cast<FcrcrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const&) const volatile;
      };
      template<typename T>
      class FcrCrC : public base_F {
      public:
        FcrCrC( T& c, double const& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FcrCrC<T>* const cl = reinterpret_cast<FcrCrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const& (T::*f)(gsl::vector const volatile&) const volatile;
      };
      template<typename T>
      class FVrcrC : public base_F {
      public:
        FVrcrC( T& c, double volatile& (T::*f)(gsl::vector const&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrcrC<T>* const cl = reinterpret_cast<FVrcrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const&) const volatile;
      };
      template<typename T>
      class FVrCrC : public base_F {
      public:
        FVrCrC( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FVrCrC<T>* const cl = reinterpret_cast<FVrCrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double volatile& (T::*f)(gsl::vector const volatile&) const volatile;
      };
      template<typename T>
      class FCrcrC : public base_F {
      public:
        FCrcrC( T& c, double const volatile& (T::*f)(gsl::vector const&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrcrC<T>* const cl = reinterpret_cast<FCrcrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const&) const volatile;
      };
      template<typename T>
      class FCrCrC : public base_F {
      public:
        FCrCrC( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim )
          : xv( dim ), c( c ), f( f ){}
        double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
        function_t function(){ return &function_s; }
      private:
        gsl::vector xv;
        static double function_s( double* x, size_t dim, void* params ){
          FCrCrC<T>* const cl = reinterpret_cast<FCrCrC<T>*>( params );
          if( dim != cl->xv.size() )
            GSL_ERROR( "Number of arguments and dim do not match.", GSL_EBADLEN );
          std::swap(cl->xv.get()->data,x);
          double result = (cl->c.*cl->f)( cl->xv );
          std::swap(cl->xv.get()->data,x);
          return result;
        }
        T& c;
        double const volatile& (T::*f)(gsl::vector const volatile&) const volatile;
      };
#endif
    base_F* base_f;
    size_t* count;
  public:
    function(){
      base_f = 0;
      f = 0;
      dim = 0;
      params = 0;
      count = 0; // initially nullptr will do
    }
      explicit function( double (*const f)(gsl::vector const&), size_t const dim ){
        base_f = new Fuvcr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#ifndef DOXYGEN_SKIP
      explicit function( double (*const f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FuvCr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      explicit function( double const (*const f)(gsl::vector const&), size_t const dim ){
        base_f = new Fcvcr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      explicit function( double const (*const f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FcvCr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      explicit function( double& (*const f)(gsl::vector const&), size_t const dim ){
        base_f = new Furcr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      explicit function( double& (*const f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FurCr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      explicit function( double const& (*const f)(gsl::vector const&), size_t const dim ){
        base_f = new Fcrcr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      explicit function( double const& (*const f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FcrCr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      explicit function( double volatile& (*const f)(gsl::vector const&), size_t const dim ){
        base_f = new FVrcr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      explicit function( double volatile& (*const f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FVrCr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      explicit function( double const volatile& (*const f)(gsl::vector const&), size_t const dim ){
        base_f = new FCrcr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      explicit function( double const volatile& (*const f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FCrCr( f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
      template<typename T> function( T& c, double (T::*f)(gsl::vector const&), size_t const dim ){
        base_f = new Fuvcru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FuvCru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const&), size_t const dim ){
        base_f = new Fcvcru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FcvCru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const&), size_t const dim ){
        base_f = new Furcru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FurCru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&), size_t const dim ){
        base_f = new Fcrcru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FcrCru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&), size_t const dim ){
        base_f = new FVrcru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FVrCru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&), size_t const dim ){
        base_f = new FCrcru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&), size_t const dim ){
        base_f = new FCrCru<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double (T::*f)(gsl::vector const&) const, size_t const dim ){
        base_f = new Fuvcrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) const, size_t const dim ){
        base_f = new FuvCrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) const, size_t const dim ){
        base_f = new Fcvcrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) const, size_t const dim ){
        base_f = new FcvCrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) const, size_t const dim ){
        base_f = new Furcrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) const, size_t const dim ){
        base_f = new FurCrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) const, size_t const dim ){
        base_f = new Fcrcrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) const, size_t const dim ){
        base_f = new FcrCrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) const, size_t const dim ){
        base_f = new FVrcrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const, size_t const dim ){
        base_f = new FVrCrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) const, size_t const dim ){
        base_f = new FCrcrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const, size_t const dim ){
        base_f = new FCrCrc<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double (T::*f)(gsl::vector const&) volatile, size_t const dim ){
        base_f = new FuvcrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) volatile, size_t const dim ){
        base_f = new FuvCrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) volatile, size_t const dim ){
        base_f = new FcvcrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) volatile, size_t const dim ){
        base_f = new FcvCrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) volatile, size_t const dim ){
        base_f = new FurcrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim ){
        base_f = new FurCrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) volatile, size_t const dim ){
        base_f = new FcrcrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim ){
        base_f = new FcrCrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) volatile, size_t const dim ){
        base_f = new FVrcrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim ){
        base_f = new FVrCrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) volatile, size_t const dim ){
        base_f = new FCrcrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) volatile, size_t const dim ){
        base_f = new FCrCrV<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double (T::*f)(gsl::vector const&) const volatile, size_t const dim ){
        base_f = new FuvcrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim ){
        base_f = new FuvCrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) const volatile, size_t const dim ){
        base_f = new FcvcrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim ){
        base_f = new FcvCrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) const volatile, size_t const dim ){
        base_f = new FurcrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim ){
        base_f = new FurCrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) const volatile, size_t const dim ){
        base_f = new FcrcrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim ){
        base_f = new FcrCrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) const volatile, size_t const dim ){
        base_f = new FVrcrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim ){
        base_f = new FVrCrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
#ifndef DOXYGEN_SKIP
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) const volatile, size_t const dim ){
        base_f = new FCrcrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
      template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const volatile, size_t const dim ){
        base_f = new FCrCrC<T>( c, f, dim );
        params = base_f;
        this->f = base_f->function();
        this->dim = dim;
        // 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 f
      }
#endif
    // Copy and move constructors
    // copy constructor
    function( function const& v ) : base_f( v.base_f ), count( v.count ){
      f = v.f;
      dim = v.dim;
      params = v.params;
      if( count != 0 ) ++*count; // function is now shared.
    }
    // assignment operator
    function& operator=( function const& v ){
      // first, possibly delete anything pointed to by this
      if( count == 0 or --*count == 0 ){
    delete base_f;
    delete count;
      }
      // Then copy
      base_f = v.base_f;
      f = v.f;
      dim = v.dim;
      params = v.params;
      count = v.count;
      if( count != 0 ) ++*count; // function is now shared.
      return *this;
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    function( function&& v ) : base_f( v.base_f ), count( nullptr ){
      std::swap( f, v.f );
      std::swap( dim, v.dim );
      std::swap( params, v.params );
      std::swap( count, v.count );
      v.base_f = nullptr;
    }
    function& operator=( function&& v ){
      std::swap( base_f, v.base_f );
      std::swap( f, v.f );
      std::swap( dim, v.dim );
      std::swap( params, v.params );
      std::swap( count, v.count );
      return *this;
    }
#endif
    ~function(){ 
      // first, possibly delete anything pointed to by base_f
      if( count == 0 or --*count == 0 ){
    delete base_f;
    delete count;
      }
    }
  private:
    static double fn( double* x, size_t dim, void* params ){
      base_F* const b = reinterpret_cast<base_F*>( params );
      return b->function()( x, dim, params );
    }
  };
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) , size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&)  const, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&)  volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
    template<typename T>
    inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&)  const volatile, size_t const dim ){
      function fn( c, f, dim );
      return fn;
    }
#endif
 
  }
}
 
#endif