PercentileConfidenceInterval.h

#ifndef _theplu_yat_statistics_percentile_confidence_interval_
#define _theplu_yat_statistics_percentile_confidence_interval_

// $Id: PercentileConfidenceInterval.h 4036 2021-01-24 01:02:57Z peter $

/*
  Copyright (C) 2021 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "yat/utility/yat_assert.h"

#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_concepts.hpp>

#include <boost/math/distributions/binomial.hpp>

#include <algorithm>
#include <vector>

namespace theplu {
namespace yat {
namespace statistics {

  class PercentileConfidenceInterval
  {
  public:
    PercentileConfidenceInterval(double k, double level);


    template<typename RandomAccessIterator>
    void operator()(RandomAccessIterator first, RandomAccessIterator last,
                    bool sorted=false)
    {
      typedef RandomAccessIterator T;
      typedef typename std::iterator_traits<T>::value_type value_type;
      BOOST_CONCEPT_ASSERT((boost_concepts::RandomAccessTraversal<T>));
      BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<T>));
      BOOST_CONCEPT_ASSERT((boost::Convertible<value_type, double>));
      prepare(last - first);
      process(first, last, sorted);
    }

    double alpha(void) const;

    double lower(void) const;

    double k(void) const;

    double upper(void) const;

  private:
    double alpha_;
    double k_;
    size_t n_;
    size_t lower_index_;
    double lower_;
    size_t upper_index_;
    double upper_;

    void prepare(size_t n);

    template<typename RandomAccessIterator>
    void process(RandomAccessIterator first, RandomAccessIterator last,
                 bool sorted)
    {
      if (!sorted) {
        std::vector<double> v(first, last);
        std::sort(v.begin(), v.end());
        process(v.begin(), v.end(), true);
        return;
      }
      lower_ = first[lower_index_];
      upper_ = first[upper_index_];
    }

  };

}}} // of namespace statistics, yat, and theplu

#endif