multimin_function_fdf.hpp

Go to the documentation of this file.

/*
 * $Id: multimin_function_fdf.hpp 130 2012-03-27 09:45:00Z jdl3 $
 * Copyright (C) 2010, 2011, 2012, 2016, 2020, 2021 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_MULTIMIN_FUNCTION_FDF_HPP
#define CCGSL_MULTIMIN_FUNCTION_FDF_HPP
 
// For std::pair
#include<utility>
#include"multimin_function.hpp"
// For std::swap
#if __cplusplus <= 199711L
#include<algorithm>
#else
#include<utility>
#endif
 
namespace gsl {
  namespace multimin {
    class function_fdf;
    template<typename T>
    void function_fdf_constructor( function_fdf& fdf, T& t );
    class function_fdf : public gsl_multimin_function_fdf {
    public:
      struct Concept {
    virtual double f( const vector& x ) = 0;
    virtual void df( const vector& x, vector& gradient ) = 0;
    virtual void fdf( const vector& x, double* result, vector& gradient ) = 0;
    size_t size() const;
      };
#ifndef DOXYGEN_SKIP
    private:
      struct base_F {
    typedef double (*function_t)(const vector&,void*);
    typedef void (*function_df_t)(const vector&,void*,vector&);
    typedef void (*function_fdf_t)(const vector&,void*,double&,vector&);
      };
      template<typename T>
      struct FDF : public base_F {
      public:
    FDF( T& t ) : t( t ){
      xv.wrap_gsl_vector_without_ownership( 0 );
      dfv.wrap_gsl_vector_without_ownership( 0 );
    }
      public:
    static double fn( gsl_vector const* x, void* params ){
      FDF<T>* fdft = reinterpret_cast<FDF<T>*>( params );
      fdft->xv.ccgsl_pointer = const_cast<gsl_vector*>( x );
      return fdft->t.f( fdft->xv ); }
    static void dfn( gsl_vector const* x, void* params, gsl_vector* df ){
      FDF<T>* fdft = reinterpret_cast<FDF<T>*>( params );
      fdft->xv.ccgsl_pointer = const_cast<gsl_vector*>( x );
      fdft->dfv.ccgsl_pointer = df;
      return fdft->t.df( fdft->xv, fdft->dfv ); }
    static void fdfn( gsl_vector const* x, void* params, double* f, gsl_vector* df ){
      FDF<T>* fdft = reinterpret_cast<FDF<T>*>( params );
      fdft->xv.ccgsl_pointer = const_cast<gsl_vector*>( x );
      fdft->dfv.ccgsl_pointer = df;
      return fdft->t.fdf( fdft->xv, *f, fdft->dfv ); }
      private:
    gsl::vector xv;
    gsl::vector dfv;
    T& t;
      };
#endif
      base_F* function;
      size_t* count;
    public:
      function_fdf(){
    function = 0;
    f = 0;
    df = 0;
    fdf = 0;
    params = 0;
    count = 0; // initially nullptr will do
      }
      template<typename T>
      friend void function_fdf_constructor( function_fdf& fdf, T& t );
      explicit function_fdf( gsl_multimin_function_fdf& v ){
    // explicitly set function = 0 to indicate nothing to be deleted.
    function = 0;
    n = 0;
    // copy
    f = v.f;
    df = v.df;
    fdf = v.fdf;
    params = v.params;
    // 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 function
      }
      template<typename T>
      function_fdf( T& t ){
    function_fdf_constructor<T>( *this, t );
      }
       
      // Copy and move constructors
      // copy constructor
      function_fdf( function_fdf const& v ) : function( v.function ), count( v.count ){
    f = v.f;
    n = v.n;
    df = v.df;
    fdf = v.fdf;
    params = v.params;
    if( count != 0 ) ++*count; // function_fdf is now shared.
      }
      // assignment operator
      function_fdf& operator=( function_fdf const& v ){
    // first, possibly delete anything pointed to by this
    if( count == 0 or --*count == 0 ){
      delete function;
      delete count;
    }
    // Then copy
    function = v.function;
    f = v.f;
    n = v.n;
    df = v.df;
    fdf = v.fdf;
    params = v.params;
    // count = v.count;
    if( count != 0 ) ++*count; // function_fdf is now shared.
    return *this;
      }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      function_fdf( function_fdf&& v ) : function( v.function ), count( nullptr ){
    std::swap( f, v.f );
    std::swap( n, v.n );
    std::swap( df, v.df );
    std::swap( fdf, v.fdf );
    std::swap( params, v.params );
    std::swap( count, v.count );
    v.function = nullptr;
      }
      function_fdf& operator=( function_fdf&& v ){
    std::swap( function, v.function );
    std::swap( f, v.f );
    std::swap( n, v.n );
    std::swap( df, v.df );
    std::swap( fdf, v.fdf );
    std::swap( params, v.params );
    std::swap( count, v.count );
    return *this;
      }
#endif
      ~function_fdf(){ 
    // first, possibly delete anything pointed to by f
    if( count == 0 or --*count == 0 ){
      delete function;
      delete count;
    }
      }
    };
#ifndef DOXYGEN_SKIP
    template<typename T>
    inline void function_fdf_constructor( function_fdf& fdf, T& t ){
      fdf.function = 0;
      fdf.count = 0;
      // try constructing from T
      fdf.function = new function_fdf::FDF<T>( t );
      fdf.n = t.size();
      fdf.f = &function_fdf::FDF<T>::fn;
      fdf.df = &function_fdf::FDF<T>::dfn;
      fdf.fdf = &function_fdf::FDF<T>::fdfn;
      fdf.params = fdf.function;
      // just plausibly we could fail to allocate count: no further action needed.
      fdf.count = new size_t;
      *fdf.count = 1; // initially there is just one reference to function
    }
    template<>
    inline void function_fdf_constructor( function_fdf& fdf, function_fdf& v ){
      fdf.function = v.function; fdf.count = v.count; fdf.f = v.f; fdf.n = v.n; fdf.df = v.df;
      fdf.fdf = v.fdf; fdf.params = v.params; if( fdf.count != 0 ) ++*fdf.count;
      /* function_fdf is now shared. */ }
    template<>
    inline void function_fdf_constructor( function_fdf& fdf, gsl_multimin_function_fdf& v ){
      fdf.f = v.f; fdf.n = v.n; fdf.df = v.df; fdf.fdf = v.fdf; fdf.params = v.params; }
#endif
  
    template<typename T>
    inline function_fdf make_function_fdf( T& t ){
      function_fdf fn( t );
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      return std::move( fn );
#else
      return fn;
#endif
    }
 
  }
}
 
#endif