// boost_math.h

// Copyright John Maddock 2007.
// Copyright Paul A. Bristow 2007.

// 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_OVERFLOW_ERROR_POLICY errno_on_error
//#define BOOST_MATH_ASSERT_UNDEFINED_POLICY false
// These are now defined in project properties
// "BOOST_MATH_ASSERT_UNDEFINED_POLICY=0"
// "BOOST_MATH_OVERFLOW_ERROR_POLICY=errno_on_error"
// to avoid complications with pre-compiled headers.

#pragma once

using namespace System;

#define TRANSLATE_EXCEPTIONS_BEGIN try{

#define TRANSLATE_EXCEPTIONS_END \
    }catch(const std::exception& e){  \
        System::String^ s = gcnew System::String(e.what());\
        InvalidOperationException^ se = gcnew InvalidOperationException(s);\
        throw se;  \
    }

namespace boost_math {

   class any_imp
   {
   public:
     // Distribution properties.
      virtual double mean()const = 0;
      virtual double mode()const = 0;
      virtual double median()const = 0;
      virtual double variance()const = 0;
      virtual double standard_deviation()const = 0;
      virtual double skewness()const = 0;
      virtual double kurtosis()const = 0;
      virtual double kurtosis_excess()const = 0;
      virtual double coefficient_of_variation()const = 0;
      // Values computed from random variate x.
      virtual double hazard(double x)const = 0;
      virtual double chf(double x)const = 0;
      virtual double cdf(double x)const = 0;
      virtual double ccdf(double x)const = 0;
      virtual double pdf(double x)const = 0;
      virtual double quantile(double x)const = 0;
      virtual double quantile_c(double x)const = 0;
      // Range & support of x
      virtual double lowest()const = 0;
      virtual double uppermost()const = 0;
      virtual double lower()const = 0;
      virtual double upper()const = 0;
   };

   template <class Distribution>
   class concrete_distribution : public any_imp
   {
   public:
      concrete_distribution(const Distribution& d) : m_dist(d) {}
      // Distribution properties.
      virtual double mean()const
      {
         return boost::math::mean(m_dist);
      }
      virtual double median()const
      {
         return boost::math::median(m_dist);
      }
      virtual double mode()const
      {
         return boost::math::mode(m_dist);
      }
      virtual double variance()const
      {
         return boost::math::variance(m_dist);
      }
      virtual double skewness()const
      {
         return boost::math::skewness(m_dist);
      }
      virtual double standard_deviation()const
      {
         return boost::math::standard_deviation(m_dist);
      }
      virtual double coefficient_of_variation()const
      {
         return boost::math::coefficient_of_variation(m_dist);
      }
      virtual double kurtosis()const
      {
         return boost::math::kurtosis(m_dist);
      }
      virtual double kurtosis_excess()const
      {
         return boost::math::kurtosis_excess(m_dist);
      }
      // Range of x for the distribution.
      virtual double lowest()const
      {
         return boost::math::range(m_dist).first;
      }
      virtual double uppermost()const
      {
         return boost::math::range(m_dist).second;
      }
      // Support of x for the distribution.
      virtual double lower()const
      {
         return boost::math::support(m_dist).first;
      }
      virtual double upper()const
      {
         return boost::math::support(m_dist).second;
      }

      // Values computed from random variate x.
      virtual double hazard(double x)const
      {
         return boost::math::hazard(m_dist, x);
      }
      virtual double chf(double x)const
      {
         return boost::math::chf(m_dist, x);
      }
      virtual double cdf(double x)const
      {
         return boost::math::cdf(m_dist, x);
      }
      virtual double ccdf(double x)const
      {
         return boost::math::cdf(complement(m_dist, x));
      }
      virtual double pdf(double x)const
      {
         return boost::math::pdf(m_dist, x);
      }
      virtual double quantile(double x)const
      {
         return boost::math::quantile(m_dist, x);
      }
      virtual double quantile_c(double x)const
      {
         return boost::math::quantile(complement(m_dist, x));
      }
   private:
      Distribution m_dist;
   };

   public ref class any_distribution
   {
     public:
      // Added methods for this class here.
      any_distribution(int t, double arg1, double arg2, double arg3);
      ~any_distribution()
      {
         reset(0);
      }
      // Is it OK for these to be inline?
      // Distribution properties as 'pointer-to-implementions'.
      double mean()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->mean();
         TRANSLATE_EXCEPTIONS_END
      }
      double median()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->median();
         TRANSLATE_EXCEPTIONS_END
      }
      double mode()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->mode();
         TRANSLATE_EXCEPTIONS_END
      }
      double variance()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->variance();
         TRANSLATE_EXCEPTIONS_END
      }
      double standard_deviation()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->standard_deviation();
         TRANSLATE_EXCEPTIONS_END
      }
      double coefficient_of_variation()
      { // aka Relative Standard deviation.
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->coefficient_of_variation();
         TRANSLATE_EXCEPTIONS_END
      }
      double skewness()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->skewness();
         TRANSLATE_EXCEPTIONS_END
      }
      double kurtosis()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->kurtosis();
         TRANSLATE_EXCEPTIONS_END
      }
      double kurtosis_excess()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->kurtosis_excess();
         TRANSLATE_EXCEPTIONS_END
      }
      // Values computed from random variate x.
      double hazard(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->hazard(x);
         TRANSLATE_EXCEPTIONS_END
      }
      double chf(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->chf(x);
         TRANSLATE_EXCEPTIONS_END
      }
      double cdf(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->cdf(x);
         TRANSLATE_EXCEPTIONS_END
      }
      double ccdf(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->ccdf(x);
         TRANSLATE_EXCEPTIONS_END
     }
      double pdf(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->pdf(x);
         TRANSLATE_EXCEPTIONS_END
      }
      double quantile(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->quantile(x);
         TRANSLATE_EXCEPTIONS_END
      }
      double quantile_c(double x)
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->quantile_c(x);
         TRANSLATE_EXCEPTIONS_END
      }

      double lowest()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->lowest();
         TRANSLATE_EXCEPTIONS_END
      }

      double uppermost()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->uppermost();
         TRANSLATE_EXCEPTIONS_END
      }

      double lower()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->lower();
         TRANSLATE_EXCEPTIONS_END
      }
      double upper()
      {
         TRANSLATE_EXCEPTIONS_BEGIN
         return pimpl->upper();
         TRANSLATE_EXCEPTIONS_END
      }

      // How many distributions are supported:
      static int size();
      // Display name of i'th distribution:
      static System::String^ distribution_name(int i);
      // Name of first distribution parameter, or null if not supported:
      static System::String^ first_param_name(int i);
      // Name of second distribution parameter, or null if not supported:
      static System::String^ second_param_name(int i);
      // Name of third distribution parameter, or null if not supported:
      static System::String^ third_param_name(int i);
      // Default value for first parameter:
      static double first_param_default(int i);
      // Default value for second parameter:
      static double second_param_default(int i);
      // Default value for third parameter:
      static double third_param_default(int i);

   private:
      any_distribution(const any_distribution^)
      { // Constructor is private.
      }
      const any_distribution^ operator=(const any_distribution^ d)
      { // Copy Constructor is private too.
         return d;
      }
      // We really should use a shared_ptr here, 
      // but apparently it's not allowed in a managed class like this :-(
      void reset(any_imp* p)
      {
         if(pimpl)
         { // Exists already, so
            delete pimpl;
         }
         pimpl = p;
      }
      any_imp* pimpl;
   };
}