diff --git a/extras/Rmath.jl b/extras/Rmath.jl index cb49e23c5e518..4700b9d0b1839 100644 --- a/extras/Rmath.jl +++ b/extras/Rmath.jl @@ -3,400 +3,480 @@ _jl_libRmath = dlopen("libRmath") macro _jl_libRmath_vectorize_3arg(f) quote - function ($f){T1<:Number, T2<:Number, T3<:Number}(x::AbstractArray{T1}, y::T2, z::T3) + ($f){T1<:Number, T2<:Number, T3<:Number}(x::AbstractArray{T1}, y::T2, z::T3) = reshape([ ($f)(x[i], y, z) | i=1:numel(x) ], size(x)) - end - function ($f){T1<:Number, T2<:Number, T3<:Number}(x::T1, y::AbstractArray{T2}, z::T3) + ($f){T1<:Number, T2<:Number, T3<:Number}(x::T1, y::AbstractArray{T2}, z::T3) = reshape([ ($f)(x, y[i], z) | i=1:numel(y) ], size(y)) - end - function ($f){T1<:Number, T2<:Number, T3<:Number}(x::T1, y::T2, z::AbstractArray{T3}) + ($f){T1<:Number, T2<:Number, T3<:Number}(x::T1, y::T2, z::AbstractArray{T3}) = reshape([ ($f)(x, y, z[i]) | i=1:numel(z) ], size(z)) - end function ($f){T1<:Number, T2<:Number, T3<:Number}(x::AbstractArray{T1}, y::AbstractArray{T2}, z::T3) - shp = promote_shape(size(x),size(y)) + shp = promote_shape(size(x), size(y)) reshape([ ($f)(x[i], y[i], z) | i=1:numel(x) ], shp) end function ($f){T1<:Number, T2<:Number, T3<:Number}(x::T1, y::AbstractArray{T2}, z::AbstractArray{T3}) - shp = promote_shape(size(y),size(z)) + shp = promote_shape(size(y), size(z)) reshape([ ($f)(x, y[i], z[i]) | i=1:numel(y) ], shp) end function ($f){T1<:Number, T2<:Number, T3<:Number}(x::AbstractArray{T1}, y::T2, z::AbstractArray{T3}) - shp = promote_shape(size(x),size(z)) + shp = promote_shape(size(x), size(z)) + reshape([ ($f)(x[i], y, z[i]) | i=1:numel(x) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number}(x::AbstractArray{T1}, y::T2, z::AbstractArray{T3}) + shp = promote_shape(size(x), size(z)) + reshape([ ($f)(x[i], y, z[i]) | i=1:numel(x) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number}(x::AbstractArray{T1}, y::AbstractArray{T2}, z::AbstractArray{T3}) + shp = promote_shape(promote_shape(size(x), size(y)), size(z)) reshape([ ($f)(x[i], y, z[i]) | i=1:numel(x) ], shp) end end end -## Density of normal (Gaussian) distribution - special case because the dlsym is dnorm4, not dnorm -dnorm(x::Number, mu::Number, sigma::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,:dnorm4),Float64,(Float64,Float64,Float64,Int32), x, mu, sigma, give_log) -dnorm(x::Number, mu::Number, give_log::Bool) = dnorm(x, mu, 1., give_log) -dnorm(x::Number, give_log::Bool) = dnorm(x, 0., 1., give_log) -dnorm(x::Number, mu::Number, sigma::Number) = dnorm(x, mu, sigma, false) -dnorm(x::Number, mu::Number) = dnorm(x, mu, 1., false) -dnorm(x::Number) = dnorm(x, 0., 1., false) - -@vectorize_1arg Number dnorm -@vectorize_2arg Number dnorm -@_jl_libRmath_vectorize_3arg dnorm - -## Cumulative distribution function (cdf) of the normal (Gaussian) distribution - special case because the dlsym is pnorm5 -## @argument q - quantile -pnorm(q::Number, mean::Number, sd::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, mean, sd, lower_tail, log_p) -pnorm(q::Number, mu::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, mean, 1., lower_tail, log_p) -pnorm(q::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, 0., 1., lower_tail, log_p) -pnorm(q::Number, mean::Number, sd::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, mean, sd, lower_tail, false) -pnorm(q::Number, mu::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, mean, 1., lower_tail, false) -pnorm(q::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, 0., 1., lower_tail, false) -pnorm(q::Number, mu::Number, sigma::Number) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, mean, sd, true, false) -pnorm(q::Number, mu::Number) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, mean, 1., true, false) -pnorm(q::Number) = - ccall(dlsym(_jl_libRmath,:pnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), q, 0., 1., true, false) - -@vectorize_1arg Number pnorm -@vectorize_2arg Number pnorm -@_jl_libRmath_vectorize_3arg pnorm - -## Quantile function of the normal (Gaussian) distribution - special case because the dlsym is qnorm5 -## @argument p - probability , must be in (0,1) -qnorm(p::Number, mean::Number, sd::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,:qnorm5),Float64,(Float64,Float64,Float64,Int32,Int32), p, mean, sd, lower_tail, log_p) -qnorm(p::Number, mu::Number, lower_tail::Bool, log_p::Bool) = qnorm(p, mu, 1., lower_tail, log_p) -qnorm(p::Number, lower_tail::Bool, log_p::Bool) = qnorm(p, 0., 1., lower_tail, log_p) -qnorm(p::Number, mu::Number, sigma::Number) = qnorm(p, mu, sigma, true, false) -qnorm(p::Number, mu::Number) = qnorm(p, mu, 1., true, false) -qnorm(p::Number) = qnorm(p, 0., 1., true, false) - -@vectorize_1arg Number qnorm -@vectorize_2arg Number qnorm -@_jl_libRmath_vectorize_3arg qnorm - -## Density of uniform distribution - special case because there are no 1-parameter defaults -## a and b are the upper and lower end-points of the non-zero density -## R defaults are a=0, b=1, give_log=false -dunif(x::Number, a::Number, b::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,:dunif),Float64,(Float64,Float64,Float64,Int32), x, a, b, give_log) -dunif(x::Number, give_log::Bool) = dunif(x, 0., 1., give_log) -dunif(x::Number, a::Number, b::Number) = dunif(x, a, b, false) -dunif(x::Number) = dunif(x, 0., 1., false) - -@vectorize_1arg Number dunif -@_jl_libRmath_vectorize_3arg dunif - -## Cumulative distribution function (cdf) of the uniform distribution - special case because there are no 1-parameter default cases -## @argument q - quantile -## a and b are the upper and lower end-points of the nonzero density -## R defaults are a=0, b=1, lower_tail=true, log_p=false -punif(q::Number, a::Number, b::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,:punif),Float64,(Float64,Float64,Float64,Int32,Int32), q, a, b, lower_tail, log_p) -punif(q::Number, lower_tail::Bool, log_p::Bool) = punif(q, 0., 1., lower_tail, log_p) -punif(q::Number, a::Number, b::Number) = punif(q, a, b, true, false) -punif(q::Number) = punif(q, 0., 1., true, false) - -@vectorize_1arg Number punif -@_jl_libRmath_vectorize_3arg punif - -## Quantile function of the uniform distribution - special case because there are no 1-parameter default cases -## @argument p - probability , must be in (0,1) -## a and b are the upper and lower end-points of the distribution -## R defaults are a=0, b=1, lower_tail=true, log_p=false -qunif(p::Number, a::Number, b::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,:qunif),Float64,(Float64,Float64,Float64,Int32,Int32), p, a, b, lower_tail, log_p) -qunif(p::Number, lower_tail::Bool, log_p::Bool) = qunif(p, 0., 1., lower_tail, log_p) -qunif(p::Number, a::Number, b::Number) = qunif(p, a, b, true, false) -qunif(p::Number) = qunif(p, 0., 1., true, false) - -@vectorize_1arg Number qunif -@_jl_libRmath_vectorize_3arg qunif - -set_seed(a1::Integer, a2::Integer) = ccall(dlsym(_jl_libRmath,:set_seed),Void,(Int32,Int32), a1, a2) - -## Density (or probability mass) function for distributions with 1 parameter and no default -macro _jl_libRmathfunc_d_1par_0d(f) - quote - ($f)(x::Number, a1::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32), x, a1, give_log) - ($f)(x::Number, a1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32), x, a1, false) - @vectorize_2arg Number $f - end -end +## Is this version still needed? +set_seed(a1::Integer, a2::Integer) = + ccall(dlsym(_jl_libRmath,:set_seed), Void, (Int32,Int32), a1, a2) -## Cumulative distribution function or quantile function for distributions with 1 parameter and no default -macro _jl_libRmathfunc_pq_1par_0d(f) - quote - ($f)(x::Number, a1::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, a1, lower_tail, log_p) - ($f)(x::Number, a1::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, a1, lower_tail, false) - ($f)(x::Number, a1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, a1, true, false) - @vectorize_2arg Number $f - end -end +## The d-p-q functions in Rmath for signrank allocate storage that must be freed +## Signrank - Wilcoxon Signed Rank statistic +rsignrank(nn::Integer, p1::Number) = + [ ccall(dlsym(_jl_libRmath, "rsignrank"), Float64, (Float64,), p1) | i=1:nn ] -## Random samples from distributions with 1 parameter and no default -macro _jl_libRmathfunc_r_1par_0d(f) - quote - ($f)(nn::Integer, a1::Number) = [ccall(dlsym(_jl_libRmath,$string(f)),Float64,(Float64,),a1)|i=1:nn] - ($f){T<:Number}(a1::AbstractArray{T,1}) = [ccall(dlsym(_jl_libRmath,$string(f)),Float64,(Float64,),a1[i])|i=1:length(x)] - end -end +## Need to handle the d-p-q for Wilcox separately because the Rmath functions allocate storage that must be freed. +## Wilcox - Wilcox's Rank Sum statistic (m, n) - probably only makes sense for positive integers +rwilcox(nn::Integer, p1::Number, p2::Number) = + [ ccall(dlsym(_jl_libRmath, "rwilcox"), Float64, (Float64,Float64), p1, p2) | i=1:nn ] -## Density (or probability mass) function for distributions with 1 parameter and a default -macro _jl_libRmathfunc_d_1par(f, d) +## Vectorize over four numeric arguments +macro _jl_libRmath_vectorize_4arg(f) quote - ($f)(x::Number, a1::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32), x, a1, give_log) - ($f)(x::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32), x, $d, give_log) - ($f)(x::Number, a1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32), x, a1, false) - ($f)(x::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32), x, $d, false) - @vectorize_1arg Number $f - @vectorize_2arg Number $f + ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::T2, a3::T3, a4::T4) = + reshape([ ($f)(a1[i], a2, a3, a4) | i=1:numel(a1) ], size(a1)) + ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::AbstractArray{T2}, a3::T3, a4::T4) = + reshape([ ($f)(a1, a2[i], a3, a4) | i=1:numel(a2) ], size(a2)) + ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::T2, a3::AbstractArray{T3}, a4::T4) = + reshape([ ($f)(a1, a2, a3[i], a4) | i=1:numel(a3) ], size(a3)) + ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::T2, a3::T3, a4::AbstractArray{T4}) = + reshape([ ($f)(a1, a2, a3, a4[i]) | i=1:numel(a4) ], size(a4)) + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::AbstractArray{T2}, a3::T3, a4::T4) + shp = promote_shape(size(a1), size(a2)) + reshape([ ($f)(a1[i], a2[i], a3, a4) | i=1:numel(a1) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::T2, a3::AbstractArray{T3}, a4::T4) + shp = promote_shape(size(a1), size(a3)) + reshape([ ($f)(a1[i], a2, a3[i], a4) | i=1:numel(a1) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::T2, a3::T3, a4::AbstractArray{T4}) + shp = promote_shape(size(a1), size(a4)) + reshape([ ($f)(a1[i], a2, a3, a4[i]) | i=1:numel(a1) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::AbstractArray{T2}, a3::AbstractArray{T3}, a4::T4) + shp = promote_shape(size(a2), size(a3)) + reshape([ ($f)(a1, a2[i], a3[i], a4) | i=1:numel(a2) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::AbstractArray{T2}, a3::T3, a4::AbstractArray{T4}) + shp = promote_shape(size(a2), size(a4)) + reshape([ ($f)(a1, a2[i], a3, a4[i]) | i=1:numel(a2) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::T2, a3::AbstractArray{T3}, a4::AbstractArray{T4}) + shp = promote_shape(size(a3), size(a4)) + reshape([ ($f)(a1, a2, a3[i], a4[i]) | i=1:numel(a3) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::AbstractArray{T2}, a3::AbstractArray{T3}, a4::T4) + shp = promote_shape(promote_shape(size(a1), size(a2)), size(a3)) + reshape([ ($f)(a1[i], a2[i], a3[i], a4) | i=1:numel(a1) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::AbstractArray{T2}, a3::T3, a4::AbstractArray{T4}) + shp = promote_shape(promote_shape(size(a1), size(a2)), size(a4)) + reshape([ ($f)(a1[i], a2[i], a3, a4[i]) | i=1:numel(a1) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::T2, a3::AbstractArray{T3}, a4::AbstractArray{T4}) + shp = promote_shape(promote_shape(size(a1), size(a3)), size(a4)) + reshape([ ($f)(a1[i], a2, a3[i], a4[i]) | i=1:numel(a1) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::T1, a2::AbstractArray{T2}, a3::AbstractArray{T3}, a4::AbstractArray{T4}) + shp = promote_shape(promote_shape(size(a2), size(a3)), size(a4)) + reshape([ ($f)(a1, a2[i], a3[i], a4[i]) | i=1:numel(a2) ], shp) + end + function ($f){T1<:Number, T2<:Number, T3<:Number, T4<:Number}(a1::AbstractArray{T1}, a2::AbstractArray{T2}, a3::AbstractArray{T3}, a4::AbstractArray{T4}) + shp = promote_shape(promote_shape(promote_shape(size(a1), size(a2)), size(a3)), size(a4)) + reshape([ ($f)(a1[i], a2[i], a3[i], a4[i]) | i=1:numel(a2) ], shp) + end end end -## Cumulative distribution function or quantile function for distributions with 1 parameter and a default -macro _jl_libRmathfunc_pq_1par(f, d) +## Distributions with 1 parameter and no default +macro _jl_libRmath_1par_0d(base) + dd = symbol(strcat("d", string(base))) + pp = symbol(strcat("p", string(base))) + qq = symbol(strcat("q", string(base))) + rr = symbol(strcat("r", string(base))) quote - ($f)(x::Number, a1::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, a1, lower_tail, log_p) - ($f)(x::Number, a1::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, a1, lower_tail, false) - ($f)(x::Number, a1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, a1, true, false) - ($f)(x::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, $d, lower_tail, log_p) - ($f)(x::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, $d, lower_tail, false) - ($f)(x::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Int32,Int32), x, $d, true, false) - @vectorize_2arg Number $f - @vectorize_1arg Number $f + ($dd)(x::Number, p1::Number, give_log::Bool) = + ccall(dlsym(_jl_libRmath,$string(dd)), Float64, (Float64,Float64,Int32), x, p1, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, give_log::Bool) = + reshape([ ($dd)(x[i], p1, give_log) | i=1:numel(x) ], size(x)) + ($dd)(x::Number, p1::Number) = ($dd)(x, p1, false) + @vectorize_2arg Number $dd + + ($pp)(q::Number, p1::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(pp)), Float64, (Float64,Float64,Int32,Int32), q, p1, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($pp)(q[i], p1, lower_tail, log_p) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, p1::Number, lower_tail::Bool) = ($pp)(q, p1, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($pp)(q, p1, lower_tail, false) + ($pp)(q::Number, p1::Number) = ($pp)(q, p1, true, false) + @vectorize_2arg Number $pp + + ($qq)(p::Number, p1::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(qq)), Float64, (Float64,Float64,Int32,Int32), p, p1, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($qq)(p[i], p1, lower_tail, log_p) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, p1::Number, lower_tail::Bool) = ($qq)(p, p1, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($qq)(p, p1, lower_tail, false) + ($qq)(p::Number, p1::Number) = ($qq)(p, p1, true, false) + @vectorize_2arg Number $qq + + ($rr)(nn::Integer, p1::Number) = + [ ccall(dlsym(_jl_libRmath,$string(rr)), Float64, (Float64,), p1) | i=1:nn ] end end -## Density (or probability mass) function for distributions with 2 parameters and no defaults -macro _jl_libRmathfunc_d_2par_0d(f) +@_jl_libRmath_1par_0d t # Student's t distribution (df) +@_jl_libRmath_1par_0d chisq # Central Chi-squared distribution (df) +@_jl_libRmath_1par_0d pois # Poisson distribution (lambda) +@_jl_libRmath_1par_0d geom # Geometric distribution (prob) + +## Distributions with 1 parameter and a default +macro _jl_libRmath_1par_1d(base, d1) + dd = symbol(strcat("d", string(base))) + pp = symbol(strcat("p", string(base))) + qq = symbol(strcat("q", string(base))) + rr = symbol(strcat("r", string(base))) quote - ($f)(x::Number, p1::Number, p2::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, give_log) - ($f)(x::Number, p1::Number, p2::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, false) - @vectorize_2arg Number $f - @_jl_libRmath_vectorize_3arg $f + ($dd)(x::Number, p1::Number, give_log::Bool) = + ccall(dlsym(_jl_libRmath,$string(dd)), Float64, (Float64,Float64,Int32), x, p1, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, give_log::Bool) = + reshape([ ($dd)(x[i], p1, give_log) | i=1:numel(x) ], size(x)) + ($dd)(x::Number, give_log::Bool) = ($dd)(x, $d1, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, give_log::Bool) = ($dd)(x, $d1, give_log) + ($dd)(x::Number, p1::Number) = ($dd)(x, p1, false) + @vectorize_2arg Number $dd + ($dd)(x::Number) = ($dd)(x, $d1, false) + ($dd){T<:Number}(x::AbstractArray{T}) = ($dd)(x, $d1, false) + + ($pp)(q::Number, p1::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(pp)), Float64, (Float64,Float64,Int32,Int32), q, p1, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($pp)(q[i], p1, lower_tail, log_p) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, lower_tail::Bool, log_p::Bool) = ($pp)(q, $d1, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, lower_tail::Bool, log_p::Bool) = ($pp)(q, $d1, lower_tail, log_p) + ($pp)(q::Number, p1::Number, lower_tail::Bool) = ($pp)(q, p1, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($pp)(q, p1, lower_tail, false) + ($pp)(q::Number, lower_tail::Bool) = ($pp)(q, $d1, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, lower_tail::Bool) = ($pp)(q, $d1, lower_tail, false) + ($pp)(q::Number, p1::Number) = ($pp)(q, p1, true, false) + @vectorize_2arg Number $pp + ($pp)(q::Number) = ($pp)(q, $d1, true, false) + ($pp){T<:Number}(q::AbstractArray{T}) = ($pp)(q, $d1, true, false) + + ($qq)(p::Number, p1::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(qq)), Float64, (Float64,Float64,Int32,Int32), p, p1, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($qq)(p[i], p1, lower_tail, log_p) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, lower_tail::Bool, log_p::Bool) = ($qq)(p, $d1, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, lower_tail::Bool, log_p::Bool) = ($qq)(p, $d1, lower_tail, log_p) + ($qq)(p::Number, p1::Number, lower_tail::Bool) = ($qq)(p, p1, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($qq)(p, p1, lower_tail, false) + ($qq)(p::Number, lower_tail::Bool) = ($qq)(p, $d1, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, lower_tail::Bool) = ($qq)(p, $d1, lower_tail, false) + ($qq)(p::Number, p1::Number) = ($qq)(p, p1, true, false) + @vectorize_2arg Number $qq + ($qq)(p::Number) = ($qq)(p, $d1, true, false) + ($qq){T<:Number}(p::AbstractArray{T}) = ($qq)(p, $d1, true, false) + + ($rr)(nn::Integer, p1::Number) = + [ ccall(dlsym(_jl_libRmath,$string(rr)), Float64, (Float64,), p1) | i=1:nn ] + ($rr)(nn::Integer) = ($rr)(nn, $d1) end end -## Cumulative distribution function or quantile function for distributions with 2 parameters and no defaults -macro _jl_libRmathfunc_pq_2par_0d(f) - quote - ($f)(x::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, lower_tail, log_p) - ($f)(x::Number, p1::Number, p2::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, lower_tail, false) - ($f)(x::Number, p1::Number, p2::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, true, false) - @vectorize_2arg Number $f - @_jl_libRmath_vectorize_3arg $f - end -end +## May need to handle this as a special case. The Rmath library uses 1/rate, not rate +@_jl_libRmath_1par_1d exp 1 # Exponential distribution (rate) -## Density (or probability mass) function for distributions with 2 parameters and 1 default -macro _jl_libRmathfunc_d_2par_1d(f, d) +## Distributions with 2 parameters and no defaults +macro _jl_libRmath_2par_0d(base) + dd = symbol(strcat("d", string(base))) + pp = symbol(strcat("p", string(base))) + qq = symbol(strcat("q", string(base))) + rr = symbol(strcat("r", string(base))) quote - ($f)(x::Number, p1::Number, p2::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, give_log) - ($f)(x::Number, p1::Number, p2::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, false) - ($f)(x::Number, p1::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, $d, give_log) - ($f)(x::Number, p1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, $d, false) - @vectorize_2arg Number $f - @_jl_libRmath_vectorize_3arg $f + ($dd)(x::Number, p1::Number, p2::Number, give_log::Bool) = + ccall(dlsym(_jl_libRmath,$string(dd)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, p2::Number, give_log::Bool) = + reshape([ ($dd)(x[i], p1, p2, give_log) | i=1:numel(x) ], size(x)) + ($dd)(x::Number, p1::Number, p2::Number) = ($dd)(x, p1, p2, false) + @_jl_libRmath_vectorize_3arg $dd + + ($pp)(q::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(pp)), Float64, (Float64,Float64,Float64,Int32,Int32), q, p1, p2, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($pp)(q[i], p1, p2, lower_tail, log_p) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, p1::Number, p2::Number, lower_tail::Bool) = ($pp)(q, p1, p2, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool) = + reshape([ ($pp)(q[i], p1, p2, lower_tail, false) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, p1::Number, p2::Number) = ($pp)(q, p1, p2, true, false) + @_jl_libRmath_vectorize_3arg $pp + + ($qq)(p::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(qq)), Float64, (Float64,Float64,Float64,Int32,Int32), p, p1, p2, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($qq)(p[i], p1, p2, lower_tail, log_p) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, p1::Number, p2::Number, lower_tail::Bool) = ($qq)(p, p1, p2, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool) = + reshape([ ($qq)(p[i], p1, p2, lower_tail, false) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, p1::Number, p2::Number) = ($qq)(p, p1, p2, true, false) + @_jl_libRmath_vectorize_3arg $qq + + ($rr)(nn::Integer, p1::Number, p2::Number) = + [ ccall(dlsym(_jl_libRmath,$string(rr)), Float64, (Float64,Float64), p1, p2) | i=1:nn ] end end -## Cumulative distribution function or quantile function for distributions with 2 parameters and 1 default -macro _jl_libRmathfunc_pq_2par_1d(f, d) +@_jl_libRmath_2par_0d f # Central F distribution (df1, df2) +@_jl_libRmath_2par_0d binom # Binomial distribution (size, prob) +@_jl_libRmath_2par_0d nbinom # Negative binomial distribution (size, prob) +@_jl_libRmath_2par_0d nbinom_mu # Negative binomial distribution (size, mu) +@_jl_libRmath_2par_0d beta # Beta distribution (shape1, shape2) +@_jl_libRmath_2par_0d nchisq # Noncentral Chi-squared distribution (df, ncp) + +## Distributions with 2 parameters and 1 default +macro _jl_libRmath_2par_1d(base, d2) + dd = symbol(strcat("d", string(base))) + pp = symbol(strcat("p", string(base))) + qq = symbol(strcat("q", string(base))) + rr = symbol(strcat("r", string(base))) quote - ($f)(x::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, lower_tail, log_p) - ($f)(x::Number, p1::Number, p2::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, lower_tail, false) - ($f)(x::Number, p1::Number, p2::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, true, false) - ($f)(x::Number, p1::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, $d, lower_tail, log_p) - ($f)(x::Number, p1::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, $d, lower_tail, false) - ($f)(x::Number, p1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, $d, true, false) - @vectorize_2arg Number $f - @_jl_libRmath_vectorize_3arg $f + ($dd)(x::Number, p1::Number, p2::Number, give_log::Bool) = + ccall(dlsym(_jl_libRmath,$string(dd)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, p2::Number, give_log::Bool) = + reshape([ ($dd)(x[i], p1, p2, give_log) | i=1:numel(x) ], size(x)) + ($dd)(x::Number, p1::Number, give_log::Bool) = ($dd)(x, p1, $d2, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, give_log::Bool) = ($dd)(x, p1, $d2, give_log) + ($dd)(x::Number, p1::Number, p2::Number) = ($dd)(x, p1, p2, false) + @_jl_libRmath_vectorize_3arg $dd + ($dd)(x::Number, p1::Number) = ($dd)(x, p1, $d2, false) + @vectorize_2arg Number $dd + + ($pp)(q::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(pp)), Float64, (Float64,Float64,Float64,Int32,Int32), q, p1, p2, lower_tail, log_p) + ($pp)(q::Number, p1::Number, lower_tail::Bool, log_p::Bool) = ($pp)(q, p1, $d2, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($pp)(q[i], p1, p2, lower_tail, log_p) | i=1:numel(q) ], size(q)) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = ($pp)(q, p1, $d2, lower_tail, log_p) + ($pp)(q::Number, p1::Number, p2::Number, lower_tail::Bool) = ($pp)(q, p1, p2, lower_tail, false) + ($pp)(q::Number, p1::Number, lower_tail::Bool) = ($pp)(q, p1, $d2, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool) = ($pp)(q, p1, p2, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($pp)(q, p1, $d2, lower_tail, false) + ($pp)(q::Number, p1::Number, p2::Number) = ($pp)(q, p1, p2, true, false) + @_jl_libRmath_vectorize_3arg $pp + ($pp)(q::Number, p1::Number) = ($pp)(q, p1, $d2, true, false) + @vectorize_2arg Number $pp + + ($qq)(p::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(qq)), Float64, (Float64,Float64,Float64,Int32,Int32), p, p1, p2, lower_tail, log_p) + ($qq)(p::Number, p1::Number, lower_tail::Bool, log_p::Bool) = ($qq)(p, p1, $d2, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($qq)(p[i], p1, p2, lower_tail, log_p) | i=1:numel(p) ], size(p)) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = ($qq)(p, p1, $d2, lower_tail, log_p) + ($qq)(p::Number, p1::Number, p2::Number, lower_tail::Bool) = ($qq)(p, p1, p2, lower_tail, false) + ($qq)(p::Number, p1::Number, lower_tail::Bool) = ($qq)(p, p1, $d2, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool) = ($qq)(p, p1, p2, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($qq)(p, p1, $d2, lower_tail, false) + ($qq)(p::Number, p1::Number, p2::Number) = ($qq)(p, p1, p2, true, false) + @_jl_libRmath_vectorize_3arg $qq + ($qq)(p::Number, p1::Number) = ($qq)(p, p1, $d2, true, false) + @vectorize_2arg Number $qq + + ($rr)(nn::Integer, p1::Number, p2::Number) = + [ ccall(dlsym(_jl_libRmath,$string(rr)), Float64, (Float64,Float64), p1, p2) | i=1:nn ] + ($rr)(nn::Integer, p1::Number) = ($rr)(nn, p1, $d2) end end -## Density (or probability mass) function for distributions with 2 parameters and 2 defaults -macro _jl_libRmathfunc_d_2par_2d(f, d1, d2) +@_jl_libRmath_2par_1d gamma 1 # Gamma distribution (shape, scale) +@_jl_libRmath_2par_1d weibull 1 # Weibull distribution (shape, scale) + +## Distributions with 2 parameters and 2 defaults +macro _jl_libRmath_2par_2d(base, d1, d2) + ddsym = dd = symbol(strcat("d", string(base))) + ppsym = pp = symbol(strcat("p", string(base))) + qqsym = qq = symbol(strcat("q", string(base))) + rr = symbol(strcat("r", string(base))) + if (string(base) == "norm") + ddsym = :dnorm4 + ppsym = :pnorm5 + qqsym = :qnorm5 + end quote - ($f)(x::Number, p1::Number, p2::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, give_log) - ($f)(x::Number, p1::Number, p2::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, false) - ($f)(x::Number, p1::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, $d2, give_log) - ($f)(x::Number, p1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, p1, $d2, false) - ($f)(x::Number, give_log::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, $d1, $d2, give_log) - ($f)(x::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32), x, $d1, $d2, false) - @vectorize_2arg Number $f - @_jl_libRmath_vectorize_3arg $f + ($dd)(x::Number, p1::Number, p2::Number, give_log::Bool) = + ccall(dlsym(_jl_libRmath,$string(ddsym)), Float64, (Float64,Float64,Float64,Int32), x, p1, p2, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, p2::Number, give_log::Bool) = + reshape([ ($dd)(x[i], p1, p2, give_log) | i=1:numel(x) ], size(x)) + ($dd)(x::Number, p1::Number, give_log::Bool) = ($dd)(x, p1, $d2, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, give_log::Bool) = ($dd)(x, p1, $d2, give_log) + ($dd)(x::Number, give_log::Bool) = ($dd)(x, $d1, $d2, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, give_log::Bool) = ($dd)(x, $d1, $d2, give_log) + ($dd)(x::Number, p1::Number, p2::Number) = ($dd)(x, p1, p2, false) + @_jl_libRmath_vectorize_3arg $dd + ($dd)(x::Number, p1::Number) = ($dd)(x, p1, $d2, false) + @vectorize_2arg Number $dd + ($dd)(x::Number) = ($dd)(x, $d1, $d2, false) + ($dd){T<:Number}(x::AbstractArray{T}) = ($dd)(x, $d1, $d2, give_log) + + + ($pp)(q::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(ppsym)), Float64, (Float64,Float64,Float64,Int32,Int32), q, p1, p2, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($pp)(q[i], p1, p2, lower_tail, log_p) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, p1::Number, lower_tail::Bool, log_p::Bool) = ($pp)(q, p1, $d2, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = ($pp)(q, p1, $d2, lower_tail, log_p) + ($pp)(q::Number, lower_tail::Bool, log_p::Bool) = ($pp)(q, $d1, $d2, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, lower_tail::Bool, log_p::Bool) = ($pp)(q, $d1, $d2, lower_tail, log_p) + ($pp)(q::Number, p1::Number, p2::Number, lower_tail::Bool) = ($pp)(q, p1, p2, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool) = ($pp)(q, p1, p2, lower_tail, false) + ($pp)(q::Number, p1::Number, lower_tail::Bool) = ($pp)(q, p1, $d2, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($pp)(q, p1, $d2, lower_tail, false) + ($pp)(q::Number, lower_tail::Bool) = ($pp)(q, $d1, $d2, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, lower_tail::Bool) = ($pp)(q, $d1, $d2, lower_tail, false) + ($pp)(q::Number, p1::Number, p2::Number) = ($pp)(q, p1, p2, true, false) + @_jl_libRmath_vectorize_3arg $pp + ($pp)(q::Number, p1::Number) = ($pp)(q, p1, $d2, true, false) + @vectorize_2arg Number $pp + ($pp)(q::Number) = ($pp)(q, $d1, $d2, true, false) + ($pp){T<:Number}(q::AbstractArray{T}) = ($pp)(q, $d1, $d2, true, false) + + ($qq)(p::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(qqsym)), Float64, (Float64,Float64,Float64,Int32,Int32), p, p1, p2, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($qq)(p[i], p1, p2, lower_tail, log_p) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, p1::Number, lower_tail::Bool, log_p::Bool) = ($qq)(p, p1, $d2, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool, log_p::Bool) = ($qq)(p, p1, $d2, lower_tail, log_p) + ($qq)(p::Number, lower_tail::Bool, log_p::Bool) = ($qq)(p, $d1, $d2, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, lower_tail::Bool, log_p::Bool) = ($qq)(p, $d1, $d2, lower_tail, log_p) + ($qq)(p::Number, p1::Number, p2::Number, lower_tail::Bool) = ($qq)(p, p1, p2, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, lower_tail::Bool) = ($qq)(p, p1, p2, lower_tail, false) + ($qq)(p::Number, p1::Number, lower_tail::Bool) = ($qq)(p, p1, $d2, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, lower_tail::Bool) = ($qq)(p, p1, $d2, lower_tail, false) + ($qq)(p::Number, lower_tail::Bool) = ($qq)(p, $d1, $d2, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, lower_tail::Bool) = ($qq)(p, $d1, $d2, lower_tail, false) + ($qq)(p::Number, p1::Number, p2::Number) = ($qq)(p, p1, p2, true, false) + @_jl_libRmath_vectorize_3arg $qq + ($qq)(p::Number, p1::Number) = ($qq)(p, p1, $d2, true, false) + @vectorize_2arg Number $qq + ($qq)(p::Number) = ($qq)(p, $d1, $d2, true, false) + ($qq){T<:Number}(p::AbstractArray{T}) = ($qq)(p, $d1, $d2, true, false) + + ($rr)(nn::Integer, p1::Number, p2::Number) = + [ ccall(dlsym(_jl_libRmath,$string(rr)), Float64, (Float64,Float64), p1, p2) | i=1:nn ] + ($rr)(nn::Integer, p1::Number) = ($rr)(nn, p1, $d2) + ($rr)(nn::Integer) = ($rr)(nn, $d1, $d2) end end -## Cumulative distribution function or quantile function for distributions with 2 parameters and 2 defaults -macro _jl_libRmathfunc_pq_2par_2d(f, d1, d2) +@_jl_libRmath_2par_2d cauchy 0 1 # Cauchy distribution (location, scale) +@_jl_libRmath_2par_2d lnorm 0 1 # Log-normal distribution (meanlog, sdlog) +@_jl_libRmath_2par_2d logis 0 1 # Logistic distribution (location, scale) +@_jl_libRmath_2par_2d norm 0 1 # Normal (Gaussian) distribution (mu, sd) +@_jl_libRmath_2par_2d unif 0 1 # Uniform distribution (min, max) + +## Distributions with 3 parameters and no defaults +macro _jl_libRmath_3par_0d(base) + dd = symbol(strcat("d", string(base))) + pp = symbol(strcat("p", string(base))) + qq = symbol(strcat("q", string(base))) + rr = symbol(strcat("r", string(base))) quote - ($f)(x::Number, p1::Number, p2::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, lower_tail, log_p) - ($f)(x::Number, p1::Number, p2::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, lower_tail, false) - ($f)(x::Number, p1::Number, p2::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, p2, true, false) - ($f)(x::Number, p1::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, $d2, lower_tail, log_p) - ($f)(x::Number, p1::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, $d2, lower_tail, false) - ($f)(x::Number, p1::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, p1, $d2, true, false) - ($f)(x::Number, lower_tail::Bool, log_p::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, $d1, $d2, lower_tail, log_p) - ($f)(x::Number, lower_tail::Bool) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, $d1, $d2, lower_tail, false) - ($f)(x::Number) = - ccall(dlsym(_jl_libRmath,$string(f)), Float64, (Float64,Float64,Float64,Int32,Int32), x, $d1, $d2, true, false) - @vectorize_2arg Number $f - @_jl_libRmath_vectorize_3arg $f + ($dd)(x::Number, p1::Number, p2::Number, p3::Number, give_log::Bool) = + ccall(dlsym(_jl_libRmath,$string(dd)), Float64, (Float64,Float64,Float64,Float64,Int32), x, p1, p2, p3, give_log) + ($dd){T<:Number}(x::AbstractArray{T}, p1::Number, p2::Number, p3::Number, give_log::Bool) = + reshape([ ($dd)(x[i], p1, p2, p3, give_log) | i=1:numel(x) ], size(x)) + ($dd)(x::Number, p1::Number, p2::Number, p3::Number) = ($dd)(x, p1, p2, p3, false) + @_jl_libRmath_vectorize_4arg $dd + + ($pp)(q::Number, p1::Number, p2::Number, p3::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(pp)), Float64, (Float64,Float64,Float64,Float64,Int32,Int32), q, p1, p2, p3, lower_tail, log_p) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, p3::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($pp)(q[i], p1, p2, p3, lower_tail, log_p) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, p1::Number, p2::Number, p3::Number, lower_tail::Bool) = ($pp)(q, p1, p2, p3, lower_tail, false) + ($pp){T<:Number}(q::AbstractArray{T}, p1::Number, p2::Number, p3::Number, lower_tail::Bool) = + reshape([ ($pp)(q[i], p1, p2, p3, lower_tail, false) | i=1:numel(q) ], size(q)) + ($pp)(q::Number, p1::Number, p2::Number, p3::Number) = ($pp)(q, p1, p2, p3, true, false) + @_jl_libRmath_vectorize_4arg $pp + + ($qq)(p::Number, p1::Number, p2::Number, p3::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath,$string(qq)), Float64, (Float64,Float64,Float64,Float64,Int32,Int32), p, p1, p2, p3, lower_tail, log_p) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, p3::Number, lower_tail::Bool, log_p::Bool) = + reshape([ ($qq)(p[i], p1, p2, p3, lower_tail, log_p) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, p1::Number, p2::Number, p3::Number, lower_tail::Bool) = ($qq)(p, p1, p2, p3, lower_tail, false) + ($qq){T<:Number}(p::AbstractArray{T}, p1::Number, p2::Number, p3::Number, lower_tail::Bool) = + reshape([ ($qq)(p[i], p1, p2, p3, lower_tail, false) | i=1:numel(p) ], size(p)) + ($qq)(p::Number, p1::Number, p2::Number, p3::Number) = ($qq)(p, p1, p2, p3, true, false) + @_jl_libRmath_vectorize_4arg $qq + + ($rr)(nn::Integer, p1::Number, p2::Number, p3::Number) = + [ ccall(dlsym(_jl_libRmath,$string(rr)), Float64, (Float64,Float64,Float64), p1, p2, p3) | i=1:nn ] end end -## Central Chi-squared distribution (df) -@_jl_libRmathfunc_d_1par_0d dchisq -@_jl_libRmathfunc_pq_1par_0d pchisq -@_jl_libRmathfunc_pq_1par_0d qchisq -@_jl_libRmathfunc_r_1par_0d rchisq - -## Poisson distribution (lambda) -@_jl_libRmathfunc_d_1par_0d dpois -@_jl_libRmathfunc_pq_1par_0d ppois -@_jl_libRmathfunc_pq_1par_0d qpois -@_jl_libRmathfunc_r_1par_0d rpois - -## Signrank - Wilcoxon Signed Rank statistic -@_jl_libRmathfunc_d_1par_0d dsignrank -@_jl_libRmathfunc_pq_1par_0d psignrank -@_jl_libRmathfunc_pq_1par_0d qsignrank -@_jl_libRmathfunc_r_1par_0d rsignrank - -## Student's t distribution (df) -@_jl_libRmathfunc_d_1par_0d dt -@_jl_libRmathfunc_pq_1par_0d pt -@_jl_libRmathfunc_pq_1par_0d qt -@_jl_libRmathfunc_r_1par_0d rt - -## Geometric distribution (prob) -@_jl_libRmathfunc_d_1par_0d dgeom -@_jl_libRmathfunc_pq_1par_0d pgeom -@_jl_libRmathfunc_pq_1par_0d qgeom -@_jl_libRmathfunc_r_1par_0d rgeom - -## Exponential distribution (rate) -@_jl_libRmathfunc_d_1par dexp 1 -@_jl_libRmathfunc_pq_1par pexp 1 -@_jl_libRmathfunc_pq_1par qexp 1 - -## Central F distribution (df1, df2) -@_jl_libRmathfunc_d_2par_0d df -@_jl_libRmathfunc_pq_2par_0d pf -@_jl_libRmathfunc_pq_2par_0d qf - -## Binomial distribution (size, prob) -@_jl_libRmathfunc_d_2par_0d dbinom -@_jl_libRmathfunc_pq_2par_0d pbinom -@_jl_libRmathfunc_pq_2par_0d qbinom - -## Negative binomial distribution (size, prob) - alternative of mu needs to be written in Julia -@_jl_libRmathfunc_d_2par_0d dnbinom -@_jl_libRmathfunc_pq_2par_0d pnbinom -@_jl_libRmathfunc_pq_2par_0d qnbinom - -## Beta distribution (shape1, shape2) -@_jl_libRmathfunc_d_2par_0d dbeta -@_jl_libRmathfunc_pq_2par_0d pbeta -@_jl_libRmathfunc_pq_2par_0d qbeta - -## Noncentral Chi-squared distribution (df, ncp) -@_jl_libRmathfunc_d_2par_0d dnchisq -@_jl_libRmathfunc_pq_2par_0d pnchisq -@_jl_libRmathfunc_pq_2par_0d qnchisq +@_jl_libRmath_3par_0d hyper # Hypergeometric (m, n, k) +@_jl_libRmath_3par_0d nbeta # Non-central beta (shape1, shape2, ncp) +@_jl_libRmath_3par_0d nf # Non-central F (df1, df2, ncp) -## Wilcox - Wilcox's Rank Sum statistic (m, n) - probably only makes sense for positive integers -@_jl_libRmathfunc_d_2par_0d dwilcox -@_jl_libRmathfunc_pq_2par_0d pwilcox -@_jl_libRmathfunc_pq_2par_0d qwilcox - -## Gamma distribution (shape, scale) -@_jl_libRmathfunc_d_2par_1d dgamma 1 -@_jl_libRmathfunc_pq_2par_1d pgamma 1 -@_jl_libRmathfunc_pq_2par_1d qgamma 1 - -## Weibull distribution (shape, scale) -@_jl_libRmathfunc_d_2par_1d dweibull 1 -@_jl_libRmathfunc_pq_2par_1d pweibull 1 -@_jl_libRmathfunc_pq_2par_1d qweibull 1 - -## Log-normal distribution (meanlog, sdlog) -@_jl_libRmathfunc_d_2par_2d dlnorm 0 1 -@_jl_libRmathfunc_pq_2par_2d plnorm 0 1 -@_jl_libRmathfunc_pq_2par_2d qlnorm 0 1 - -## Logistic distribution (location, scale) -@_jl_libRmathfunc_d_2par_2d dlogis 0 1 -@_jl_libRmathfunc_pq_2par_2d plogis 0 1 -@_jl_libRmathfunc_pq_2par_2d qlogis 0 1 - -## Cauchy distribution (location, scale) -@_jl_libRmathfunc_d_2par_2d dcauchy 0 1 -@_jl_libRmathfunc_pq_2par_2d pcauchy 0 1 -@_jl_libRmathfunc_pq_2par_2d qcauchy 0 1 - -## Not done yet -## hyper (Hypergeometric, 3pars, no defaults; I'm not sure I even want to think of vectorize_4args) -## nbeta (Noncentral beta, 3pars, no defaults) -## nf (Noncentral f, 3pars, no defaults) ## tukey (Studentized Range Distribution - p and q only - 3pars) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,nmeans,df,lower_tail,log_p) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,nmeans,df,lower_tail,false) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,nmeans,df,true,false) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool, log_p::Bool) = + reshape([ptukey(q[i],nmeans,df,nranges,lower_tail,log_p)|i=1:numel(q)], size(q)) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool) = + reshape([ptukey(q[i],nmeans,df,nranges,lower_tail,false)|i=1:numel(q)], size(q)) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number) = + reshape([ptukey(q[i],nmeans,df,nranges,true,false)|i=1:numel(q)], size(q)) -## An version of pow from R (probably not necessary) -## returns x^y -function R_pow(x::Number, y::Number) - if isa(y, Integer) - return ccall(dlsym(_jl_libRmath, :R_pow_di), Float64, (Float64, Int32), x, y) - end - ccall(dlsym(_jl_libRmath, :R_pow), Float64, (Float64, Float64), x, y) -end - +## tukey (Studentized Range Distribution - p and q only - 3pars) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,nmeans,df,lower_tail,log_p) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,nmeans,df,lower_tail,false) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,nmeans,df,true,false) +ptukey(q::Number, nmeans::Number, df::Number, nranges::Number) = + ccall(dlsym(_jl_libRmath, :ptukey), Float64, (Float64,Float64,Float64,Int32,Int32),q,nranges,1.,df,true,false) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool, log_p::Bool) = + reshape([ptukey(q[i],nmeans,df,nranges,lower_tail,log_p)|i=1:numel(q)], size(q)) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool) = + reshape([ptukey(q[i],nmeans,df,nranges,lower_tail,false)|i=1:numel(q)], size(q)) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number) = + reshape([ptukey(q[i],nmeans,df,nranges,true,false)|i=1:numel(q)], size(q)) +ptukey{T<:Number}(q::AbstractArray{T}, nmeans::Number, df::Number) = + reshape([ptukey(q[i],nmeans,df,1.,true,false)|i=1:numel(q)], size(q)) + +qtukey(q::Number, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool, log_p::Bool) = + ccall(dlsym(_jl_libRmath, :qtukey), Float64, (Float64,Float64,Float64,Int32,Int32),p,nranges,nmeans,df,lower_tail,log_p) +qtukey(p::Number, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool) = + ccall(dlsym(_jl_libRmath, :qtukey), Float64, (Float64,Float64,Float64,Int32,Int32),p,nranges,nmeans,df,lower_tail,false) +qtukey(p::Number, nmeans::Number, df::Number, nranges::Number) = + ccall(dlsym(_jl_libRmath, :qtukey), Float64, (Float64,Float64,Float64,Int32,Int32),p,nranges,nmeans,df,true,false) +qtukey(p::Number, nmeans::Number, df::Number) = + ccall(dlsym(_jl_libRmath, :qtukey), Float64, (Float64,Float64,Float64,Int32,Int32),p,nranges,1.,df,true,false) +qtukey{T<:Number}(p::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool, log_p::Bool) = + reshape([qtukey(p[i],nmeans,df,nranges,lower_tail,log_p)|i=1:numel(p)], size(p)) +qtukey{T<:Number}(p::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number, lower_tail::Bool) = + reshape([qtukey(p[i],nmeans,df,nranges,lower_tail,false)|i=1:numel(p)], size(p)) +qtukey{T<:Number}(p::AbstractArray{T}, nmeans::Number, df::Number, nranges::Number) = + reshape([qtukey(p[i],nmeans,df,nranges,true,false)|i=1:numel(p)], size(p)) +qtukey{T<:Number}(p::AbstractArray{T}, nmeans::Number, df::Number) = + reshape([qtukey(p[i],nmeans,df,1.,true,false)|i=1:numel(p)], size(p)) diff --git a/test/Rmath.jl b/test/Rmath.jl index 179dcdca8ddaa..2d1fd2dc35d8b 100644 --- a/test/Rmath.jl +++ b/test/Rmath.jl @@ -1,6 +1,21 @@ -# R_pow -@assert abs(R_pow(2.0, 3) - 8.0) < 10e-8 -@assert abs(R_pow(2.0, 1/2) - sqrt(2.0)) < 10e-8 +load("Rmath.jl") + +function allEq(target::Vector{Float64}, current::Vector{Float64}, tolerance::Float64) + @assert numel(target) == numel(current) + if all(target == current) + return true + end + xy = mean(abs(target - current)) + xn = mean(abs(target)) + if (isfinite(xn) && xn > tolerance) + xy /= xn + end + @assert xy < tolerance + return true +end + +allEq(target::Vector{Float64}, current::Vector{Float64}) = + allEq(target, current, sqrt(eps())) # dbeta @assert abs(dbeta(-1, 1, 1) - 0.0) < 10e-8 @@ -24,3 +39,158 @@ @assert abs(dexp(1, 2) - (1 / 2) * exp(-(1 / 2) * 1)) < 10e-8 @assert abs(dexp(1, 3) - (1 / 3) * exp(-(1 / 3) * 1)) < 10e-8 @assert abs(dexp(2, 3) - (1 / 3) * exp(-(1 / 3) * 2)) < 10e-8 + +n = 26 + +Rbeta = rbeta (n, .8, 2) +Rbinom = rbinom (n, 55, pi/16) +Rcauchy = rcauchy (n, 12, 2) +Rchisq = rchisq (n, 3) +Rexp = rexp (n, 2) +Rf = rf (n, 12, 6) +Rgamma = rgamma (n, 2, 5) +Rgeom = rgeom (n, pi/16) +Rhyper = rhyper (n, 40, 30, 20) +Rlnorm = rlnorm (n, -1, 3) +Rlogis = rlogis (n, 12, 2) +Rnbinom = rnbinom (n, 7, .01) +Rnorm = rnorm (n, -1, 3) +Rpois = rpois (n, 12) +Rsignrank = rsignrank(n, 47) +Rt = rt (n, 11) +## Rt2 below (to preserve the following random numbers!) +Runif = runif (n, .2, 2) +Rweibull = rweibull (n, 3, 2) +Rwilcox = rwilcox (n, 13, 17) +Rt2 = rt (n, 1.01) + +Pbeta = pbeta (Rbeta, .8, 2) +Pbinom = pbinom (Rbinom, 55, pi/16) +Pcauchy = pcauchy (Rcauchy, 12, 2) +Pchisq = pchisq (Rchisq, 3) +Pexp = pexp (Rexp, 2) +Pf = pf (Rf, 12, 6) +Pgamma = pgamma (Rgamma, 2, 5) +Pgeom = pgeom (Rgeom, pi/16) +Phyper = phyper (Rhyper, 40, 30, 20) +Plnorm = plnorm (Rlnorm, -1, 3) +Plogis = plogis (Rlogis, 12, 2) +Pnbinom = pnbinom (Rnbinom, 7, .01) +Pnorm = pnorm (Rnorm, -1, 3) +Ppois = ppois (Rpois, 12) +#Psignrank = psignrank(Rsignrank, 47) +Pt = pt (Rt, 11) +Pt2 = pt (Rt2, 1.01) +Punif = punif (Runif, .2, 2) +Pweibull = pweibull (Rweibull, 3, 2) +#Pwilcox = pwilcox (Rwilcox, 13, 17) + +dbeta (Rbeta, .8, 2) +dbinom (Rbinom, 55, pi/16) +dcauchy (Rcauchy, 12, 2) +dchisq (Rchisq, 3) +dexp (Rexp, 2) +df (Rf, 12, 6) +dgamma (Rgamma, 2, 5) +dgeom (Rgeom, pi/16) +dhyper (Rhyper, 40, 30, 20) +dlnorm (Rlnorm, -1, 3) +dlogis (Rlogis, 12, 2) +dnbinom (Rnbinom, 7, .01) +dnorm (Rnorm, -1, 3) +dpois (Rpois, 12) +#dsignrank(Rsignrank, 47) +dt (Rt, 11) +dunif (Runif, .2, 2) +dweibull (Rweibull, 3, 2) +#dwilcox (Rwilcox, 13, 17) + +## Check q*(p*(.)) = identity +allEq(Rbeta, qbeta (Pbeta, .8, 2)) +allEq(Rbinom, qbinom (Pbinom, 55, pi/16)) +allEq(Rcauchy, qcauchy (Pcauchy, 12, 2)) +allEq(Rchisq, qchisq (Pchisq, 3)) +allEq(Rexp, qexp (Pexp, 2)) +allEq(Rf, qf (Pf, 12, 6)) +allEq(Rgamma, qgamma (Pgamma, 2, 5)) +allEq(Rgeom, qgeom (Pgeom, pi/16)) +allEq(Rhyper, qhyper (Phyper, 40, 30, 20)) +allEq(Rlnorm, qlnorm (Plnorm, -1, 3)) +allEq(Rlogis, qlogis (Plogis, 12, 2)) +allEq(Rnbinom, qnbinom (Pnbinom, 7, .01)) +allEq(Rnorm, qnorm (Pnorm, -1, 3)) +allEq(Rpois, qpois (Ppois, 12)) +#allEq(Rsignrank, qsignrank(Psignrank, 47)) +allEq(Rt, qt (Pt, 11)) +allEq(Rt2, qt (Pt2, 1.01), 1e-2) +allEq(Runif, qunif (Punif, .2, 2)) +allEq(Rweibull, qweibull (Pweibull, 3, 2)) +#allEq(Rwilcox, qwilcox (Pwilcox, 13, 17)) + +## Same with "upper tail": +allEq(Rbeta, qbeta (1- Pbeta, .8, 2, false)) +allEq(Rbinom, qbinom (1- Pbinom, 55, pi/16, false)) +allEq(Rcauchy, qcauchy (1- Pcauchy, 12, 2, false)) +allEq(Rchisq, qchisq (1- Pchisq, 3, false)) +allEq(Rexp, qexp (1- Pexp, 2, false)) +allEq(Rf, qf (1- Pf, 12, 6, false)) +allEq(Rgamma, qgamma (1- Pgamma, 2, 5, false)) +allEq(Rgeom, qgeom (1- Pgeom, pi/16, false)) +allEq(Rhyper, qhyper (1- Phyper, 40, 30, 20, false)) +allEq(Rlnorm, qlnorm (1- Plnorm, -1, 3, false)) +allEq(Rlogis, qlogis (1- Plogis, 12, 2, false)) +allEq(Rnbinom, qnbinom (1- Pnbinom, 7, .01, false)) +allEq(Rnorm, qnorm (1- Pnorm, -1, 3,false)) +allEq(Rpois, qpois (1- Ppois, 12, false)) +#allEq(Rsignrank, qsignrank(1- Psignrank, 47, false)) +allEq(Rt, qt (1- Pt, 11, false)) +allEq(Rt2, qt (1- Pt2, 1.01, false), 1e-2) +allEq(Runif, qunif (1- Punif, .2, 2, false)) +allEq(Rweibull, qweibull (1- Pweibull, 3, 2, false)) +#allEq(Rwilcox, qwilcox (1- Pwilcox, 13, 17, false)) + +## Check q*(p* ( log ), log) = identity +allEq(Rbeta, qbeta (log(Pbeta), .8, 2, true, true)) +allEq(Rbinom, qbinom (log(Pbinom), 55, pi/16, true, true)) +allEq(Rcauchy, qcauchy (log(Pcauchy), 12, 2, true, true)) +allEq(Rchisq, qchisq (log(Pchisq), 3, true, true), 1e-14) +allEq(Rexp, qexp (log(Pexp), 2, true, true)) +allEq(Rf, qf (log(Pf), 12, 6, true, true)) +allEq(Rgamma, qgamma (log(Pgamma), 2, 5, true, true)) +allEq(Rgeom, qgeom (log(Pgeom), pi/16, true, true)) +allEq(Rhyper, qhyper (log(Phyper), 40, 30, 20, true, true)) +allEq(Rlnorm, qlnorm (log(Plnorm), -1, 3, true, true)) +allEq(Rlogis, qlogis (log(Plogis), 12, 2, true, true)) +allEq(Rnbinom, qnbinom (log(Pnbinom), 7, .01, true, true)) +allEq(Rnorm, qnorm (log(Pnorm), -1, 3, true, true)) +allEq(Rpois, qpois (log(Ppois), 12, true, true)) +#allEq(Rsignrank, qsignrank(log(Psignrank), 47, true, true)) +allEq(Rt, qt (log(Pt), 11, true, true)) +allEq(Rt2, qt (log(Pt2), 1.01, true, true), 1e-2) +allEq(Runif, qunif (log(Punif), .2, 2, true, true)) +allEq(Rweibull, qweibull (log(Pweibull), 3, 2, true, true)) +#allEq(Rwilcox, qwilcox (log(Pwilcox), m = 13, n = 17, true, true)) + +## same q*(p* (log) log) with upper tail: + +allEq(Rbeta, qbeta (log(1- Pbeta), .8, 2, false, true)) +allEq(Rbinom, qbinom (log(1- Pbinom), 55, pi/16, false, true)) +allEq(Rcauchy, qcauchy (log(1- Pcauchy), 12, 2, false, true)) +allEq(Rchisq, qchisq (log(1- Pchisq), 3, false, true)) +allEq(Rexp, qexp (log(1- Pexp), 2, false, true)) +allEq(Rf, qf (log(1- Pf), 12, 6, false, true)) +allEq(Rgamma, qgamma (log(1- Pgamma), 2, 5, false, true)) +allEq(Rgeom, qgeom (log(1- Pgeom), pi/16, false, true)) +allEq(Rhyper, qhyper (log(1- Phyper), 40, 30, 20, false, true)) +allEq(Rlnorm, qlnorm (log(1- Plnorm), -1, 3, false, true)) +allEq(Rlogis, qlogis (log(1- Plogis), 12, 2, false, true)) +allEq(Rnbinom, qnbinom (log(1- Pnbinom), 7, .01, false, true)) +allEq(Rnorm, qnorm (log(1- Pnorm), -1, 3, false, true)) +allEq(Rpois, qpois (log(1- Ppois), 12, false, true)) +#allEq(Rsignrank, qsignrank(log(1- Psignrank), 47, false, true)) +allEq(Rt, qt (log(1- Pt ), 11, false, true)) +allEq(Rt2, qt (log(1- Pt2), 1.01, false, true), 1e-2) +allEq(Runif, qunif (log(1- Punif), .2, 2, false, true)) +allEq(Rweibull, qweibull (log(1- Pweibull), 3, 2, false, true)) +#allEq(Rwilcox, qwilcox (log(1- Pwilcox), 13, 17, false, true)) +