LOrPEWeightsLocalConvergence.hh

Go to the documentation of this file.

#ifndef NPSTAT_LORPEWEIGHTSLOCALCONVERGENCE_HH_
#define NPSTAT_LORPEWEIGHTSLOCALCONVERGENCE_HH_
 
/*!
// \file LOrPEWeightsLocalConvergence.hh
//
// \brief Class that decides whether the iterations of the LOrPE
//        semiparametric mixture Fredholm equation have converged
//
// Author: I. Volobouev
//
// August 2022
*/
 
#include <cmath>
#include <cassert>
 
namespace npstat {
    class LOrPEWeightsLocalConvergence
    {
    public:
        inline LOrPEWeightsLocalConvergence(const double i_tol,
                                            const double i_normPower,
                                            const bool i_useDensity)
            : tol_(i_tol),
              normPower_(i_normPower),
              checkConVergenceForDensity_(i_useDensity)
        {
            assert(tol_ > 0.0);
            assert(normPower_ > 0.0);
        }
 
        inline double tol() const {return tol_;}
        inline double normPower() const {return normPower_;}
        inline bool checkingConVergenceForDensity() const
            {return checkConVergenceForDensity_;}
 
        template<class Lorpe>
        inline bool converged(const Lorpe& lorpe,
                              const double* previousWeights,
                              const double* currentWeights,
                              const double* previousBg,
                              const double* currentBg) const
        {
            if (checkConVergenceForDensity_)
                return locallyConverged(lorpe, previousBg, currentBg);
            else
                return locallyConverged(lorpe, previousWeights, currentWeights);
        }
 
    private:
        template<class Lorpe>
        inline bool locallyConverged(const Lorpe& lorpe,
                                     const double* previous,
                                     const double* current) const
        {
            assert(previous);
            assert(current);
 
            const auto& sample = lorpe.coords();
            const unsigned long sampleSize = sample.size();
 
            long double sum = 0.0L, wsum = 0.0L;
            double p;
            for (unsigned long i=0; i<sampleSize; ++i)
            {
                const double w = lorpe.cvLocalizingWeight(sample[i].first);
                assert(w >= 0.0);
                if (w > 0.0)
                {
                    wsum += w;
                    const double ac = std::abs(current[i]);
                    const double ap = std::abs(previous[i]);
                    const double d = std::abs(current[i] - previous[i])*2.0/(ac + ap + 1.0);
                    if (normPower_ == 1.0)
                        p = d;
                    else if (normPower_ == 2.0)
                        p = d*d;
                    else
                        p = std::pow(d, normPower_);
                    sum += w*p;
                }
            }
            assert(wsum > 0.0L);
 
            const double weightedDiff = sum/wsum;
            const double norm = std::pow(weightedDiff, 1.0/normPower_);
            return norm < tol_;
        }
 
        double tol_;
        double normPower_;
        bool checkConVergenceForDensity_;
    };
}
 
#endif // NPSTAT_LORPEWEIGHTSLOCALCONVERGENCE_HH_