Merge pull request #326 from JuliaStats/dh/doc3

Updated documentation

src/univariate/continuous/cauchy.jl

@@ -1,24 +1,24 @@
 immutable Cauchy <: ContinuousUnivariateDistribution
-    x0::Float64
-    γ::Float64
+    μ::Float64
+    β::Float64
 
-    function Cauchy(x0::Real, γ::Real)
-        γ > zero(γ) || error("scale must be positive")
-        new(float64(x0), float64(γ))
+    function Cauchy(μ::Real, β::Real)
+        β > zero(β) || error("Cauchy: scale must be positive")
+        new(float64(μ), float64(β))
     end
 
-    Cauchy(x0::Real) = new(float64(x0), 1.0)
+    Cauchy(μ::Real) = new(float64(μ), 1.0)
     Cauchy() = new(0.0, 1.0)
 end
 
 @distr_support Cauchy -Inf Inf
 
 #### Parameters
 
-location(d::Cauchy) = d.x0
-scale(d::Cauchy) = d.γ
+location(d::Cauchy) = d.μ
+scale(d::Cauchy) = d.β
 
-params(d::Cauchy) = (d.x0, d.γ)
+params(d::Cauchy) = (d.μ, d.β)
 
 
 #### Statistics
@@ -36,36 +36,30 @@ entropy(d::Cauchy) = log(scale(d)) + log4π
 
 #### Functions
 
-function pdf(d::Cauchy, x::Float64)
-    x0, γ = params(d)
-    z = (x - x0) / γ
-    1.0 / (π * γ * (1 + z^2))
-end
+zval(d::Cauchy, x::Float64) = (x - d.μ) / d.β
+xval(d::Cauchy, z::Float64) = d.μ + z * d.β
 
-function logpdf(d::Cauchy, x::Float64)
-    x0, γ = params(d)
-    z = (x - x0) / γ
-    - (logπ + log(γ) + log1psq(z))
-end
+pdf(d::Cauchy, x::Float64) = 1.0 / (π * scale(d) * (1 + zval(d, x)^2))
+logpdf(d::Cauchy, x::Float64) = - (logπ + log(scale(d)) + log1psq(zval(d, x)))
 
 function cdf(d::Cauchy, x::Float64)
-    x0, γ = params(d)
-    invπ * atan2(x - x0, γ) + 0.5
+    μ, β = params(d)
+    invπ * atan2(x - μ, β) + 0.5
 end
 
 function ccdf(d::Cauchy, x::Float64)
-    x0, γ = params(d)
-    invπ * atan2(x0 - x, γ) + 0.5
+    μ, β = params(d)
+    invπ * atan2(μ - x, β) + 0.5
 end
 
 function quantile(d::Cauchy, p::Float64)
-    x0, γ = params(d)
-    x0 + γ * tan(π * (p - 0.5))
+    μ, β = params(d)
+    μ + β * tan(π * (p - 0.5))
 end
 
 function cquantile(d::Cauchy, p::Float64)
-    x0, γ = params(d)
-    x0 + γ * tan(π * (0.5 - p))
+    μ, β = params(d)
+    μ + β * tan(π * (0.5 - p))
 end
 
 mgf(d::Cauchy, t::Real) = t == zero(t) ? 1.0 : NaN

src/univariate/continuous/erlang.jl

@@ -12,14 +12,14 @@ end
 
 @distr_support Erlang 0.0 Inf
 
-show(io::IO, d::Erlang) = ((α, θ) = params(d); show_oneline(io, d, [(:α, α), (:θ, θ)]))
+show(io::IO, d::Erlang) = ((α, β) = params(d); show_oneline(io, d, [(:α, α), (:β, β)]))
 
 #### Parameters
 
 shape(d::Erlang) = int(shape(d.gammad))
 scale(d::Erlang) = scale(d.gammad)
 rate(d::Erlang) = rate(d.gammad)
-params(d::Erlang) = ((α, θ) = params(d.gammad); (int(α), θ))
+params(d::Erlang) = ((α, β) = params(d.gammad); (int(α), β))
 
 
 #### Statistics

src/univariate/continuous/frechet.jl

@@ -1,12 +1,10 @@
-# Fréchet Distribution
-
 immutable Frechet <: ContinuousUnivariateDistribution
     α::Float64
-    s::Float64
+    β::Float64
 
