[Boost-commit] svn:boost r49485 - in sandbox/math_toolkit: boost/math boost/math/distributions libs/math/doc/sf_and_dist libs/math/doc/sf_and_dist/distributions libs/math/doc/sf_and_dist/graphs libs/math/test

Subject: [Boost-commit] svn:boost r49485 - in sandbox/math_toolkit: boost/math boost/math/distributions libs/math/doc/sf_and_dist libs/math/doc/sf_and_dist/distributions libs/math/doc/sf_and_dist/graphs libs/math/test
From: john_at_[hidden]
Date: 2008-10-29 09:10:09

Author: johnmaddock
Date: 2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
New Revision: 49485
URL: http://svn.boost.org/trac/boost/changeset/49485

Log:
Added logistic distribution.
Added:
   sandbox/math_toolkit/boost/math/distributions/logistic.hpp   (contents, props changed)
      - copied, changed from r49389, /sandbox/SOC/2008/parrallel_math/boost/math/distributions/gsoc_logistic.hpp
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/distributions/logistic.qbk   (contents, props changed)
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/graphs/logistic_pdf.png   (contents, props changed)
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/graphs/logistic_pdf.svg   (contents, props changed)
   sandbox/math_toolkit/libs/math/test/test_logistic_dist.cpp   (contents, props changed)
      - copied, changed from r49389, /sandbox/SOC/2008/parrallel_math/libs/math/test/gsoc_test_logistic_dist.cpp
Text files modified: 
   sandbox/math_toolkit/boost/math/distributions.hpp                 |     1                                         
   sandbox/math_toolkit/boost/math/distributions/logistic.hpp        |   304 ++++++++++++++++++--------------------- 
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/dist_reference.qbk |     1                                         
   sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk        |     1                                         
   sandbox/math_toolkit/libs/math/test/test_logistic_dist.cpp        |   299 ++++++++++++++++++--------------------- 
   5 files changed, 283 insertions(+), 323 deletions(-)

Modified: sandbox/math_toolkit/boost/math/distributions.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/distributions.hpp	(original)
+++ sandbox/math_toolkit/boost/math/distributions.hpp	2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
@@ -22,6 +22,7 @@
 #include <boost/math/distributions/extreme_value.hpp>
 #include <boost/math/distributions/fisher_f.hpp>
 #include <boost/math/distributions/gamma.hpp>
+#include <boost/math/distributions/logistic.hpp>
 #include <boost/math/distributions/lognormal.hpp>
 #include <boost/math/distributions/negative_binomial.hpp>
 #include <boost/math/distributions/non_central_chi_squared.hpp>

Copied: sandbox/math_toolkit/boost/math/distributions/logistic.hpp (from r49389, /sandbox/SOC/2008/parrallel_math/boost/math/distributions/gsoc_logistic.hpp)
==============================================================================
--- /sandbox/SOC/2008/parrallel_math/boost/math/distributions/gsoc_logistic.hpp	(original)
+++ sandbox/math_toolkit/boost/math/distributions/logistic.hpp	2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
@@ -1,31 +1,19 @@
-
-// Copyright John Maddock 
-// Copyright Paul A. Bristow 
-// Copyright Gautam Sewani
-
+// Copyright 2008 Gautam Sewani
+//
 // Use, modification and distribution are subject to 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)
 
-
-
-
-
-
-
-
-
 #include <boost/math/distributions/fwd.hpp>
 #include <boost/math/distributions/detail/common_error_handling.hpp>
 #include <boost/math/distributions/complement.hpp>
 #include <boost/math/special_functions/log1p.hpp>
