[Boost-commit] svn:boost r67694 - in trunk: boost boost/random libs/random/test

Subject: [Boost-commit] svn:boost r67694 - in trunk: boost boost/random libs/random/test
From: steven_at_[hidden]
Date: 2011-01-05 17:42:40

Author: steven_watanabe
Date: 2011-01-05 17:42:36 EST (Wed, 05 Jan 2011)
New Revision: 67694
URL: http://svn.boost.org/trac/boost/changeset/67694

Log:
Implement fisher_f_distribution.
Added:
   trunk/boost/random/fisher_f_distribution.hpp   (contents, props changed)
   trunk/libs/random/test/test_fisher_f.cpp   (contents, props changed)
   trunk/libs/random/test/test_fisher_f_distribution.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/random.hpp            |     1 +                                       
   trunk/libs/random/test/Jamfile.v2 |     2 ++                                      
   2 files changed, 3 insertions(+), 0 deletions(-)

Modified: trunk/boost/random.hpp
==============================================================================
--- trunk/boost/random.hpp	(original)
+++ trunk/boost/random.hpp	2011-01-05 17:42:36 EST (Wed, 05 Jan 2011)
@@ -81,6 +81,7 @@
 #include <boost/random/binomial_distribution.hpp>
 #include <boost/random/negative_binomial_distribution.hpp>
 #include <boost/random/chi_squared_distribution.hpp>
+#include <boost/random/fisher_f_distribution.hpp>
 #include <boost/random/uniform_on_sphere.hpp>
 
 #endif // BOOST_RANDOM_HPP

