arg check with keyword (#976)

* arg check with keyword

* fix multinomial

* more distributions

* fix ambig method

* fix laplace

* reversed arg check

* Update src/multivariate/multinomial.jl

Co-Authored-By: Milan Bouchet-Valat <nalimilan@club.fr>

* more distributions

* last distributions

* arg check doesn't sort

* formatting

* reverse words

* space around kw, checkargs

* last formatting and typo

src/multivariate/multinomial.jl

@@ -23,18 +23,21 @@ struct Multinomial{T<:Real} <: DiscreteMultivariateDistribution
     n::Int
     p::Vector{T}
 
-    function Multinomial{T}(n::Integer, p::Vector{T}) where T
+    Multinomial{T}(n::Integer, p::Vector{T}) where {T} = new{T}(Int(n), p)
+end
+
+function Multinomial(n::Integer, p::Vector{T}; check_args=true) where {T<:Real}
+    if check_args
         if n < 0
             throw(ArgumentError("n must be a nonnegative integer."))
         end
         if !isprobvec(p)
             throw(ArgumentError("p = $p is not a probability vector."))
         end
-        new{T}(round(Int, n), p)
     end
-    Multinomial{T}(n::Integer, p::Vector{T}, ::NoArgCheck) where {T} = new{T}(round(Int, n), p)
+    return Multinomial{T}(n, p)
 end
-Multinomial(n::Integer, p::Vector{T}) where {T<:Real} = Multinomial{T}(n, p)
+
 Multinomial(n::Integer, k::Integer) = Multinomial{Float64}(round(Int, n), fill(1.0 / k, k))
 
 # Parameters

src/univariate/continuous/arcsine.jl

@@ -23,21 +23,19 @@ External links
 
 * [Arcsine distribution on Wikipedia](http://en.wikipedia.org/wiki/Arcsine_distribution)
 
-Use `Arcsine(a, b, ::NoArgCheck)` to bypass argument checks.
+Use `Arcsine(a, b, check_args=false)` to bypass argument checks.
 """
 struct Arcsine{T<:Real} <: ContinuousUnivariateDistribution
     a::T
     b::T
     Arcsine{T}(a::T, b::T) where {T<:Real} = new{T}(a, b)
 end
 
-function Arcsine(a::T, b::T) where {T <: Real}
-    @check_args(Arcsine, a < b)
+function Arcsine(a::T, b::T; check_args=true) where {T <: Real}
+    check_args && @check_args(Arcsine, a < b)
     return Arcsine{T}(a, b)
 end
 
-Arcsine(a::T, b::T, ::NoArgCheck) where {T <: Real} = Arcsine{T}(a, b)
-
 Arcsine(a::Real, b::Real) = Arcsine(promote(a, b)...)
 Arcsine(a::Integer, b::Integer) = Arcsine(float(a), float(b))
 Arcsine(b::T) where {T <: Real} = Arcsine(zero(T), b)

src/univariate/continuous/beta.jl

@@ -32,19 +32,15 @@ struct Beta{T<:Real} <: ContinuousUnivariateDistribution
     Beta{T}(α::T, β::T) where {T} = new{T}(α, β)
 end
 
-function Beta(α::T, β::T) where {T<:Real}
-    @check_args(Beta, α > zero(α) && β > zero(β))
-    return Beta{T}(α, β)
-end
-
-function Beta(α::T, β::T, ::NoArgCheck) where {T<:Real}
+function Beta(α::T, β::T; check_args=true) where {T<:Real}
+    check_args && @check_args(Beta, α > zero(α) && β > zero(β))
     return Beta{T}(α, β)
 end
 
 Beta(α::Real, β::Real) = Beta(promote(α, β)...)
 Beta(α::Integer, β::Integer) = Beta(float(α), float(β))
 Beta(α::Real) = Beta(α, α)
-Beta() = Beta(1.0, 1.0, NoArgCheck())
+Beta() = Beta(1.0, 1.0, check_args=false)
 
 @distr_support Beta 0.0 1.0
 
@@ -53,7 +49,7 @@ function convert(::Type{Beta{T}}, α::Real, β::Real) where T<:Real
     Beta(T(α), T(β))
 end
 function convert(::Type{Beta{T}}, d::Beta{S}) where {T <: Real, S <: Real}
-    Beta(T(d.α), T(d.β), NoArgCheck())
+    Beta(T(d.α), T(d.β), check_args=false)
 end
 
 #### Parameters
@@ -66,14 +62,11 @@ params(d::Beta) = (d.α, d.β)
 
 mean(d::Beta) = ((α, β) = params(d); α / (α + β))
 
-function mode(d::Beta)
-    (α, β) = params(d)
-    (α > 1 && β > 1) || error("mode is defined only when α > 1 and β > 1.")
-    return (α - 1) / (α + β - 2)
-end
-
-function mode(d::Beta, ::NoArgCheck)
+function mode(d::Beta; check_args=true)
     (α, β) = params(d)
+    if check_args
+        (α > 1 && β > 1) || error("mode is defined only when α > 1 and β > 1.")
+    end
     return (α - 1) / (α + β - 2)
 end
 

src/univariate/continuous/betaprime.jl

@@ -32,17 +32,15 @@ struct BetaPrime{T<:Real} <: ContinuousUnivariateDistribution
     BetaPrime{T}(α::T, β::T) where {T} = new{T}(α, β)
 end
 
-function BetaPrime(α::T, β::T) where {T<:Real}
-    @check_args(BetaPrime, α > zero(α) && β > zero(β))
+function BetaPrime(α::T, β::T; check_args=true) where {T<:Real}
+    check_args && @check_args(BetaPrime, α > zero(α) && β > zero(β))
     return BetaPrime{T}(α, β)
 end
 
-BetaPrime(α::T, β::T, ::NoArgCheck) where {T<:Real} = BetaPrime{T}(α, β)
-
 BetaPrime(α::Real, β::Real) = BetaPrime(promote(α, β)...)
 BetaPrime(α::Integer, β::Integer) = BetaPrime(float(α), float(β))
 BetaPrime(α::Real) = BetaPrime(α, α)
-BetaPrime() = BetaPrime(1.0, 1.0, NoArgCheck())
+BetaPrime() = BetaPrime(1.0, 1.0, check_args=false)
 
 @distr_support BetaPrime 0.0 Inf
 
@@ -51,7 +49,7 @@ function convert(::Type{BetaPrime{T}}, α::Real, β::Real) where T<:Real
     BetaPrime(T(α), T(β))
 end
 function convert(::Type{BetaPrime{T}}, d::BetaPrime{S}) where {T <: Real, S <: Real}
-    BetaPrime(T(d.α), T(d.β), NoArgCheck())
+    BetaPrime(T(d.α), T(d.β), check_args=false)
 end
 
 #### Parameters

src/univariate/continuous/biweight.jl

@@ -7,17 +7,15 @@ struct Biweight{T<:Real} <: ContinuousUnivariateDistribution
     Biweight{T}(µ::T, σ::T) where {T <: Real} = new{T}(µ, σ)
 end
 
-function Biweight(μ::T, σ::T) where {T<:Real}
-    @check_args(Biweight, σ > zero(σ))
+function Biweight(μ::T, σ::T; check_args=true) where {T<:Real}
+    check_args && @check_args(Biweight, σ > zero(σ))
     return Biweight{T}(μ, σ)
 end
 
-Biweight(μ::T, σ::T, ::NoArgCheck) where {T<:Real} = Biweight{T}(μ, σ)
-
 Biweight(μ::Real, σ::Real) = Biweight(promote(μ, σ)...)
 Biweight(μ::Integer, σ::Integer) = Biweight(float(μ), float(σ))
 Biweight(μ::T) where {T<:Real} = Biweight(μ, one(T))
-Biweight() = Biweight(0.0, 1.0, NoArgCheck())
+Biweight() = Biweight(0.0, 1.0, check_args=false)
 
 @distr_support Biweight d.μ - d.σ d.μ + d.σ
 

src/univariate/continuous/cauchy.jl

@@ -28,19 +28,15 @@ struct Cauchy{T<:Real} <: ContinuousUnivariateDistribution
     Cauchy{T}(µ, σ) where {T} = new{T}(µ, σ)
 end
 
-function Cauchy(μ::T, σ::T) where {T<:Real}
-    @check_args(Cauchy, σ > zero(σ))
-    return Cauchy{T}(μ, σ)
-end
-
-function Cauchy(μ::T, σ::T, ::NoArgCheck) where {T<:Real}
+function Cauchy(μ::T, σ::T; check_args=true) where {T<:Real}
+    check_args && @check_args(Cauchy, σ > zero(σ))
     return Cauchy{T}(μ, σ)
 end
 
 Cauchy(μ::Real, σ::Real) = Cauchy(promote(μ, σ)...)
 Cauchy(μ::Integer, σ::Integer) = Cauchy(float(μ), float(σ))
 Cauchy(μ::T) where {T<:Real} = Cauchy(μ, one(T))
-Cauchy() = Cauchy(0.0, 1.0, NoArgCheck())
+Cauchy() = Cauchy(0.0, 1.0, check_args=false)
 
 @distr_support Cauchy -Inf Inf
 
@@ -49,7 +45,7 @@ function convert(::Type{Cauchy{T}}, μ::Real, σ::Real) where T<:Real
     Cauchy(T(μ), T(σ))
 end
 function convert(::Type{Cauchy{T}}, d::Cauchy{S}) where {T <: Real, S <: Real}
-    Cauchy(T(d.μ), T(d.σ), NoArgCheck())
+    Cauchy(T(d.μ), T(d.σ), check_args=false)
 end
 
 #### Parameters

src/univariate/continuous/chi.jl

@@ -26,20 +26,18 @@ struct Chi{T<:Real} <: ContinuousUnivariateDistribution
     Chi{T}(ν::T) where {T} = new{T}(ν)
 end
 
-function Chi(ν::T) where {T<:Real}
-    @check_args(Chi, ν > zero(ν))
+function Chi(ν::T; check_args=true) where {T<:Real}
+    check_args && @check_args(Chi, ν > zero(ν))
     return Chi{T}(ν)
 end
 
-Chi(ν::T, ::NoArgCheck) where {T<:Real} = Chi{T}(ν)
-
 Chi(ν::Integer) = Chi(float(ν))
 
 @distr_support Chi 0.0 Inf
 
 ### Conversions
 convert(::Type{Chi{T}}, ν::Real) where {T<:Real} = Chi(T(ν))
-convert(::Type{Chi{T}}, d::Chi{S}) where {T <: Real, S <: Real} = Chi(T(d.ν), NoArgCheck())
+convert(::Type{Chi{T}}, d::Chi{S}) where {T <: Real, S <: Real} = Chi(T(d.ν), check_args=false)
 
 #### Parameters
 

src/univariate/continuous/chisq.jl

@@ -25,12 +25,11 @@ struct Chisq{T<:Real} <: ContinuousUnivariateDistribution
     Chisq{T}(ν::T) where {T} = new{T}(ν)
 end
 
-function Chisq(ν::T) where {T <: Real}
-    @check_args(Chisq, ν > zero(ν))
+function Chisq(ν::T; check_args=true) where {T <: Real}
+    check_args && @check_args(Chisq, ν > zero(ν))
     return Chisq{T}(ν)
 end
 
-Chisq(ν::T, ::NoArgCheck) where {T <: Real} = Chisq{T}(ν)
 Chisq(ν::Integer) = Chisq(float(ν))
 
 @distr_support Chisq 0.0 Inf

src/univariate/continuous/cosine.jl

@@ -13,16 +13,15 @@ struct Cosine{T<:Real} <: ContinuousUnivariateDistribution
     Cosine{T}(μ::T, σ::T) where {T} = new{T}(µ, σ)
 end
 
-function Cosine(μ::T, σ::T) where {T <: Real}
-    @check_args(Cosine, σ > zero(σ))
+function Cosine(μ::T, σ::T; check_args=true) where {T <: Real}
+    check_args && @check_args(Cosine, σ > zero(σ))
     return Cosine{T}(μ, σ)
 end
 
-Cosine(μ::T, σ::T, ::NoArgCheck) where {T<:Real} = Cosine{T}(μ, σ)
 Cosine(μ::Real, σ::Real) = Cosine(promote(μ, σ)...)
 Cosine(μ::Integer, σ::Integer) = Cosine(float(μ), float(σ))
 Cosine(μ::T) where {T <: Real} = Cosine(μ, one(µ))
-Cosine() = Cosine(0.0, 1.0, NoArgCheck())
+Cosine() = Cosine(0.0, 1.0, check_args=false)
 
 @distr_support Cosine d.μ - d.σ d.μ + d.σ
 
@@ -31,7 +30,7 @@ function convert(::Type{Cosine{T}}, μ::Real, σ::Real) where T<:Real
     Cosine(T(μ), T(σ))
 end
 function convert(::Type{Cosine{T}}, d::Cosine{S}) where {T <: Real, S <: Real}
-    Cosine(T(d.μ), T(d.σ), NoArgCheck())
+    Cosine(T(d.μ), T(d.σ), check_args=false)
 end
 
 #### Parameters

src/univariate/continuous/epanechnikov.jl

@@ -7,26 +7,24 @@ struct Epanechnikov{T<:Real} <: ContinuousUnivariateDistribution
     Epanechnikov{T}(µ::T, σ::T) where {T} = new{T}(µ, σ)
 end
 
-function Epanechnikov(μ::T, σ::T) where {T<:Real}
-    @check_args(Epanechnikov, σ > zero(σ))
+function Epanechnikov(μ::T, σ::T; check_args=true) where {T<:Real}
+    check_args && @check_args(Epanechnikov, σ > zero(σ))
     return Epanechnikov{T}(μ, σ)
 end
 
-Epanechnikov(μ::T, σ::T, ::NoArgCheck) where {T<:Real} = Epanechnikov{T}(μ, σ)
-
 Epanechnikov(μ::Real, σ::Real) = Epanechnikov(promote(μ, σ)...)
 Epanechnikov(μ::Integer, σ::Integer) = Epanechnikov(float(μ), float(σ))
 Epanechnikov(μ::T) where {T <: Real} = Epanechnikov(μ, one(T))
-Epanechnikov() = Epanechnikov(0.0, 1.0, NoArgCheck())
+Epanechnikov() = Epanechnikov(0.0, 1.0, check_args=false)
 
 @distr_support Epanechnikov d.μ - d.σ d.μ + d.σ
 
 #### Conversions
 function convert(::Type{Epanechnikov{T}}, μ::Real, σ::Real) where T<:Real
-    Epanechnikov(T(μ), T(σ), NoArgCheck())
+    Epanechnikov(T(μ), T(σ), check_args=false)
 end
 function convert(::Type{Epanechnikov{T}}, d::Epanechnikov{S}) where {T <: Real, S <: Real}
-    Epanechnikov(T(d.μ), T(d.σ), NoArgCheck())
+    Epanechnikov(T(d.μ), T(d.σ), check_args=false)
 end
 
 ## Parameters

src/univariate/continuous/erlang.jl

@@ -20,17 +20,13 @@ struct Erlang{T<:Real} <: ContinuousUnivariateDistribution
     Erlang{T}(α::Int, θ::T) where {T} = new{T}(α, θ)
 end
 
-function Erlang(α::Real, θ::T) where {T <: Real}
-    @check_args(Erlang, isinteger(α) && α >= zero(α))
+function Erlang(α::Real, θ::T; check_args=true) where {T <: Real}
+    check_args && @check_args(Erlang, isinteger(α) && α >= zero(α))
     return Erlang{T}(α, θ)
 end
 
-function Erlang(α::Integer, θ::T) where {T <: Real}
-    @check_args(Erlang, α >= zero(α))
-    return Erlang{T}(α, θ)
-end
-
-function Erlang(α::Integer, θ::T, ::NoArgCheck) where {T <: Real}
+function Erlang(α::Integer, θ::T; check_args=true) where {T <: Real}
+    check_args && @check_args(Erlang, α >= zero(α))
     return Erlang{T}(α, θ)
 end
 
@@ -40,16 +36,16 @@ function Erlang(α::Integer, θ::Integer)
 end
 
 Erlang(α::Integer) = Erlang(α, 1.0)
-Erlang() = Erlang(1, 1.0, NoArgCheck())
+Erlang() = Erlang(1, 1.0, check_args=false)
 
 @distr_support Erlang 0.0 Inf
 
 #### Conversions
 function convert(::Type{Erlang{T}}, α::Integer, θ::S) where {T <: Real, S <: Real}
-    Erlang(α, T(θ), NoArgCheck())
+    Erlang(α, T(θ), check_args=false)
 end
 function convert(::Type{Erlang{T}}, d::Erlang{S}) where {T <: Real, S <: Real}
-    Erlang(d.α, T(d.θ), NoArgCheck())
+    Erlang(d.α, T(d.θ), check_args=false)
 end
 
 #### Parameters

src/univariate/continuous/exponential.jl

@@ -26,44 +26,40 @@ struct Exponential{T<:Real} <: ContinuousUnivariateDistribution
     Exponential{T}(θ::T) where {T} = new{T}(θ)
 end
 
-function Exponential(θ::T) where {T <: Real}
-    @check_args(Exponential, θ > zero(θ))
+function Exponential(θ::T; check_args=true) where {T <: Real}
+    check_args && @check_args(Exponential, θ > zero(θ))
     return Exponential{T}(θ)
 end
 
-Exponential(θ::T, ::NoArgCheck) where {T <: Real} = Exponential{T}(θ)
-
 Exponential(θ::Integer) = Exponential(float(θ))
-Exponential() = Exponential(1.0, NoArgCheck())
+Exponential() = Exponential(1.0, check_args=false)
 
 @distr_support Exponential 0.0 Inf
 
 ### Conversions
 convert(::Type{Exponential{T}}, θ::S) where {T <: Real, S <: Real} = Exponential(T(θ))
-convert(::Type{Exponential{T}}, d::Exponential{S}) where {T <: Real, S <: Real} = Exponential(T(d.θ), NoArgCheck())
+convert(::Type{Exponential{T}}, d::Exponential{S}) where {T <: Real, S <: Real} = Exponential(T(d.θ), check_args=false)
 
 #### Parameters
 
 scale(d::Exponential) = d.θ
 rate(d::Exponential) = inv(d.θ)
 
 params(d::Exponential) = (d.θ,)
-@inline partype(d::Exponential{T}) where {T<:Real} = T
-
+partype(::Exponential{T}) where {T<:Real} = T
 
 #### Statistics
 
 mean(d::Exponential) = d.θ
 median(d::Exponential) = logtwo * d.θ
-mode(d::Exponential{T}) where {T<:Real} = zero(T)
+mode(::Exponential{T}) where {T<:Real} = zero(T)
 
 var(d::Exponential) = d.θ^2
-skewness(d::Exponential{T}) where {T} = T(2)
-kurtosis(d::Exponential{T}) where {T} = T(6)
+skewness(::Exponential{T}) where {T} = T(2)
+kurtosis(::Exponential{T}) where {T} = T(6)
 
 entropy(d::Exponential{T}) where {T} = one(T) + log(d.θ)
 
-
 #### Evaluation
 
 zval(d::Exponential, x::Real) = x / d.θ