-
-#include <cmath>
 #include <boost/math/constants/constants.hpp>
 #include <utility>
 
 namespace boost { namespace math { 
+
     template <class RealType = double, class Policy = policies::policy<> >
     class logistic_distribution
     {
@@ -80,177 +68,174 @@
     template <class RealType, class Policy>
     inline RealType pdf(const logistic_distribution<RealType, Policy>& dist, const RealType& x)
     {
-      RealType scale = dist.scale();
-      RealType location = dist.location();
-      
-      static const char* function = "boost::math::pdf(const logistic_distribution<%1%>&, %1%)";
-      if((boost::math::isinf)(x))
-        {
+       RealType scale = dist.scale();
+       RealType location = dist.location();
+
+       static const char* function = "boost::math::pdf(const logistic_distribution<%1%>&, %1%)";
+       if((boost::math::isinf)(x))
+       {
           return 0; // pdf + and - infinity is zero.
-        }
-      
-      
-      RealType result;
-      if(false == detail::check_scale(function, scale , &result, Policy()))
-        {
-          return result;
-        }
-      if(false == detail::check_location(function, location, &result, Policy()))
-        {
-          return result;
-        }
-      if(false == detail::check_x(function, x, &result, Policy()))
-        {
+       }
+
+       RealType result;
+       if(false == detail::check_scale(function, scale , &result, Policy()))
+       {
           return result;
-        }
-      
-      BOOST_MATH_STD_USING
-      RealType exp_term=exp((location-x)/scale);
-      return ( exp_term )/ ( scale*(1+exp_term)*(1+exp_term ) );
-      
-      
+       }
+       if(false == detail::check_location(function, location, &result, Policy()))
+       {
+          return result;
+       }
+       if(false == detail::check_x(function, x, &result, Policy()))
+       {
+          return result;
+       }
+
+       BOOST_MATH_STD_USING
+       RealType exp_term = (location - x) / scale;
+       if(fabs(exp_term) > tools::log_max_value<RealType>())
+          return 0;
+       exp_term = exp(exp_term);
+       if((exp_term * scale > 1) && (exp_term > tools::max_value<RealType>() / (scale * exp_term)))
+          return 1 / (scale * exp_term);
+       return (exp_term) / (scale * (1 + exp_term) * (1 + exp_term));
     } 
     
     template <class RealType, class Policy>
     inline RealType cdf(const logistic_distribution<RealType, Policy>& dist, const RealType& x)
     {
-      RealType scale = dist.scale();
-      RealType location = dist.location();
-      RealType result; // of checks.
-      static const char* function = "boost::math::cdf(const logistic_distribution<%1%>&, %1%)";
-      if(false == detail::check_scale(function, scale, &result, Policy()))
-        {
+       RealType scale = dist.scale();
+       RealType location = dist.location();
+       RealType result; // of checks.
+       static const char* function = "boost::math::cdf(const logistic_distribution<%1%>&, %1%)";
+       if(false == detail::check_scale(function, scale, &result, Policy()))
+       {
           return result;
-        }
-      
-      if(false == detail::check_location(function, location, &result, Policy()))
-        {
+       }
+       if(false == detail::check_location(function, location, &result, Policy()))
+       {
           return result;
-        }
-      
-      if((boost::math::isinf)(x))
-        {
+       }
+
+       if((boost::math::isinf)(x))
+       {
           if(x < 0) return 0; // -infinity
           return 1; // + infinity
-        }
-      
-      if(false == detail::check_x(function, x, &result, Policy()))
-        {
+       }
+
+       if(false == detail::check_x(function, x, &result, Policy()))
+       {
           return result;
-        }
-      BOOST_MATH_STD_USING
-      RealType power=(location-x)/scale;
-      return 1/( 1+exp(power) ); 
+       }
+       BOOST_MATH_STD_USING
+       RealType power = (location - x) / scale;
+       if(power > tools::log_max_value<RealType>())
+          return 0;
+       if(power < -tools::log_max_value<RealType>())
+          return 1;
+       return 1 / (1 + exp(power)); 
     } 
     
     template <class RealType, class Policy>
     inline RealType quantile(const logistic_distribution<RealType, Policy>& dist, const RealType& p)
     {
-      RealType location = dist.location();
-      RealType scale = dist.scale();
-      
-      static const char* function = "boost::math::quantile(const logistic_distribution<%1%>&, %1%)";
-      
-      RealType result;
-      if(false == detail::check_scale(function, scale, &result, Policy()))
-        return result;
-      if(false == detail::check_location(function, location, &result, Policy()))
-        return result;
-      if(false == detail::check_probability(function, p, &result, Policy()))
-        return result;
-      
-      
-      if(p == 0)
-        {
-          
-          result=policies::raise_underflow_error<RealType>(function,"probability argument is 0, must be >0 and <1",Policy());
-          return result;
-        }
-      if(p == 1)
-        {
-          result=policies::raise_overflow_error<RealType>(function,"probability argument is 0, must be >0 and <1",Policy());
+       BOOST_MATH_STD_USING
+       RealType location = dist.location();
+       RealType scale = dist.scale();
+
+       static const char* function = "boost::math::quantile(const logistic_distribution<%1%>&, %1%)";
+
+       RealType result;
+       if(false == detail::check_scale(function, scale, &result, Policy()))
           return result;
-          
-        }
-      BOOST_MATH_STD_USING
-      //Expressions to try
+       if(false == detail::check_location(function, location, &result, Policy()))
+          return result;
+       if(false == detail::check_probability(function, p, &result, Policy()))
+          return result;
+
+       if(p == 0)
+       {
+          return -policies::raise_overflow_error<RealType>(function,"probability argument is 0, must be >0 and <1",Policy());
+       }
+       if(p == 1)
+       {
+          return policies::raise_overflow_error<RealType>(function,"probability argument is 1, must be >0 and <1",Policy());
+       }
+       //Expressions to try
        //return location+scale*log(p/(1-p));
        //return location+scale*log1p((2*p-1)/(1-p));
-      
-      //return location - scale*log( (1-p)/p);
+
+       //return location - scale*log( (1-p)/p);
        //return location - scale*log1p((1-2*p)/p);
 
-      //return -scale*log(1/p-1) + location;
-      return -scale*log1p(1/p-2)+location;
-        
+       //return -scale*log(1/p-1) + location;
+       return location - scale * log1p((1 / p) - 2);
      } // RealType quantile(const logistic_distribution<RealType, Policy>& dist, const RealType& p)
     
     template <class RealType, class Policy>
     inline RealType cdf(const complemented2_type<logistic_distribution<RealType, Policy>, RealType>& c)
     {
-      RealType location = c.dist.location();
-      RealType scale = c.dist.scale();
-      RealType x = c.param;
-      static const char* function = "boost::math::cdf(const complement(logistic_distribution<%1%>&), %1%)";
-      
-      if((boost::math::isinf)(x))
-        {
+       BOOST_MATH_STD_USING
+       RealType location = c.dist.location();
+       RealType scale = c.dist.scale();
+       RealType x = c.param;
+       static const char* function = "boost::math::cdf(const complement(logistic_distribution<%1%>&), %1%)";
+
+       if((boost::math::isinf)(x))
+       {
           if(x < 0) return 1; // cdf complement -infinity is unity.
           return 0; // cdf complement +infinity is zero
-        }
-      RealType result;
-      if(false == detail::check_scale(function, scale, &result, Policy()))
-        return result;
-      if(false == detail::check_location(function, location, &result, Policy()))
-        return result;
-      if(false == detail::check_x(function, x, &result, Policy()))
-        return result;
-      BOOST_MATH_STD_USING
-      RealType power=(x-location)/scale;
-      return 1/( 1+exp(power) ); 
-      
+       }
+       RealType result;
+       if(false == detail::check_scale(function, scale, &result, Policy()))
+          return result;
+       if(false == detail::check_location(function, location, &result, Policy()))
+          return result;
+       if(false == detail::check_x(function, x, &result, Policy()))
+          return result;
+       RealType power = (x - location) / scale;
+       if(power > tools::log_max_value<RealType>())
+          return 0;
+       if(power < -tools::log_max_value<RealType>())
+          return 1;
+       return 1 / (1 + exp(power)); 
     } 
-      template <class RealType, class Policy>
-  inline RealType quantile(const complemented2_type<logistic_distribution<RealType, Policy>, RealType>& c)
-  {
-   RealType scale = c.dist.scale();
-   RealType location = c.dist.location();
-   static const char* function = "boost::math::quantile(const complement(logistic_distribution<%1%>&), %1%)";
-   RealType result;
-   if(false == detail::check_scale(function, scale, &result, Policy()))
-      return result;
-   if(false == detail::check_location(function, location, &result, Policy()))
-      return result;
-   RealType q = c.param;
-   if(false == detail::check_probability(function, q, &result, Policy()))
-      return result;
-   using boost::math::tools::max_value;
-
-
-      if(q == 1)
-        {
-          result=policies::raise_underflow_error<RealType>(function,"probability argument is 0, must be >0 and <1",Policy());
-          return result;
-          
-        }
-      if(q == 0)
-        {
-          result=policies::raise_overflow_error<RealType>(function,"probability argument is 0, must be >0 and <1",Policy());
-          return result;
-          
-        }
-   //Expressions to try 
-   BOOST_MATH_STD_USING
-     //return location+scale*log((1-q)/q);
-   return location+scale*log1p((1-2*q)/(q));
-   
-   //return location-scale*log(q/(1-q));
-   //return location-scale*log1p((2*q-1)/(1-q));
-   
-   //return location+scale*log(1/q-1);
-   //return location+scale*log1p(1/q-2);
 
-  } 
+    template <class RealType, class Policy>
+    inline RealType quantile(const complemented2_type<logistic_distribution<RealType, Policy>, RealType>& c)
+    {
+       BOOST_MATH_STD_USING
+       RealType scale = c.dist.scale();
+       RealType location = c.dist.location();
+       static const char* function = "boost::math::quantile(const complement(logistic_distribution<%1%>&), %1%)";
+       RealType result;
+       if(false == detail::check_scale(function, scale, &result, Policy()))
+          return result;
+       if(false == detail::check_location(function, location, &result, Policy()))
+          return result;
+       RealType q = c.param;
+       if(false == detail::check_probability(function, q, &result, Policy()))
+          return result;
+       using boost::math::tools::max_value;
+
+       if(q == 1)
+       {
+          return -policies::raise_overflow_error<RealType>(function,"probability argument is 1, but must be >0 and <1",Policy());
+       }
+       if(q == 0)
+       {
+          return policies::raise_overflow_error<RealType>(function,"probability argument is 0, but must be >0 and <1",Policy());
+       }
+       //Expressions to try 
+       //return location+scale*log((1-q)/q);
+       return location + scale * log1p((1 - 2 * q) / q);
+
+       //return location-scale*log(q/(1-q));
+       //return location-scale*log1p((2*q-1)/(1-q));
+
+       //return location+scale*log(1/q-1);
+       //return location+scale*log1p(1/q-2);
+    } 
     
     template <class RealType, class Policy>
     inline RealType mean(const logistic_distribution<RealType, Policy>& dist)
@@ -264,33 +249,28 @@
       BOOST_MATH_STD_USING
       RealType scale = dist.scale();
       return boost::math::constants::pi<RealType>()*boost::math::constants::pi<RealType>()*scale*scale/3;
-      
     } // RealType variance(const logistic_distribution<RealType, Policy>& dist)
     
     template <class RealType, class Policy>
     inline RealType mode(const logistic_distribution<RealType, Policy>& dist)
     {
-      
       return dist.location();
     }
     
     template <class RealType, class Policy>
     inline RealType median(const logistic_distribution<RealType, Policy>& dist)
     {
-      
       return dist.location();
     }
     template <class RealType, class Policy>
-    inline RealType skewness(const logistic_distribution<RealType, Policy>& dist)
+    inline RealType skewness(const logistic_distribution<RealType, Policy>& /*dist*/)
     {
-      
       return 0;
     } // RealType skewness(const logistic_distribution<RealType, Policy>& dist)
     
     template <class RealType, class Policy>
-    inline RealType kurtosis_excess(const logistic_distribution<RealType, Policy>& dist)
+    inline RealType kurtosis_excess(const logistic_distribution<RealType, Policy>& /*dist*/)
     {
-      
       return static_cast<RealType>(6)/5; 
     } // RealType kurtosis_excess(const logistic_distribution<RealType, Policy>& dist)
 

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/dist_reference.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/dist_reference.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/dist_reference.qbk	2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
@@ -13,6 +13,7 @@
 [include distributions/extreme_value.qbk]
 [include distributions/fisher.qbk]
 [include distributions/gamma.qbk]
+[include distributions/logistic.qbk]
 [include distributions/lognormal.qbk]
 [include distributions/negative_binomial.qbk]
 [include distributions/nc_beta.qbk]

Added: sandbox/math_toolkit/libs/math/doc/sf_and_dist/distributions/logistic.qbk
==============================================================================
--- (empty file)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/distributions/logistic.qbk	2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
@@ -0,0 +1,102 @@
+[section:logistic_dist Logistic Distribution]
+
+``#include <boost/math/distributions/logistic.hpp>``
+
+   namespace boost{ namespace math{ 
+      
+   template <class RealType = double, 
+             class ``__Policy``   = ``__policy_class`` >
+   class logistic_distribution;
+
+   template <class RealType, class Policy>
+   class logistic_distribution
+   {
+   public:
+      typedef RealType value_type;
+      typedef Policy   policy_type;
+      // Construct:
+      logistic_distribution(RealType location = 0, RealType scale = 1);
+      // Accessors:
+      RealType location()const; // location.
+      RealType scale()const; // scale.
+      
+   };
+
+   typedef logistic_distribution<> logistic;
+
+   }} // namespaces
+   
+The logistic distribution is a continous probability distribution. 
+It has two parameters - location and scale.  The cumulative distribution 
+function of the logistic distribution appears in logistic regression 
+and feedforward neural networks. Among other applications, 
+United State Chess Federation and FIDE use it to calculate chess ratings.
+
+The following graph shows how the distribution changes as the
+parameters change:
+
+[graph logistic_pdf]
+
+[h4 Member Functions]
+
+   logistic_distribution(RealType u = 0, RealType s = 1);
+
+Constructs a logistic distribution with location /u/ and scale /s/.
+
+Requires `scale > 0`, otherwise a __domain_error is raised.
+
+   RealType location()const;   
+
+Returns the location of this distribution.
+
+   RealType scale()const;
+
+Returns the scale of this distribution. 
+
+[h4 Non-member Accessors]
+
+All the [link math_toolkit.dist.dist_ref.nmp usual non-member accessor functions]
+that are generic to all distributions are supported: __usual_accessors.
+
+The domain of the random variable is \[-\[max_value\], +\[min_value\]\]. 
+However, the pdf and cdf support inputs of +[infin] and -[infin]
+as special cases if RealType permits.
+
+At `p=1` and `p=0`, the quantile function returns the result of 
++__overflow_error and -__overflow_error, while the compliment 
+quantile function returns the result of -__overflow_error and 
++__overflow_error respectively. 
+
+[h4 Accuracy]
+
+The logistic distribution is implemented in terms of the `std::exp` 
+and the `std::log` functions, so it's accuracy is related to the 
+accurate implementations of those functions on a given platform. 
+While calculating the quantile and the inverse quantile, some 
+non-zero position values might cause catastrophic cancellation errors. 
+In such cases, only a low /absolute error/ can be guarenteed.
+
+[h4 Implementation]
+
+[table
+[[Function][Implementation Notes]]
+[[pdf][Using the relation: pdf = e[super -(x-u)/s] / (s*(1+e[super -(x-u)/s])[super 2])]]
+[[cdf][Using the relation: p = 1/(1+e[super -(x-u)/s])]]
+[[cdf complement][Using the relation: q = 1/(1+e[super (x-u)/s])]]
+[[quantile][Using the relation: x = u - s*log(1/p-1)]]
+[[quantile from the complement][Using the relation: x = u + s*log(p/1-p)]]
+[[mean][u]]
+[[mode][The same as the mean.]]
+[[skewness][0]]
+[[kurtosis excess][6/5]]
+[[variance][ ([pi]*s)[super 2] / 3]]
+]
+
+[endsect]
+
+[/ logistic.qbk
+  Copyright 2006, 2007 John Maddock and Paul A. Bristow.
+  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).
+]

Added: sandbox/math_toolkit/libs/math/doc/sf_and_dist/graphs/logistic_pdf.png
==============================================================================
Binary file. No diff available.

Added: sandbox/math_toolkit/libs/math/doc/sf_and_dist/graphs/logistic_pdf.svg
==============================================================================
Binary file. No diff available.

Modified: sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk	(original)
+++ sandbox/math_toolkit/libs/math/doc/sf_and_dist/roadmap.qbk	2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
@@ -4,6 +4,7 @@
 
 * Added support for MPFR as a bignum type.
 * Added some full specializations of the policy classes to reduce compile times.
+* Added logistic distribution, from Gautam Sewani's Google Summer of Code project.
 
 [h4 Boost-1.37.0]
 

Copied: sandbox/math_toolkit/libs/math/test/test_logistic_dist.cpp (from r49389, /sandbox/SOC/2008/parrallel_math/libs/math/test/gsoc_test_logistic_dist.cpp)
==============================================================================
--- /sandbox/SOC/2008/parrallel_math/libs/math/test/gsoc_test_logistic_dist.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_logistic_dist.cpp	2008-10-29 09:10:08 EDT (Wed, 29 Oct 2008)
@@ -1,20 +1,14 @@
-
-
-// Copyright John Maddock 
-// Copyright Paul A. Bristow 
-// Copyright Gautam Sewani
+// Copyright 2008 Gautam Sewani
 
 // Use, modification and distribution are subject to 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)
 
-
-
 #define BOOST_MATH_UNDERFLOW_ERROR_POLICY throw_on_error
 #define BOOST_MATH_OVERFLOW_ERROR_POLICY throw_on_error
 #include <boost/math/concepts/real_concept.hpp> // for real_concept
-#include <boost/math/distributions/gsoc_logistic.hpp>
+#include <boost/math/distributions/logistic.hpp>
     using boost::math::logistic_distribution;
 
 #include <boost/test/included/test_exec_monitor.hpp> // Boost.Test
@@ -32,33 +26,33 @@
 {
    BOOST_CHECK_CLOSE(
       ::boost::math::cdf(
-         logistic_distribution<RealType>(location,scale),      
-         x),
-         p,
-         tolerance); // %
+      logistic_distribution<RealType>(location,scale),      
+      x),
+      p,
+      tolerance); // %
    BOOST_CHECK_CLOSE(
       ::boost::math::cdf(
-         complement(logistic_distribution<RealType>(location,scale),      
-         x)),
-         q,
-         tolerance); // %
+      complement(logistic_distribution<RealType>(location,scale),      
+      x)),
+      q,
+      tolerance); // %
    if(p < 0.999)
    {
       BOOST_CHECK_CLOSE(
          ::boost::math::quantile(
-            logistic_distribution<RealType>(location,scale),      
-            p),
-            x,
-            tolerance); // %
+         logistic_distribution<RealType>(location,scale),      
+         p),
+         x,
+         tolerance); // %
    }
    if(q < 0.999)
    {
       BOOST_CHECK_CLOSE(
          ::boost::math::quantile(
-            complement(logistic_distribution<RealType>(location,scale),      
-            q)),
-            x,
-            tolerance); // %
+         complement(logistic_distribution<RealType>(location,scale),      
+         q)),
+         x,
+         tolerance); // %
    }
 }
 
