[Boost-commit] svn:boost r56589 - sandbox/statistics/kernel/boost/statistics/kernel/functional

Subject: [Boost-commit] svn:boost r56589 - sandbox/statistics/kernel/boost/statistics/kernel/functional
From: erwann.rogard_at_[hidden]
Date: 2009-10-04 18:57:02

Author: e_r
Date: 2009-10-04 18:57:01 EDT (Sun, 04 Oct 2009)
New Revision: 56589
URL: http://svn.boost.org/trac/boost/changeset/56589

Log:
m
Text files modified: 
   sandbox/statistics/kernel/boost/statistics/kernel/functional/estimator.hpp  |   249 ++++++++++++--------------------------- 
   sandbox/statistics/kernel/boost/statistics/kernel/functional/nw_visitor.hpp |    12 +                                       
   sandbox/statistics/kernel/boost/statistics/kernel/functional/rp_visitor.hpp |    11 +                                       
   3 files changed, 90 insertions(+), 182 deletions(-)

Modified: sandbox/statistics/kernel/boost/statistics/kernel/functional/estimator.hpp
==============================================================================
--- sandbox/statistics/kernel/boost/statistics/kernel/functional/estimator.hpp	(original)
+++ sandbox/statistics/kernel/boost/statistics/kernel/functional/estimator.hpp	2009-10-04 18:57:01 EDT (Sun, 04 Oct 2009)
@@ -8,29 +8,33 @@
 #ifndef BOOST_STATISTICS_KERNEL_FUNCTIONAL_DENSITY_VISITOR_HPP_ER_2009
 #define BOOST_STATISTICS_KERNEL_FUNCTIONAL_DENSITY_VISITOR_HPP_ER_2009
 #include <algorithm>
+#include <boost/concept/assert.hpp>
+#include <boost/concept_check.hpp>
 #include <boost/call_traits.hpp>
 #include <boost/call_traits.hpp>
 #include <boost/type_traits/is_reference.hpp>
+#include  <boost/type_traits/is_convertible.hpp>
 #include <boost/mpl/nested_type.hpp>
-#include <boost/statistics/estimator_concept/meta/result_of_estimate.hpp>
+#include <boost/mpl/assert.hpp>
 #include <boost/statistics/kernel/functional/detail/mean_accumulator.hpp>
