Type inconsistencies

[cscherrer]

There are some serious type inconsistencies here:

julia> b = Bernoulli()
Bernoulli{Float64}(p=0.5)

julia> rand(b)
false

julia> rand(b,1)
1-element Array{Int64,1}:
 0

julia> eltype(b)
Int64

Can we please have rand(dist) :: T imply

• rand(dist, n::Int) :: Array{T}
• eltype(dist) == T
  ?

[matbesancon]

Both fixes are acceptable (moving everything to Bool or to Int)

[cscherrer]

Thanks @matbesancon.

Bool seems a better fit to me, any objections (from anyone)?

Any thoughts on rand(dist, n::Int) :: Array{T}? This would require significant breaking changes for multivariate and matrix-variate distributions, but to me it seems worth it to avoid having to consider special cases.

I can understand the reasoning for the current approach: a regular array-of-vectors is more efficiently stored in a matrix. But the lack of regularity in the interface is a bit painful. It seems like we need a way to store something as a matrix but access it as an array of vectors. I thought I had seen a library that provides this capability, but I'm having trouble finding it right now. Any ideas?

[matbesancon]

Bool seems a better fit to me, any objections (from anyone)?

I'm good with Bool on this, the fact that Bool is an Integer is helpful here.

Any thoughts on rand(dist, n::Int) :: Array{T}? This would require significant breaking changes for multivariate and matrix-variate distributions, but to me it seems worth it to avoid having to consider special cases.

We have to keep in mind that the standard method is always rand(RNG, ...), which fallbacks to rand(Random.GLOBAL_RNG, ...). The new rand interface would be:

rand(RNG, dist::Distribution, n::Integer) :: AbstractArray{T}

The AbstractArray subtype used is specialized for the distribution.

It seems like we need a way to store something as a matrix but access it as an array of vectors. I thought I had seen a library that provides this capability, but I'm having trouble finding it right now. Any ideas?

RecursiveArrayTools.jl could do the job

[cscherrer]

RecursiveArrayTools.jl could do the job

I had thought this too, but it seems to solve the problem of treating a vector-of-vectors as a matrix, while we need to go the other way.

A few years ago I saw a nice approach in Haskell that gave a nice way to build abstractions on customized efficient internal representations. I'll see if I can find it, in case it's not too Haskell-specific; maybe some of the ideas can apply here

[matbesancon]

This would require significant breaking changes for multivariate and matrix-variate distributions

If it improves consistency it's fine, we can always add breaking changes