-    function Frechet(α::Real, s::Real)
-    	α > zero(α) && s > zero(s) || error("Both shape and scale must be positive")
-    	new(float64(α), float64(s))
+    function Frechet(α::Real, β::Real)
+    	α > zero(α) && β > zero(β) || error("Both shape and scale must be positive")
+    	new(float64(α), float64(β))
     end
 
     Frechet(α::Real) = Frechet(α, 1.0)
@@ -19,22 +17,22 @@ end
 #### Parameters
 
 shape(d::Frechet) = d.α
-scale(d::Frechet) = d.s
-params(d::Frechet) = (d.α, d.s)
+scale(d::Frechet) = d.β
+params(d::Frechet) = (d.α, d.β)
 
 
 #### Statistics
 
-mean(d::Frechet) = (α = d.α; α > 1.0 ? d.s * gamma(1.0 - 1.0 / α) : Inf)
+mean(d::Frechet) = (α = d.α; α > 1.0 ? d.β * gamma(1.0 - 1.0 / α) : Inf)
 
-median(d::Frechet) = d.s * logtwo^(-1.0 / d.α)
+median(d::Frechet) = d.β * logtwo^(-1.0 / d.α)
 
-mode(d::Frechet) = (iα = -1.0/d.α; d.s * (1.0 - iα) ^ iα)
+mode(d::Frechet) = (iα = -1.0/d.α; d.β * (1.0 - iα) ^ iα)
 
 function var(d::Frechet)
     if d.α > 2.0
         iα = 1.0 / d.α    
-        return d.s^2 * (gamma(1.0 - 2.0 * iα) - gamma(1.0 - iα)^2)
+        return d.β^2 * (gamma(1.0 - 2.0 * iα) - gamma(1.0 - iα)^2)
     else    
         return Inf
     end
@@ -67,41 +65,41 @@ end
 
 function entropy(d::Frechet)
     const γ = 0.57721566490153286060  # γ is the Euler-Mascheroni constant
-    1.0 + γ / d.α + γ + log(d.s / d.α)
+    1.0 + γ / d.α + γ + log(d.β / d.α)
 end
 
 
 #### Evaluation
 
 function logpdf(d::Frechet, x::Float64)
-    (α, s) = params(d)
+    (α, β) = params(d)
     if x > 0.0
-        z = s / x
-        return log(α / s) + (1.0 + α) * log(z) - z^α
+        z = β / x
+        return log(α / β) + (1.0 + α) * log(z) - z^α
     else
         return -Inf
     end
 end
 
 pdf(d::Frechet, x::Float64) = exp(logpdf(d, x))
 
-cdf(d::Frechet, x::Float64) = x > 0.0 ? exp(-((d.s / x) ^ d.α)) : 0.0
-ccdf(d::Frechet, x::Float64) = x > 0.0 ? -expm1(-((d.s / x) ^ d.α)) : 1.0
-logcdf(d::Frechet, x::Float64) = x > 0.0 ? -(d.s / x) ^ d.α : -Inf
-logccdf(d::Frechet, x::Float64) = x > 0.0 ? log1mexp(-((d.s / x) ^ d.α)) : 0.0
+cdf(d::Frechet, x::Float64) = x > 0.0 ? exp(-((d.β / x) ^ d.α)) : 0.0
+ccdf(d::Frechet, x::Float64) = x > 0.0 ? -expm1(-((d.β / x) ^ d.α)) : 1.0
+logcdf(d::Frechet, x::Float64) = x > 0.0 ? -(d.β / x) ^ d.α : -Inf
+logccdf(d::Frechet, x::Float64) = x > 0.0 ? log1mexp(-((d.β / x) ^ d.α)) : 0.0
 
-quantile(d::Frechet, p::Float64) = d.s * (-log(p)) ^ (-1.0 / d.α)
-cquantile(d::Frechet, p::Float64) = d.s * (-log1p(-p)) ^ (-1.0 / d.α)
-invlogcdf(d::Frechet, lp::Float64) = d.s * (-lp)^(-1.0 / d.α)
-invlogccdf(d::Frechet, lp::Float64) = d.s * (-log1mexp(lp))^(-1.0 / d.α)
+quantile(d::Frechet, p::Float64) = d.β * (-log(p)) ^ (-1.0 / d.α)
+cquantile(d::Frechet, p::Float64) = d.β * (-log1p(-p)) ^ (-1.0 / d.α)
+invlogcdf(d::Frechet, lp::Float64) = d.β * (-lp)^(-1.0 / d.α)
+invlogccdf(d::Frechet, lp::Float64) = d.β * (-log1mexp(lp))^(-1.0 / d.α)
 
 function gradlogpdf(d::Frechet, x::Float64)