@@ -73,15 +67,15 @@
       static_cast<RealType>(1e-33L),
       boost::math::tools::epsilon<RealType>());
    cout<<"Absolute tolerance:"<<tolerance<<endl;
-   
+
    tolerance *= 50 * 100; 
    // #  pragma warning(disable: 4100) // unreferenced formal parameter.
    // prevent his spurious warning.
    if (T != 0)
    {
-     cout << "Expect parameter T == 0!" << endl;
+      cout << "Expect parameter T == 0!" << endl;
    }
-    cout << "Tolerance for type " << typeid(T).name()  << " is " << tolerance << " %" << endl;
+   cout << "Tolerance for type " << typeid(T).name()  << " is " << tolerance << " %" << endl;
 
    test_spot(
       static_cast<RealType>(1), // location
@@ -98,8 +92,8 @@
       static_cast<RealType>(0.281215878622547904873088053477813L), // p
       static_cast<RealType>(0.718784121377452095126911946522187L), //q
       tolerance);
-      
-      test_spot(
+
+   test_spot(
       static_cast<RealType>(1.2345L), // location
       static_cast<RealType>(0.12345L), // scale
       static_cast<RealType>(3.123123123L),//x
@@ -108,14 +102,12 @@
       tolerance);
 
 
-    //High probability
-    test_spot(
+   //High probability
+   test_spot(
       static_cast<RealType>(1), // location
       static_cast<RealType>(0.5L), // scale
       static_cast<RealType>(10), // x
       static_cast<RealType>(0.99999998477002048723965105559179L), // p  
-
-
       static_cast<RealType>(1.5229979512760348944408208801237e-8L), //q
       tolerance);
 
@@ -127,8 +119,8 @@
       static_cast<RealType>(0.0724264853615177178439235061476928L), // p
       static_cast<RealType>(0.927573514638482282156076493852307L), //q
       tolerance);
-   
-   
+
+
    test_spot(
       static_cast<RealType>(5), // location
       static_cast<RealType>(2), // scale
@@ -138,10 +130,6 @@
       tolerance);
 
 
-   
-
-   
-  
    //test value to check cancellation error in straight/complimented quantile 
    //the subtraction in the formula location-scale*log term introduces catastrophics cancellator error if location and scale*log term are close
    //For these values, the tests fail at tolerance, but work at 100*tolerance
@@ -153,24 +141,24 @@
       static_cast<RealType>(0.3L), //q
       80*tolerance);   
 