-
 namespace boost{
 namespace statistics{
 namespace kernel{
 
-    // R:   range of training_data 
-    // V:   visitor
+    // A type that models Trainer and Predictor
+    // See https://svn.boost.org/svn/boost/sandbox/statistics/cross_validation/boost/statistics/detail/cross_validation/estimator/concept/ 
+    //
+    // R:   range of a data range 
+    // V:   visitor 
     // K:   kernel
     // A:   accumulator
     //
-    // V                        R
-    // rp_visitor               {x[i]:i=1,...,n}
-    // nw_visitor_tuple         {(x,y)[i]:i=1,...,n}
+    // V                                      ->     data range of type R
+    // rp_visitor                             ->     {x[i]:i=1,...,n}
+    // meta_nw_visitor_unary<F1,F2>::apply    ->     {(x,y)[i]:i=1,...,n}
     //
-    // See statistics/estimator_concept
-    // Models TrainableEstimator 
-    // If V == nw_visitor_tuple, models TrainableRegressionEstimator 
+    // It is recommended that R derives from iterator_range because it is cheap
+    // to copy.
     template<
         typename R, 
         template<typename,typename,typename> class V,
@@ -41,187 +45,84 @@
     class estimator{
     
         public:
-        typedef R training_data_type;
+        typedef R training_dataset_type;
         typedef K kernel_type;
         typedef A accumulator_type;
 
         template<typename X>
-        struct result{
+        struct visitor
+        {
             typedef V<K,const X&,A> arg_;
             typedef typename mpl::nested_type<arg_>::type type;
         };
+
+        template<typename X>
+        struct result_of_predict
+        {
+            typedef typename visitor<X>::type v_;
+            typedef typename v_::result_type type;
+        };
     
         // Constructor
-        estimator();
-        estimator(K k);
-        estimator(K k,const A&);
-        estimator(const estimator&);
-        estimator& operator=(const estimator&);
+        estimator(){}
+        estimator(K k)
+            :k_(k){}
+        estimator(K k,const A& a)
+            :k_(k),a_(a){}
+        estimator(const estimator& that)
+            :td_(that.td_),k_(that.k_),a_(that.a_){}
+        estimator& operator=(const estimator& that){
+            if(&that = this){
+                this->td_ = that.td_;
+                this->k_ = that.k_;
+                this->a_ = that.a_;
+            }
+            return *this;
+        }
     
-        // Evaluate
-        template<typename X>
-        typename result<X>::type  operator()(const X& x)const;    
-
         // Access
-        const R& train_data()const;
-        const K& kernel()const;
-        const A& accumulator()const;
-
-        void set_train_data(const R& train_data);
+        const R& training_dataset()const{
+            return this->td_;
+        }
+        const K& kernel()const{
+            return this->k_; 
+        }
+        const A& accumulator()const{
+            return this->a_;
+        }
+
+        void train(const R& training_dataset){
+            BOOST_CONCEPT_ASSERT((
+                boost::Assignable<R>
+            ));
+            this->td_ = training_dataset;
+        }
+
+        template<typename X> 
+        typename visitor<X>::type 
+        visit(const X& x)const{
+            typedef estimator this_type;
+            typedef typename visitor<X>::type v_;
+    
+            return std::for_each(
+                boost::begin( this->training_dataset() ),
+                boost::end( this->training_dataset() ),
+                v_( this->kernel(), x, this->a_)
+            );
+        }
+        
+        template<typename X> 
+        typename result_of_predict<X>::type 
+        predict(const X& x)const{
+            return visit(x).estimate();
+        }
 
     private:
-        R train_data_;
+        R td_;
         K k_;
         A a_; // Initialized accumulator
     };
 
-}//kernel
-
-    template<
-        typename R, 
-        template<typename,typename,typename> class V,
-        typename K,
-        typename A
-    >
-    void train(kernel::estimator<R,V,K,A>& e, const R& train_data){
-        e.set_train_data(train_data);
-    }
-
-    template<
-        typename R, 
-        template<typename,typename,typename> class V,
-        typename K, typename A, typename X
-    >
-    struct result_of_estimate< kernel::estimator<R,V,K,A>,X > {
-        typedef kernel::estimator<R,V,K,A>  est_;
-        typedef typename est_::template result<X>    meta_vis_;
-        typedef typename meta_vis_::type    vis_;
-        typedef typename vis_::result_type  type;
-    };
-    
-    template<
-        typename R, 
-        template<typename,typename,typename> class V,
-        typename K, typename A, typename X
-    >
-    typename result_of_estimate< kernel::estimator<R,V,K,A>, X >::type
-    estimate(const kernel::estimator<R,V,K,A>& e, const X& x){
-        return e(x).estimate();
-    }
-
-// Implementation //
-namespace kernel{
-    
-// Constructor
-
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-estimator<R,V,K,A>::estimator():train_data_(),k_(),a_(){}
-
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-estimator<R,V,K,A>::estimator(K k):k_(k),a_(){}
-
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-estimator<R,V,K,A>::estimator(K k,const A& a)
-:train_data_(),k_(k),a_(a){}
-    
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-estimator<R,V,K,A>::estimator(const estimator& that)
-:train_data_(that.train_data_),k_(that.k_),a_(that.a_){}
-    
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-estimator<R,V,K,A>& 
-estimator<R,V,K,A>::operator=(const estimator& that){
-    if(&that = this){
-        this->train_data_ = that.train_data_;
-        this->k_ = that.k_;
-        this->a_ = that.a_;
-    }
-    return *this;
-}
-
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-void estimator<R,V,K,A>::set_train_data(const R& train_data){
-    this->train_data_ = train_data;
-}
-
-// Evaluate
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-    template<typename X>
-typename estimator<R,V,K,A>::template result<X>::type 
-estimator<R,V,K,A>::operator()(const X& x)const{
-    typedef typename estimator<R,V,K,A>::template result<X>::type result_;
-    return std::for_each(
-        boost::begin( this->train_data() ),
-        boost::end( this->train_data() ),
-        result_( this->kernel(), x, this->a_)
-    );
-}
-
-// Access
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-const R&
-estimator<R,V,K,A>::train_data()const{ return this->train_data_; }
-
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-const K& 
-estimator<R,V,K,A>::kernel()const{ return this->k_; }
-    
-template<
-    typename R, 
-    template<typename,typename,typename> class V,
-    typename K,
-    typename A
->
-const A&
-estimator<R,V,K,A>::accumulator()const{
-    return this->a_;
-}
-    
 }// kernel
 }// statistics
 }// boost

Modified: sandbox/statistics/kernel/boost/statistics/kernel/functional/nw_visitor.hpp
==============================================================================
--- sandbox/statistics/kernel/boost/statistics/kernel/functional/nw_visitor.hpp	(original)
+++ sandbox/statistics/kernel/boost/statistics/kernel/functional/nw_visitor.hpp	2009-10-04 18:57:01 EDT (Sun, 04 Oct 2009)
@@ -17,10 +17,10 @@
 namespace statistics{
 namespace kernel{
    
-// Let E[Y|X=x] denote the conditional mean of Y given X = x
+// This visitor, f, updates a Nadaraya-Watson estimate of E[Y|X=x0] each
+// time f(x,y) is called. 
 //
-// This class is to be used to visit the training data, to obtain an estimator,
-// by the Nadaraya-Watson method, of E[Y|X=x]
+// K,X,A : See rp_visitor 
 template<
     typename K,
     typename X,
@@ -50,14 +50,17 @@
     nw_visitor& operator=(const nw_visitor&);
         
     // Update
+    protected:
     template<typename X1,typename Y1> // Training data point
     result_type operator()(const X1& x1,const Y1& y1);
-        
+
+    public:
     // Access
     result_type unnormalized_estimate()const;
     result_type normalizing_constant()const;
     result_type estimate()const; 
 
+    
     const A& accumulator()const;
     const rp_visitor_type& rp_visitor()const;
         
@@ -134,7 +137,6 @@
     return (this->rp_visitor_);
 }
     
-    
 }// kernel
 }// statistics
 }// boost

Modified: sandbox/statistics/kernel/boost/statistics/kernel/functional/rp_visitor.hpp
==============================================================================
--- sandbox/statistics/kernel/boost/statistics/kernel/functional/rp_visitor.hpp	(original)
+++ sandbox/statistics/kernel/boost/statistics/kernel/functional/rp_visitor.hpp	2009-10-04 18:57:01 EDT (Sun, 04 Oct 2009)
@@ -18,10 +18,15 @@
 namespace statistics{
 namespace kernel{
 
-// Let p(x) denote the density of X = x
+// This visitor, f, keeps a data point, x0, and each time f(x) is called, it 
+// updates an estimate of the density at x0, p(x0), by the Rosenblatt-Parzen 
+// method, using a given kernel k.
 //
-// This class is to be used to visit the training data, to obtain an estimator,
-// by the Rosenblatt-Parzen method, of p(x)
+// The estimate is the average of the kernel evaluations over the traversed 
+// dataset. That average is implemented by an accumulator of type A.
+//
+// X can be a reference which is only recommended if the x object is expensive 
+// to copy
 template<
     typename K,
     typename X,