[Boost-commit] svn:boost r57322 - in sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling: statistics weights

Subject: [Boost-commit] svn:boost r57322 - in sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling: statistics weights
From: erwann.rogard_at_[hidden]
Date: 2009-11-03 11:40:34

Author: e_r
Date: 2009-11-03 11:40:33 EST (Tue, 03 Nov 2009)
New Revision: 57322
URL: http://svn.boost.org/trac/boost/changeset/57322

Log:
a/m
Added:
   sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/
   sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/percentage_effective_sample_size.hpp   (contents, props changed)
   sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/variance_of_mean_normalized.hpp   (contents, props changed)
Text files modified: 
   sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/weights/prepare_weights.hpp |   128 ++++++++++++--------------------------- 
   1 files changed, 40 insertions(+), 88 deletions(-)

Added: sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/percentage_effective_sample_size.hpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/percentage_effective_sample_size.hpp	2009-11-03 11:40:33 EST (Tue, 03 Nov 2009)
@@ -0,0 +1,100 @@
+///////////////////////////////////////////////////////////////////////////////
+// accumulator::statistics::percentage_effective_sample_size.hpp             //
+//                                                                           //
+//  Copyright 2008 Erwann Rogard. Distributed under the Boost                //
+//  Software License, Version 1.0. (See accompanying file                    //
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)         //
+///////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_STATISTICS_DETAIL_IMPORTANCE_SAMPLING_STATISTICS_PERCENTAGE_EFFECTIVE_SAMPLE_SIZE_HPP_ER_2009
+#define BOOST_STATISTICS_DETAIL_IMPORTANCE_SAMPLING_STATISTICS_PERCENTAGE_EFFECTIVE_SAMPLE_SIZE_HPP_ER_2009
+#include <boost/parameter/binding.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/accumulators/framework/extractor.hpp>
+#include <boost/accumulators/framework/accumulator_base.hpp>
+#include <boost/accumulators/framework/parameters/sample.hpp>
+#include <boost/accumulators/framework/parameters/accumulator.hpp>
+#include <boost/statistics/detail/importance_sampling/statistics/variance_of_mean_normalized.hpp>
+#include <boost/accumulators/framework/depends_on.hpp>
+
+namespace boost { 
+namespace statistics{
+namespace detail{
+namespace accumulator{
+namespace impl
+{
+
+    // Var(w/c) = Var(w) / c^2, where c = mean(w)
+    template<typename T>
+    class percentage_effective_sample_size 
+            : public boost::accumulators::accumulator_base
+        {
+        typedef boost::accumulators::dont_care dont_care_;
+    
+        typedef tag::variance_of_mean_normalized tag_vmn_;
+        typedef boost::accumulators::tag::accumulator tag_acc_;
+    
+        public:
+        typedef T result_type;
+        percentage_effective_sample_size(){}
+        percentage_effective_sample_size(dont_care_){}
+        void operator()(dont_care_)const{}
+
+        template<typename Args>
+        result_type result(const Args& args) const
+        {
+
+            typedef 
+                typename boost::parameter::binding<Args,tag_acc_>::type cref_;
+            cref_ acc = args[boost::accumulators::accumulator];
+
+            T vmn = accumulators::extract_result<tag_vmn_>(acc);
+            return one / (one+vmn);
+        }
+        
+        static const T one;
+    };
+
+    template<typename T>
+    const T percentage_effective_sample_size<T>::one = static_cast<T>(1);
+
+}//impl
+
+///////////////////////////////////////////////////////////////////////////////
+// tag::percentage_effective_sample_size
+namespace tag
+{
+    struct percentage_effective_sample_size
+      : boost::accumulators::depends_on<tag::variance_of_mean_normalized>
+    {
+      typedef statistics::detail::accumulator::impl
+        ::percentage_effective_sample_size<boost::mpl::_1> impl;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// extract::percentage_effective_sample_size
+namespace extract
+{
+
+  template<typename AccSet>
+  typename
+    boost::mpl::apply<
+        AccSet,
+        tag::percentage_effective_sample_size
+    >::type::result_type
+  percentage_effective_sample_size(AccSet const& acc){
+    typedef tag::percentage_effective_sample_size the_tag;
+    return boost::accumulators::extract_result<the_tag>(acc);
+  }
+
+}
+
+using extract::percentage_effective_sample_size;
+
+}// accumulator
+}// detail
+}// statistics
+}// boost
+
+#endif
\ No newline at end of file

Added: sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/variance_of_mean_normalized.hpp
==============================================================================
--- (empty file)
+++ sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/statistics/variance_of_mean_normalized.hpp	2009-11-03 11:40:33 EST (Tue, 03 Nov 2009)
@@ -0,0 +1,102 @@
+///////////////////////////////////////////////////////////////////////////////
+// accumulator::statistics::variance_of_mean_normalized.hpp                  //
+//                                                                           //
+//  Copyright 2008 Erwann Rogard. Distributed under the Boost                //
+//  Software License, Version 1.0. (See accompanying file                    //
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)         //
+///////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_STATISTICS_DETAIL_IMPORTANCE_SAMPLING_STATISTICS_VARIANCE_OF_MEAN_NORMALIZED_HPP_ER_2009
+#define BOOST_STATISTICS_DETAIL_IMPORTANCE_SAMPLING_STATISTICS_VARIANCE_OF_MEAN_NORMALIZED_HPP_ER_2009
+#include <boost/parameter/binding.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/accumulators/framework/extractor.hpp>
+#include <boost/accumulators/framework/accumulator_base.hpp>
+#include <boost/accumulators/framework/parameters/sample.hpp>
+#include <boost/accumulators/framework/parameters/accumulator.hpp>
+#include <boost/accumulators/framework/depends_on.hpp>
+#include <boost/accumulators/statistics_fwd.hpp>
+#include <boost/accumulators/statistics/mean.hpp>
+#include <boost/accumulators/statistics/variance.hpp>
+
+namespace boost { 
+namespace statistics{
+namespace detail{
+namespace accumulator{
+
+namespace impl
+{
+
+    // Var(w/c) = Var(w) / c^2, where c = mean(w)
+    template<typename T>
+    class variance_of_mean_normalized 
+            : public boost::accumulators::accumulator_base{
+        typedef boost::accumulators::dont_care dont_care_;
+    
+        typedef boost::accumulators::tag::variance tag_v_;
+        typedef boost::accumulators::tag::mean tag_m_;
+        typedef boost::accumulators::tag::accumulator tag_acc_;
+    
+        public:
+        typedef T result_type;
+        variance_of_mean_normalized(){}
+        variance_of_mean_normalized(dont_care_){}
+        void operator()(dont_care_)const{}
+
+        template<typename Args>
+        result_type result(const Args& args) const
+        {
+
+            typedef 
+                typename boost::parameter::binding<Args,tag_acc_>::type cref_;
+            cref_ acc = args[boost::accumulators::accumulator];
+
+            T v = accumulators::extract_result<tag_v_>(acc);
+            T c = accumulators::extract_result<tag_m_>(acc);
+            return v / (c*c);
+        }
+    };
+
+}//impl
+
+///////////////////////////////////////////////////////////////////////////////
+// tag::variance_of_mean_normalized
+namespace tag
+{
+    struct variance_of_mean_normalized
+      : boost::accumulators::depends_on<
+        boost::accumulators::tag::mean,
+        boost::accumulators::tag::variance
+    >
+    {
+      typedef impl::variance_of_mean_normalized<boost::mpl::_1> impl;
+
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// extract::variance_of_mean_normalized
+namespace extract
+{
+
+  template<typename AccSet>
+  typename
+    boost::mpl::apply<
+        AccSet,
+        tag::variance_of_mean_normalized
+    >::type::result_type
+    variance_of_mean_normalized(AccSet const& acc){
+        typedef tag::variance_of_mean_normalized the_tag;
+        return boost::accumulators::extract_result<the_tag>(acc);
+    }
+
+}
+
+using extract::variance_of_mean_normalized;
+
+}// accumulator
+}// detail
+}// statistics
+}// boost
+
+#endif
\ No newline at end of file

Modified: sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/weights/prepare_weights.hpp
==============================================================================
--- sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/weights/prepare_weights.hpp	(original)
+++ sandbox/statistics/importance_sampling/boost/statistics/detail/importance_sampling/weights/prepare_weights.hpp	2009-11-03 11:40:33 EST (Tue, 03 Nov 2009)
@@ -11,7 +11,8 @@
 #include <functional>
 #include <boost/format.hpp>
 #include <boost/lambda/lambda.hpp>
-#include <boost/math/tools/precision.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
 #include <boost/statistics/detail/importance_sampling/weights/apply_exp_offset.hpp>
 #include <boost/statistics/detail/importance_sampling/weights/scale_to_finite_sum.hpp>
 #include <boost/statistics/detail/importance_sampling/weights/effective_sample_size.hpp>
@@ -28,130 +29,81 @@
         typedef T value_type;
         typedef std::size_t size_type;
 
-        prepare_weights();
-        prepare_weights(value_type max_log);
+        prepare_weights()
+        :max_log_(default_max_log),offset_(zero),scaling_factor_(zero){}
+
+        prepare_weights(value_type max_log)
+        :max_log_(max_log),offset_(zero),scaling_factor_(zero){}
+
         // Default copy/assign
 
         // [ Input ]
         // max_log controls precision hence raising it should decr pc_lt_eps
         // but also incr risk that cum_sum isinf. 
-        value_type max_log;  
+        value_type max_log()const{ return this->max_log_; }  
  
         // [ Output ]
-        value_type offset;        // lw <- lw + offset, max{lw}+offset = max_log
-        value_type scaling_factor;// w <- w/c such that sum{w/c}<inf
-        value_type pc_ess;        // pc effective sample size
-        value_type pc_lt_eps;     // pc w<eps
+        // lw <- lw + offset, max{lw}+offset = max_log
+        value_type offset()const{ return this->offset_; }  
+        // w <- w/c such that sum{w/c}<inf
+        value_type scaling_factor()const{ return this->scaling_factor_; }
         
         // [ Side effect ] 
         // 1) w <- exp(lw+offset)
         // 2) if needed, w <- w/c such that sum{w} < inf
         template<typename ItW>
-        void operator()(
-            ItW b_w,    // log( unnormalized weights )
-            ItW e_w    
-        );
+        void operator()(ItW b_w,ItW e_w) // log( unnormalized weights )
+        {
+            this->offset_ = apply_exp_offset(
+                b_w,
+                e_w,
+                this->max_log()
+            );
+
+            // if max_log is small enough (which costs precision), this does not 
+            // nothing i.e. scaling_factor = 1
+            this->scaling_factor_ = scale_to_finite_sum(
+                b_w,
+                e_w
+            ); 
+        }
 
-        public:
-        static value_type zero;
-        static value_type eps;
-        static value_type default_max_log;
         static const char* header;
+        private:
+        value_type max_log_;
+        value_type offset_;
+        value_type scaling_factor_;
+        static const value_type zero;
+        static const value_type default_max_log;
 
     };
 
     template<typename T>
-    std::ostream& operator<<(std::ostream& out, 
-        const prepare_weights<T>& that);
-
-    // Implementation
-
-    template<typename T>
     std::ostream& operator<<(
         std::ostream& out, 
         const prepare_weights<T>& that
     ){
         out << 
             (
-                format("(%1%,%2%,%3%,%4%)")
-                % that.offset
-                % that.scaling_factor
-                % that.pc_ess
-                % that.pc_lt_eps
+                boost::format("(%1%,%2%)")
+                % that.offset()
+                % that.scaling_factor()
             ).str();
         return out;
     }
 
     template<typename T>
     const char* prepare_weights<T>::header 
-        = "(offset,scaling_factor,pc_ess,pc_lt_eps)";
-
-    template<typename T>
-    typename prepare_weights<T>::value_type
-    prepare_weights<T>::eps = math::tools::epsilon<value_type>();
+        = "(offset,scaling_factor)";
 
     template<typename T>
-    typename prepare_weights<T>::value_type
+    const typename prepare_weights<T>::value_type
     prepare_weights<T>::default_max_log = static_cast<value_type>(0);
 
     template<typename T>
-    typename prepare_weights<T>::value_type
+    const typename prepare_weights<T>::value_type
     prepare_weights<T>::zero = static_cast<value_type>(0);
 
-    template<typename T>
-    prepare_weights<T>::prepare_weights()
-    :max_log(default_max_log),
-    offset(zero),scaling_factor(zero),pc_ess(zero),pc_lt_eps(zero){}
-
-    template<typename T>
-    prepare_weights<T>::prepare_weights(value_type ml)
-    :max_log(ml),
-    offset(zero),scaling_factor(zero),pc_ess(zero),pc_lt_eps(zero){}
-    
-    template<typename T>
-    template<typename ItW>
-    void
-    prepare_weights<T>::operator()(
-        ItW b_w,
-        ItW e_w
-    ){
-        offset = apply_exp_offset(
-            b_w,
-            e_w,
-            max_log
-        );
-
-        // if max_log is small enough (which costs precision), this does not 
-        // nothing i.e. scaling_factor = 1
-        scaling_factor = scale_to_finite_sum(
-            b_w,
-            e_w
-        ); 
-
-        ItW i_lt_eps = std::lower_bound(
-            b_w,
-            e_w,
-            eps,
-            ( boost::lambda::_1 >= boost::lambda::_2 )
-        );
-        
-        value_type n_gt_eps 
-            = static_cast<value_type>( std::distance(b_w,i_lt_eps) );
-        value_type n_lt_eps 
-            = static_cast<value_type>( std::distance(i_lt_eps,e_w) );
-        
-        
-        // Increasing max_log should decrease this number
-        pc_lt_eps = n_lt_eps / ( n_lt_eps + n_gt_eps ) ;
-
-        // Beware that pc_lt_eps >0  may distort ess
-        pc_ess = percentage_effective_sample_size(
-            b_w,
-            e_w
-        );
-        
-    }
-
 }// importance_weights
 }// detail
 }// statistics