-  test_spot(
+   test_spot(
       static_cast<RealType>(1.2345L), // location
       static_cast<RealType>(0.12345L), // scale
       static_cast<RealType>(0.0012345L), // x
       static_cast<RealType>(0.0000458541039469413343331170952855318L), // p
       static_cast<RealType>(0.999954145896053058665666882904714L), //q
       80*tolerance);
- 
 
-  
+
+
    test_spot(
       static_cast<RealType>(5L), // location
       static_cast<RealType>(2L), // scale
       static_cast<RealType>(0.0012345L), // x
       static_cast<RealType>(0.0759014628704232983512906076564256L), // p
       static_cast<RealType>(0.924098537129576701648709392343574L), //q
-        80*tolerance);
-  
+      80*tolerance);
+
    //negative location
    test_spot(
       static_cast<RealType>(-123.123123L), // location
@@ -179,49 +167,48 @@
       static_cast<RealType>(0.999999999999999999999999984171276L), // p
       static_cast<RealType>(1.58287236765203121622150720373972e-26L), //q
       tolerance);
-//PDF Testing
+   //PDF Testing
    BOOST_CHECK_CLOSE(
       ::boost::math::pdf(
-         logistic_distribution<RealType>(5,2),      
+      logistic_distribution<RealType>(5,2),      
          static_cast<RealType>(0.125L) ),//x
          static_cast<RealType>(0.0369500730133475464584898192104821L),              // probability
-         tolerance); // %
+      tolerance); // %
 
    BOOST_CHECK_CLOSE(
       ::boost::math::pdf(
-         logistic_distribution<RealType>(1.2345L,0.12345L),      
+         logistic_distribution<RealType>(static_cast<RealType>(1.2345L), static_cast<RealType>(0.12345L)),      
          static_cast<RealType>(0.0012345L) ),//x
          static_cast<RealType>(0.000371421639109700748742498671686243L),              // probability
-         tolerance); // %
+      tolerance); // %
    BOOST_CHECK_CLOSE(
       ::boost::math::pdf(
-         logistic_distribution<RealType>(2,1),      
+      logistic_distribution<RealType>(2,1),      
          static_cast<RealType>(2L) ),//x
          static_cast<RealType>(0.25L),              // probability
-         tolerance); // %
-
-//Extreme value testing
+      tolerance); // %
 