-    (α, s) = params(d)
-    insupport(Frechet, x) ? -(α + 1.0) / x + α * (s^α) * x^(-α-1.0)  : 0.0
+    (α, β) = params(d)
+    insupport(Frechet, x) ? -(α + 1.0) / x + α * (β^α) * x^(-α-1.0)  : 0.0
 end
 
 ## Sampling
 
-rand(d::Frechet) = d.s * randexp() ^ (-1.0 / d.α)
+rand(d::Frechet) = d.β * randexp() ^ (-1.0 / d.α)
 
 

src/univariate/continuous/gamma.jl

@@ -1,10 +1,10 @@
 immutable Gamma <: ContinuousUnivariateDistribution
     α::Float64
-    θ::Float64
+    β::Float64
 
-    function Gamma(α::Real, θ::Real)
-        α > zero(α) && θ > zero(θ) || error("Both shape and scale must be positive")
-        new(float64(α), float64(θ))
+    function Gamma(α::Real, β::Real)
+        α > zero(α) && β > zero(β) || error("Gamma: both shape and scale must be positive")
+        new(float64(α), float64(β))
     end
 
     Gamma(α::Real) = Gamma(α, 1.0)
@@ -19,41 +19,41 @@ end
 #### Parameters
 
 shape(d::Gamma) = d.α
-scale(d::Gamma) = d.θ
-rate(d::Gamma) = 1.0 / d.θ
+scale(d::Gamma) = d.β
+rate(d::Gamma) = 1.0 / d.β
 
-params(d::Gamma) = (d.α, d.θ)
+params(d::Gamma) = (d.α, d.β)
 
 
 #### Statistics
 
-mean(d::Gamma) = d.α * d.θ
+mean(d::Gamma) = d.α * d.β
 
-var(d::Gamma) = d.α * d.θ^2
+var(d::Gamma) = d.α * d.β^2
 
 skewness(d::Gamma) = 2.0 / sqrt(d.α)
 
 kurtosis(d::Gamma) = 6.0 / d.α
 
 function mode(d::Gamma)
-    (α, θ) = params(d)
-    α > 1.0 ? θ * (α - 1.0) : error("Gamma has no mode when shape < 1.0")
+    (α, β) = params(d)
+    α > 1.0 ? β * (α - 1.0) : error("Gamma has no mode when shape < 1.0")
 end
 
 function entropy(d::Gamma)
-    (α, θ) = params(d)
-    α + lgamma(α) + (1.0 - α) * digamma(α) + log(θ)
+    (α, β) = params(d)
+    α + lgamma(α) + (1.0 - α) * digamma(α) + log(β)
 end
 
-mgf(d::Gamma, t::Real) = (1.0 - t * d.θ)^(-d.α)
+mgf(d::Gamma, t::Real) = (1.0 - t * d.β)^(-d.α)
 
-cf(d::Gamma, t::Real) = (1.0 - im * t * d.θ)^(-d.α)
+cf(d::Gamma, t::Real) = (1.0 - im * t * d.β)^(-d.α)
 
 
 #### Evaluation
 
 gradlogpdf(d::Gamma, x::Float64) = 
-    insupport(Gamma, x) ? (d.α - 1.0) / x - 1.0 / d.θ : 0.0
+    insupport(Gamma, x) ? (d.α - 1.0) / x - 1.0 / d.β : 0.0
 
 
 #### Fit model

src/univariate/continuous/gumbel.jl

@@ -42,21 +42,21 @@ entropy(d::Gumbel) = 1.57721566490153286 + log(d.β)
 
 #### Evaluation
 
-zvar(d::Gumbel, x::Float64) = (x - d.μ) / d.β
-xvar(d::Gumbel, z::Float64) = x * d.β + d.μ
+zval(d::Gumbel, x::Float64) = (x - d.μ) / d.β
+xval(d::Gumbel, z::Float64) = x * d.β + d.μ
 
 function pdf(d::Gumbel, x::Float64)