Added: trunk/boost/random/fisher_f_distribution.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/random/fisher_f_distribution.hpp	2011-01-05 17:42:36 EST (Wed, 05 Jan 2011)
@@ -0,0 +1,178 @@
+/* boost random/fisher_f_distribution.hpp header file
+ *
+ * Copyright Steven Watanabe 2011
+ * 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)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id$
+ */
+
+#ifndef BOOST_RANDOM_FISHER_F_DISTRIBUTION_HPP
+#define BOOST_RANDOM_FISHER_F_DISTRIBUTION_HPP
+
+#include <iosfwd>
+#include <istream>
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/chi_squared_distribution.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * The Fisher F distribution is a real valued distribution with two
+ * parameters m and n.
+ *
+ * It has \f$\displaystyle p(x) =
+ *   \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
+ *   \left(\frac{m}{n}\right)^{m/2}
+ *   x^{(m/2)-1} \left(1+\frac{mx}{n}\right)^{-(m+n)/2}
+ * \f$.
+ */
+template<class RealType = double>
+class fisher_f_distribution {
+public:
+    typedef RealType result_type;
+    typedef RealType input_type;
+
+    class param_type {
+    public:
+        typedef fisher_f_distribution distribution_type;
+
+        /**
+         * Constructs a @c param_type from the "m" and "n" parameters
+         * of the distribution.
+         *
+         * Requires: m > 0 and n > 0
+         */
+        explicit param_type(RealType m_arg = RealType(1.0),
+                            RealType n_arg = RealType(1.0))
+          : _m(m_arg), _n(n_arg)
+        {}
+
+        /** Returns the "m" parameter of the distribtuion. */
+        RealType m() const { return _m; }
+        /** Returns the "n" parameter of the distribution. */
+        RealType n() const { return _n; }
+
+        /** Writes a @c param_type to a @c std::ostream. */
+        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+        { os << parm._m << ' ' << parm._n; return os; }
+
+        /** Reads a @c param_type from a @c std::istream. */
+        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+        { is >> parm._m >> std::ws >> parm._n; return is; }
+
+        /** Returns true if the two sets of parameters are the same. */
+        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        { return lhs._m == rhs._m && lhs._n == rhs._n; }
+        
+        /** Returns true if the two sets of parameters are the different. */
+        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+    private:
+        RealType _m;
+        RealType _n;
+    };
+
+    /**
+     * Constructs a @c fisher_f_distribution from its "m" and "n" parameters.
+     *
+     * Requires: m > 0 and n > 0
+     */
+    explicit fisher_f_distribution(RealType m_arg = RealType(1.0),
+                                   RealType n_arg = RealType(1.0))
+      : _impl_m(m_arg), _impl_n(n_arg)
+    {}
+    /** Constructs an @c fisher_f_distribution from its parameters. */
+    explicit fisher_f_distribution(const param_type& parm)
+      : _impl_m(parm.m()), _impl_n(parm.n())
+    {}
+
+    /**
+     * Returns a random variate distributed according to the
+     * F distribution.
+     */
+    template<class URNG>
+    RealType operator()(URNG& urng)
+    {
+        return (_impl_m(urng) * n()) / (_impl_n(urng) * m());
+    }
+
+    /**
+     * Returns a random variate distributed according to the
+     * F distribution with parameters specified by @c param.
+     */
+    template<class URNG>
+    RealType operator()(URNG& urng, const param_type& parm) const
+    {
+        return fisher_f_distribution(parm)(urng);
+    }
+
+    /** Returns the "m" parameter of the distribution. */
+    RealType m() const { return _impl_m.n(); }
+    /** Returns the "n" parameter of the distribution. */
+    RealType n() const { return _impl_n.n(); }
+
+    /** Returns the smallest value that the distribution can produce. */
+    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    { return 0; }
+    /** Returns the largest value that the distribution can produce. */
+    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    { return std::numeric_limits<RealType>::infinity(); }
+
+    /** Returns the parameters of the distribution. */
+    param_type param() const { return param_type(m(), n()); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm)
+    {
+        typedef chi_squared_distribution<RealType> impl_type;
+        typename impl_type::param_type m_param(parm.m());
+        _impl_m.param(m_param);
+        typename impl_type::param_type n_param(parm.n());
+        _impl_n.param(n_param);
+    }
+
+    /** Writes an @c fisher_f_distribution to a @c std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, fisher_f_distribution, fd)
+    {
+        os << fd.param();
+        return os;
+    }
+
+    /** Reads an @c fisher_f_distribution from a @c std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, fisher_f_distribution, fd)
+    {
+        param_type parm;
+        if(is >> parm) {
+            fd.param(parm);
+        }
+        return is;
+    }
+
+    /**
+     * Returns true if the two instances of @c fisher_f_distribution will
+     * return identical sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(fisher_f_distribution, lhs, rhs)
+    { return lhs._impl_m == rhs._impl_m && lhs._impl_n == rhs._impl_n; }
+    
+    /**
+     * Returns true if the two instances of @c fisher_f_distribution will
+     * return different sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(fisher_f_distribution)
+
+private:
+    chi_squared_distribution<RealType> _impl_m;
+    chi_squared_distribution<RealType> _impl_n;
+};
+
+} // namespace random
+} // namespace boost
+
+#endif // BOOST_RANDOM_EXTREME_VALUE_DISTRIBUTION_HPP

Modified: trunk/libs/random/test/Jamfile.v2
==============================================================================
--- trunk/libs/random/test/Jamfile.v2	(original)
+++ trunk/libs/random/test/Jamfile.v2	2011-01-05 17:42:36 EST (Wed, 05 Jan 2011)
@@ -62,6 +62,8 @@
 run test_negative_binomial_distribution.cpp /boost//unit_test_framework ;
 run test_chi_squared.cpp ;
 run test_chi_squared_distribution.cpp /boost//unit_test_framework ;
+run test_fisher_f.cpp ;
+run test_fisher_f_distribution.cpp /boost//unit_test_framework ;
 
 # run nondet_random_speed.cpp ;
 # run random_device.cpp ;

Added: trunk/libs/random/test/test_fisher_f.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/random/test/test_fisher_f.cpp	2011-01-05 17:42:36 EST (Wed, 05 Jan 2011)
@@ -0,0 +1,110 @@
+/* test_fisher_f.cpp
+ *
+ * Copyright Steven Watanabe 2011
+ * 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)
+ *
+ * $Id$
+ *
+ */
+
+#include <boost/random/fisher_f_distribution.hpp>
+#include <boost/random/uniform_real.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/math/distributions/fisher_f.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/exception/diagnostic_information.hpp>
+#include <vector>
+#include <iostream>
+#include <numeric>
+
+#include "statistic_tests.hpp"
+
+bool do_test(double m, double n, int max) {
+    std::cout << "running fisher_f(" << m << ", " << n << ")" << " " << max << " times: " << std::flush;
+
+    boost::math::fisher_f expected(m, n);
+    
+    boost::random::fisher_f_distribution<> dist(m, n);
+    boost::mt19937 gen;
+    kolmogorov_experiment test(max);
+    boost::variate_generator<boost::mt19937&, boost::random::fisher_f_distribution<> > vgen(gen, dist);
+
+    double prob = test.probability(test.run(vgen, expected));
+
+    bool result = prob < 0.99;
+    const char* err = result? "" : "*";
+    std::cout << std::setprecision(17) << prob << err << std::endl;
+
+    std::cout << std::setprecision(6);
+
+    return result;
+}
+
+bool do_tests(int repeat, double max_m, double max_n, int trials) {
+    boost::mt19937 gen;
+    boost::uniform_real<> mdist(0.00001, max_m);
+    boost::uniform_real<> ndist(0.00001, max_n);
+    int errors = 0;
+    for(int i = 0; i < repeat; ++i) {
+        if(!do_test(mdist(gen), ndist(gen), trials)) {
+            ++errors;
+        }
+    }
+    if(errors != 0) {
+        std::cout << "*** " << errors << " errors detected ***" << std::endl;
+    }
+    return errors == 0;
+}
+
+int usage() {
+    std::cerr << "Usage: test_fisher_f -r <repeat> -m <max m> -n <max n> -t <trials>" << std::endl;
+    return 2;
+}
+
+template<class T>
+bool handle_option(int& argc, char**& argv, char opt, T& value) {
+    if(argv[0][1] == opt && argc > 1) {
+        --argc;
+        ++argv;
+        value = boost::lexical_cast<T>(argv[0]);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+int main(int argc, char** argv) {
+    int repeat = 10;
+    double max_m = 1000.0;
+    double max_n = 1000.0;
+    int trials = 1000000;
+
+    if(argc > 0) {
+        --argc;
+        ++argv;
+    }
+    while(argc > 0) {
+        if(argv[0][0] != '-') return usage();
+        else if(!handle_option(argc, argv, 'r', repeat)
+             && !handle_option(argc, argv, 'm', max_m)
+             && !handle_option(argc, argv, 'n', max_n)
+             && !handle_option(argc, argv, 't', trials)) {
+            return usage();
+        }
+        --argc;
+        ++argv;
+    }
+
+    try {
+        if(do_tests(repeat, max_m, max_n, trials)) {
+            return 0;
+        } else {
+            return EXIT_FAILURE;
+        }
+    } catch(...) {
+        std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+        return EXIT_FAILURE;
+    }
+}

Added: trunk/libs/random/test/test_fisher_f_distribution.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/random/test/test_fisher_f_distribution.cpp	2011-01-05 17:42:36 EST (Wed, 05 Jan 2011)
@@ -0,0 +1,33 @@
+/* test_fisher_f_distribution.cpp
+ *
+ * Copyright Steven Watanabe 2011
+ * 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)
+ *
+ * $Id$
+ *
+ */
+
+#include <boost/random/fisher_f_distribution.hpp>
+#include <limits>
+
+#define BOOST_RANDOM_DISTRIBUTION boost::random::fisher_f_distribution<>
+#define BOOST_RANDOM_ARG1 m
+#define BOOST_RANDOM_ARG2 n
+#define BOOST_RANDOM_ARG1_DEFAULT 1.0
+#define BOOST_RANDOM_ARG2_DEFAULT 1.0
+#define BOOST_RANDOM_ARG1_VALUE 7.5
+#define BOOST_RANDOM_ARG2_VALUE 0.25
+
+#define BOOST_RANDOM_DIST0_MIN 0.0
+#define BOOST_RANDOM_DIST0_MAX (std::numeric_limits<double>::infinity)()
+#define BOOST_RANDOM_DIST1_MIN 0.0
+#define BOOST_RANDOM_DIST1_MAX (std::numeric_limits<double>::infinity)()
+#define BOOST_RANDOM_DIST2_MIN 0.0
+#define BOOST_RANDOM_DIST2_MAX (std::numeric_limits<double>::infinity)()
+
+#define BOOST_RANDOM_TEST1_PARAMS (1.0, 2.1)
+#define BOOST_RANDOM_TEST2_PARAMS (10.0, 10.0)
+
+#include "test_distribution.ipp"