initial implementation

include/xo/distribution/Exponential.hpp

@@ -0,0 +1,94 @@
+/* @file Exponential.hpp */
+
+#pragma once
+
+#include "xo/distribution/Distribution.hpp"
+#include <limits>
+#include <cmath>
+
+namespace xo {
+    namespace distribution {
+        /* Exponential probability distribution */
+        class Exponential : public Distribution<double> {
+        public:
+            explicit Exponential(double lm) : lambda_(lm) {}
+
+            /* exponential probability density:
+             *
+             *                    -lm.x
+             *    p(x) = {  lm . e      ,  x > 0
+             *           {  0           ,  x <= 0
+             *
+             */
+            static double density_impl(double lambda, double x) {
+                if(x <= 0.0)
+                    return 0.0;
+
+                return lambda * ::exp(-lambda * x);
+            } /*density_impl*/
+
+            /* exponential distribution:
+             *
+             *                -lm.x
+             *    F(x) = 1 - e         , x > 0
+             *    F(x) = 0             , x <= 0
+             */
+            static double distr_impl(double lambda, double x) {
+                if(x <= 0.0)
+                    return 0.0;
+
+                return 1.0 - ::exp(-lambda * x);
+            } /*distr_impl*/
+
+            /* compute x: F(x)=y,  where F(x)
+             * is the cumulative exponential probability distributio.
+             *
+             *                -lm.x
+             *    F(x) = 1 - e        , x>0
+             *
+             *     -lm.x
+             *    e      = 1 - F(x)
+             *
+             *    -lm.x  = ln(1 - F(x))
+             *
+             *    x      = -ln(1 - F(x)) / lm,   0 < F(x) < 1
+             */
+            static double distr_inverse_impl(double lambda, double Fx) {
+                if(Fx < 0.0)
+                    return -1.0 * std::numeric_limits<double>::infinity();
+                if(Fx >= 1.0)
+                    return +1.0 * std::numeric_limits<double>::infinity();
+
+                return (-1.0 / lambda) *  ::log(1.0 - Fx);
+            } /*distr_inverse_impl*/
+
+            double lambda() const { return lambda_; }
+
+            double density(double x) const {
+                return density_impl(this->lambda_, x);
+            } /*density*/
+
+            double distribution(double x) const {
+                return distr_impl(this->lambda_, x);
+            } /*distribution*/
+
+            double distribution_inverse(double y) const {
+                return distr_inverse_impl(this->lambda_, y);
+            } /*distribution_inverse*/
+
+            // ----- inherited from Distribution<double> -----
+
+            virtual double cdf(double const & x) const override {
+                return distribution(x);
+            } /*cdf*/
+
+        private:
+            /* intensity parameter.
+             * require: lambda > 0
+             */
+            double lambda_ = 1.0;
+        }; /*Exponential*/
+    } /*namespace distribution*/
+} /*namespace xo*/
+
+/* end Exponential.cpp */