-    z = zvar(d, x)
+    z = zval(d, x)
     exp(-z - exp(-z)) / d.β
 end
 
 function logpdf(d::Gumbel, x::Float64)
-    z = zvar(d, x)
+    z = zval(d, x)
     - (z + exp(-z) + log(d.β))
 end
 
-cdf(d::Gumbel, x::Float64) = exp(-exp(-zvar(d, x)))
-logcdf(d::Gumbel, x::Float64) = -exp(-zvar(d, x))
+cdf(d::Gumbel, x::Float64) = exp(-exp(-zval(d, x)))
+logcdf(d::Gumbel, x::Float64) = -exp(-zval(d, x))
 
 quantile(d::Gumbel, p::Float64) = d.μ - d.β * log(-log(p))
 

src/univariate/continuous/logistic.jl

@@ -1,10 +1,10 @@
 immutable Logistic <: ContinuousUnivariateDistribution
     μ::Float64
-    s::Float64
+    β::Float64
 
-    function Logistic(μ::Float64, s::Float64)
-    	s > zero(s) || error("Logistic's scale must be positive")
-    	new(float64(μ), float64(s))
+    function Logistic(μ::Float64, β::Float64)
+    	β > zero(β) || error("Logistic: scale must be positive")
+    	new(float64(μ), float64(β))
     end
 
     Logistic(μ::Real) = new(float64(μ), 1.0)
@@ -17,9 +17,9 @@ end
 #### Parameters
 
 location(d::Logistic) = d.μ
-scale(d::Logistic) = d.s
+scale(d::Logistic) = d.β
 
-params(d::Logistic) = (d.μ, d.s)
+params(d::Logistic) = (d.μ, d.β)
 
 
 #### Statistics
@@ -28,21 +28,21 @@ mean(d::Logistic) = d.μ
 median(d::Logistic) = d.μ
 mode(d::Logistic) = d.μ
 
-std(d::Logistic) = π * d.s / sqrt3
-var(d::Logistic) = (π * d.s)^2 / 3.0
+std(d::Logistic) = π * d.β / sqrt3
+var(d::Logistic) = (π * d.β)^2 / 3.0
 skewness(d::Logistic) = 0.0
 kurtosis(d::Logistic) = 1.2
 
-entropy(d::Logistic) = log(d.s) + 2.0
+entropy(d::Logistic) = log(d.β) + 2.0
 
 
 #### Evaluation
 
-zval(d::Logistic, x::Float64) = (x - d.μ) / d.s
-xval(d::Logistic, z::Float64) = d.μ + z * d.s
+zval(d::Logistic, x::Float64) = (x - d.μ) / d.β
+xval(d::Logistic, z::Float64) = d.μ + z * d.β
 
-pdf(d::Logistic, x::Float64) = (e = exp(-zval(d, x)); e / (d.s * (1.0 + e)^2))
-logpdf(d::Logistic, x::Float64) = (u = -abs(zval(d, x)); u - 2.0 * log1pexp(u) - log(d.s))
+pdf(d::Logistic, x::Float64) = (e = exp(-zval(d, x)); e / (d.β * (1.0 + e)^2))
+logpdf(d::Logistic, x::Float64) = (u = -abs(zval(d, x)); u - 2.0 * log1pexp(u) - log(d.β))
 
 cdf(d::Logistic, x::Float64) = logistic(zval(d, x))
 ccdf(d::Logistic, x::Float64) = logistic(-zval(d, x))
@@ -56,13 +56,13 @@ invlogccdf(d::Logistic, lp::Float64) = xval(d, logexpm1(-lp))
 
 function gradlogpdf(d::Logistic, x::Float64)
     e = exp(-zval(d, x))
-    ((2.0 * e) / (1.0 + e) - 1.0) / d.s
+    ((2.0 * e) / (1.0 + e) - 1.0) / d.β
 end
 
-mgf(d::Logistic, t::Real) = exp(t * d.μ) / sinc(d.s * t)
+mgf(d::Logistic, t::Real) = exp(t * d.μ) / sinc(d.β * t)
 
 function cf(d::Logistic, t::Real)
-    a = (π * t) * d.s
+    a = (π * t) * d.β
     a == zero(a) ? complex(one(a)) : exp(im * t * d.μ) * a / sinh(a)    
 end