-  if(std::numeric_limits<RealType>::has_infinity)
-  {
-    BOOST_CHECK_EQUAL(pdf(logistic_distribution<RealType>(), +std::numeric_limits<RealType>::infinity()), 0); // x = + infinity, pdf = 0
-    BOOST_CHECK_EQUAL(pdf(logistic_distribution<RealType>(), -std::numeric_limits<RealType>::infinity()), 0); // x = - infinity, pdf = 0
-    BOOST_CHECK_EQUAL(cdf(logistic_distribution<RealType>(), +std::numeric_limits<RealType>::infinity()), 1); // x = + infinity, cdf = 1
-    BOOST_CHECK_EQUAL(cdf(logistic_distribution<RealType>(), -std::numeric_limits<RealType>::infinity()), 0); // x = - infinity, cdf = 0
-    BOOST_CHECK_EQUAL(cdf(complement(logistic_distribution<RealType>(), +std::numeric_limits<RealType>::infinity())), 0); // x = + infinity, c cdf = 0
-    BOOST_CHECK_EQUAL(cdf(complement(logistic_distribution<RealType>(), -std::numeric_limits<RealType>::infinity())), 1); // x = - infinity, c cdf = 1
-    //Does the quantile return max_value or infinity? 
-    /*
-    BOOST_CHECK_EQUAL(quantile(logistic_distribution<RealType>(), static_cast<RealType>(1)), +std::numeric_limits<RealType>::infinity()); // x = + infinity, cdf = 1
-    BOOST_CHECK_EQUAL(quantile(logistic_distribution<RealType>(), static_cast<RealType>(0)), -std::numeric_limits<RealType>::infinity()); // x = - infinity, cdf = 0
-    BOOST_CHECK_EQUAL(quantile(complement(logistic_distribution<RealType>(), static_cast<RealType>(0))), +std::numeric_limits<RealType>::infinity()); 
-// x = + infinity, c cdf = 0
-    BOOST_CHECK_EQUAL(quantile(complement(logistic_distribution<RealType>(), static_cast<RealType>(1))), -std::numeric_limits<RealType>::infinity()); 
-    */
+   //Extreme value testing
 
-  }
-
-   
+   if(std::numeric_limits<RealType>::has_infinity)
+   {
+      BOOST_CHECK_EQUAL(pdf(logistic_distribution<RealType>(), +std::numeric_limits<RealType>::infinity()), 0); // x = + infinity, pdf = 0
+      BOOST_CHECK_EQUAL(pdf(logistic_distribution<RealType>(), -std::numeric_limits<RealType>::infinity()), 0); // x = - infinity, pdf = 0
+      BOOST_CHECK_EQUAL(cdf(logistic_distribution<RealType>(), +std::numeric_limits<RealType>::infinity()), 1); // x = + infinity, cdf = 1
+      BOOST_CHECK_EQUAL(cdf(logistic_distribution<RealType>(), -std::numeric_limits<RealType>::infinity()), 0); // x = - infinity, cdf = 0
+      BOOST_CHECK_EQUAL(cdf(complement(logistic_distribution<RealType>(), +std::numeric_limits<RealType>::infinity())), 0); // x = + infinity, c cdf = 0
+      BOOST_CHECK_EQUAL(cdf(complement(logistic_distribution<RealType>(), -std::numeric_limits<RealType>::infinity())), 1); // x = - infinity, c cdf = 1
+   }
+   BOOST_CHECK_THROW(quantile(logistic_distribution<RealType>(), static_cast<RealType>(1)), std::overflow_error); // x = + infinity, cdf = 1
+   BOOST_CHECK_THROW(quantile(logistic_distribution<RealType>(), static_cast<RealType>(0)), std::overflow_error); // x = - infinity, cdf = 0
+   BOOST_CHECK_THROW(quantile(complement(logistic_distribution<RealType>(), static_cast<RealType>(1))), std::overflow_error); // x = - infinity, cdf = 0
+   BOOST_CHECK_THROW(quantile(complement(logistic_distribution<RealType>(), static_cast<RealType>(0))), std::overflow_error); // x = + infinity, cdf = 1
+   BOOST_CHECK_EQUAL(cdf(logistic_distribution<RealType>(), +boost::math::tools::max_value<RealType>()), 1); // x = + infinity, cdf = 1
+   BOOST_CHECK_EQUAL(cdf(logistic_distribution<RealType>(), -boost::math::tools::max_value<RealType>()), 0); // x = - infinity, cdf = 0
+   BOOST_CHECK_EQUAL(cdf(complement(logistic_distribution<RealType>(), +boost::math::tools::max_value<RealType>())), 0); // x = + infinity, c cdf = 0
+   BOOST_CHECK_EQUAL(cdf(complement(logistic_distribution<RealType>(), -boost::math::tools::max_value<RealType>())), 1); // x = - infinity, c cdf = 1
+   BOOST_CHECK_EQUAL(pdf(logistic_distribution<RealType>(), +boost::math::tools::max_value<RealType>()), 0); // x = + infinity, pdf = 0
+   BOOST_CHECK_EQUAL(pdf(logistic_distribution<RealType>(), -boost::math::tools::max_value<RealType>()), 0); // x = - infinity, pdf = 0
 
    //
    // Things that are errors:
