fitWeibull.hpp

Go to the documentation of this file.

/** \file fitWeibull.hpp
 * \author Jared R. Males
 * \brief Tools for fitting the Weibull distribution to data.
 * \ingroup fitting_files
 *
 */
 
//***********************************************************************//
// Copyright 2023 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib 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 3 of the License, or
// (at your option) any later version.
//
// mxlib 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 mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef fitWeibull_hpp
#define fitWeibull_hpp
 
#include "levmarInterface.hpp"
#include "../func/weibull.hpp"
 
namespace mx
{
namespace math
{
namespace fit
{
 
template <typename realT>
struct array2FitWeibull;
 
/** \defgroup weibull_peak_fit Weibull Distribution
 * \brief Fitting the Weibull Distribution to data.
 *
 * The Weibull Distribution is fit to data.
 *
 * \ingroup peak_fit
 */
 
/// Class to manage fitting the Weibull Distribution to data via the \ref levmarInterface
/** In addition to the requirements on fitterT specified by \ref levmarInterface
 * this class also requires this definition in fitterT
 * \code
 * static const int nparams = 3;
 * \endcode
 * where the number 3 is replaced by the number of parameters that fitterT expects to fit.
 *
 * \tparam fitterT a type meeting the above requirements.
 *
 * \ingroup weibull_peak_fit
 *
 */
template <typename fitterT>
class fitWeibull : public levmarInterface<fitterT>
{
 
  public:
    typedef typename fitterT::realT realT;
 
    static const int nparams = fitterT::nparams;
 
    array2FitWeibull<realT> arr;
 
    void initialize()
    {
        this->allocate_params( nparams );
        this->adata = &arr;
    }
 
    fitWeibull()
    {
        initialize();
    }
 
    ~fitWeibull()
    {
    }
 
    /// Set the initial guess when platescale and central obscuration are fixed.
    void setGuess( realT x0,    ///< [in] the location parameter
                   realT k,     ///< [in] the shape parameter
                   realT lambda ///< [in] the scale parameter
    )
    {
        static_assert( nparams == 3, "fitWeibull: Wrong setGuess called for no location parameter." );
 
        this->p[2] = x0;
        this->p[0] = k;
        this->p[1] = lambda;
    }
 
    /// Set the initial guess when platescale and central obscuration are fixed.
    void setGuess( realT k,     ///< [in] the shape parameter
                   realT lambda ///< [in] the scale parameter
    )
    {
        static_assert( nparams == 2, "fitWeibull: Wrong setGuess called for location parameter." );
 
        this->p[0] = k;
        this->p[1] = lambda;
    }
 
    void setArray( realT *data, int n )
    {
        arr.data = data;
        arr.n = n;
 
        this->n = n;
    }
 
    void x0( realT nx0 )
    {
        arr.x0 = nx0;
        if( nparams == 3 )
        {
            this->p[2] = nx0;
        }
    }
 
    void k( realT nk )
    {
        arr.k = nk;
        this->p[0] = nk;
    }
 
    void lambda( realT nl )
    {
        arr.lambda = nl;
        this->p[1] = nl;
    }
 
    int fit()
    {
        return levmarInterface<fitterT>::fit();
    }
 
    realT x0()
    {
        if( nparams == 3 )
        {
            return this->p[2];
        }
        else
        {
            return 0;
        }
    }
 
    realT k()
    {
        return this->p[0];
    }
 
    realT lambda()
    {
        return this->p[1];
    }
};
 
/// Wrapper for a native array to pass to \ref levmarInterface, with Weibull details.
/** \ingroup weibull_peak_fit
 */
template <typename realT>
struct array2FitWeibull
{
    realT *data{ nullptr }; ///< Pointer to the array
    size_t n{ 0 };          ///< dimension of the array
 
    realT x0{ 0 };     ///< the location parameter.
    realT k{ 0 };      ///< the shape parameter
    realT lambda{ 0 }; ///< the scale parameter
};
 
///\ref levmarInterface fitter structure for the shifted Weibull Distribution
/**
 *
 * \ingroup weibull_peak_fit
 *
 */
template <typename _realT>
struct weibull_3param_fitter
{
    typedef _realT realT;
 
    static const int nparams = 3;
 
    static void func( realT *p, realT *hx, int m, int n, void *adata )
    {
        array2FitWeibull<realT> *arr = (array2FitWeibull<realT> *)adata;
 
        for( int i = 0; i < arr->n; i++ )
        {
            hx[i] = func::weibull<realT>( i, p[2], p[0], p[1] ) - arr->data[i];
        }
    }
};
 
///\ref levmarInterface fitter structure for the shifted Weibull Distribution
/**
 *
 * \ingroup weibull_peak_fit
 *
 */
template <typename _realT>
struct weibull_2param_fitter
{
    typedef _realT realT;
 
    static const int nparams = 2;
 
    static void func( realT *p, realT *hx, int m, int n, void *adata )
    {
        array2FitWeibull<realT> *arr = (array2FitWeibull<realT> *)adata;
 
        for( int i = 0; i < arr->n; i++ )
        {
            hx[i] = func::weibull<realT>( i, 0.0, p[0], p[1] ) - arr->data[i];
        }
    }
};
 
} // namespace fit
} // namespace math
} // namespace mx
 
#endif // fitWeibull_hpp