@@ -229,100 +216,90 @@
    //2. x being NAN
    //3. Probabilies being outside (0,1)
 
-   
-  
+   //location/scale can't be infinity
+   if(std::numeric_limits<RealType>::has_infinity) {
+      BOOST_CHECK_THROW(
+         logistic_distribution<RealType> dist(std::numeric_limits<RealType>::infinity(),0.5),
+         std::domain_error);
+      BOOST_CHECK_THROW(
+         logistic_distribution<RealType> dist(0.5,std::numeric_limits<RealType>::infinity()),
+         std::domain_error);
+   }
+   //scale can't be negative or 0
+   BOOST_CHECK_THROW(
+      logistic_distribution<RealType> dist(0.5,-0.5),
+      std::domain_error);
+   BOOST_CHECK_THROW(
+      logistic_distribution<RealType> dist(0.5,0),
+      std::domain_error);
 
+   logistic_distribution<RealType> dist(0.5,0.5);
+   //x can't be NaN,p can't be NaN
 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      // No longer allow x to be NaN, then these tests should throw.
+      BOOST_CHECK_THROW(pdf(dist, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
+      BOOST_CHECK_THROW(cdf(dist, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
+      BOOST_CHECK_THROW(cdf(complement(dist, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // x = + infinity
+      BOOST_CHECK_THROW(quantile(dist, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // p = + infinity
+      BOOST_CHECK_THROW(quantile(complement(dist, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // p = + infinity
+   }
 
-  //location/scale can't be infinity
-  if(std::numeric_limits<RealType>::has_infinity) {
-    BOOST_CHECK_THROW(
-       logistic_distribution<RealType> dist(std::numeric_limits<RealType>::infinity(),0.5),
-       std::domain_error);
-    BOOST_CHECK_THROW(
-       logistic_distribution<RealType> dist(0.5,std::numeric_limits<RealType>::infinity()),
-       std::domain_error);
-  }
-  //scale can't be negative or 0
-    BOOST_CHECK_THROW(
-       logistic_distribution<RealType> dist(0.5,-0.5),
-       std::domain_error);
-    BOOST_CHECK_THROW(
-       logistic_distribution<RealType> dist(0.5,0),
-       std::domain_error);
-
-    logistic_distribution<RealType> dist(0.5,0.5);
-  //x can't be NaN,p can't be NaN
-
-    if (std::numeric_limits<RealType>::has_quiet_NaN)
-      {
-        // No longer allow x to be NaN, then these tests should throw.
-        BOOST_CHECK_THROW(pdf(dist, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
-        BOOST_CHECK_THROW(cdf(dist, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
-        BOOST_CHECK_THROW(cdf(complement(dist, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // x = + infinity
-        BOOST_CHECK_THROW(quantile(dist, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // p = + infinity
-        BOOST_CHECK_THROW(quantile(complement(dist, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // p = + infinity
-      }
-
-    //p can't be outside (0,1)
-    BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(1.1)), std::domain_error); 
-    BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(-0.1)), std::domain_error);
-    BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(1)), std::overflow_error); 
-    BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(0)), std::underflow_error);
-
-    BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(1.1))), std::domain_error); 
-    BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(-0.1))), std::domain_error);
-    BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(1))), std::underflow_error); 
-    BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(0))), std::overflow_error); 
-    
-    
-    //Tests for mean,mode,median,variance,skewness,kurtosis
-    
-
-    //mean
-    BOOST_CHECK_CLOSE(
-         ::boost::math::mean(
-         logistic_distribution<RealType>(2,1)      
-         ),//x
-         static_cast<RealType>(2),              // probability
-         tolerance); // %
-    //median
-    BOOST_CHECK_CLOSE(
-         ::boost::math::median(
-         logistic_distribution<RealType>(2,1)      
-         ),//x
-         static_cast<RealType>(2),              // probability
-         tolerance);
-    //mode
-    BOOST_CHECK_CLOSE(
-         ::boost::math::mode(
-         logistic_distribution<RealType>(2,1)      
-         ),//x
-         static_cast<RealType>(2),              // probability
-         tolerance);
-    //variance
-    BOOST_CHECK_CLOSE(
-         ::boost::math::variance(
-         logistic_distribution<RealType>(2,1)      
-         ),//x
-         static_cast<RealType>(3.28986813369645287294483033329205L),              // probability
-         tolerance);
-    //skewness
-    BOOST_CHECK_CLOSE(
-         ::boost::math::skewness(
-         logistic_distribution<RealType>(2,1)      
-         ),//x
-         static_cast<RealType>(0),              // probability
-         tolerance);
-    BOOST_CHECK_CLOSE(
-         ::boost::math::kurtosis_excess(
-         logistic_distribution<RealType>(2,1)      
-         ),//x
-         static_cast<RealType>(1.2L),              // probability
-         tolerance);
+   //p can't be outside (0,1)
+   BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(1.1)), std::domain_error); 
+   BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(-0.1)), std::domain_error);
+   BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(1)), std::overflow_error); 
+   BOOST_CHECK_THROW(quantile(dist, static_cast<RealType>(0)), std::overflow_error);
+
+   BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(1.1))), std::domain_error); 
+   BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(-0.1))), std::domain_error);
+   BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(1))), std::overflow_error); 
+   BOOST_CHECK_THROW(quantile(complement(dist, static_cast<RealType>(0))), std::overflow_error); 
 
+   //Tests for mean,mode,median,variance,skewness,kurtosis
+   //mean
+   BOOST_CHECK_CLOSE(
+      ::boost::math::mean(
+      logistic_distribution<RealType>(2,1)      
+      ),//x
+      static_cast<RealType>(2),              // probability
+      tolerance); // %
+   //median
+   BOOST_CHECK_CLOSE(
+      ::boost::math::median(
+      logistic_distribution<RealType>(2,1)      
+      ),//x
+      static_cast<RealType>(2),              // probability
+      tolerance);
+   //mode
+   BOOST_CHECK_CLOSE(
+      ::boost::math::mode(
+      logistic_distribution<RealType>(2,1)      
+      ),//x
+      static_cast<RealType>(2),              // probability
+      tolerance);
+   //variance
+   BOOST_CHECK_CLOSE(
+      ::boost::math::variance(
+      logistic_distribution<RealType>(2,1)      
+      ),//x
+      static_cast<RealType>(3.28986813369645287294483033329205L),              // probability
+      tolerance);
+   //skewness
+   BOOST_CHECK_CLOSE(
+      ::boost::math::skewness(
+      logistic_distribution<RealType>(2,1)      
+      ),//x
+      static_cast<RealType>(0),              // probability
+      tolerance);
+   BOOST_CHECK_CLOSE(
+      ::boost::math::kurtosis_excess(
+      logistic_distribution<RealType>(2,1)      
+      ),//x
+      static_cast<RealType>(1.2L),              // probability
+      tolerance);
 
-    
 } // template <class RealType>void test_spots(RealType)