Avoid unneeded array traversals (#108)

## `insupport` for product measures

`insupport` currently has this method:
```julia
@inline function insupport(d::AbstractProductMeasure, x::AbstractArray)
    mar = marginals(d)
    for (j, mj) in enumerate(mar)
        dynamic(insupport(mj, x[j])) || return false
    end
    return true
end
```
But we can often infer that we're in the support, so we can save the cost of traversing the array. This PR changes this to 
```julia
@inline function insupport(d::AbstractProductMeasure, x::AbstractArray)
    mar = marginals(d)
    # We might get lucky and know statically that everything is inbounds
    T = Core.Compiler.return_type(insupport, Tuple{eltype(mar),eltype(x)})
    T <: True || all(zip(x, mar)) do (xj, mj)
        insupport(mj, xj) == true
    end
end
```

## `logdensity_def` for powers of primitive measures

Again, we're currently traversing the array unnecessarily. This PR adds these methods

```julia
logdensity_def(::PowerMeasure{P}, x) where {P<:PrimitiveMeasure} = static(0.0)

# To avoid ambiguities
function logdensity_def(
    ::PowerMeasure{P,Tuple{Vararg{Base.OneTo{Static.StaticInt{0}},N}}},
    x,
) where {P<:PrimitiveMeasure,N}
    static(0.0)
end
```

## `istrue`

Lots of code expecting a Bool doesn't work for StaticBools. In these cases, we instead need to check e.g. `p == true`. I've added `istrue(p) = p == true` to make this a little simpler

Author: cscherrer

src/MeasureBase.jl

@@ -90,6 +90,9 @@ using LogExpFunctions: logsumexp, logistic, logit
 
 @deprecate instance_type(x) Core.Typeof(x) false
 
+# Mostly useful for StaticBools
+istrue(p) = p == true
+
 """
 `logdensity_def` is the standard way to define a log-density for a new measure.
 Note that this definition does not include checking for membership in the

src/combinators/power.jl

@@ -130,3 +130,13 @@ function checked_arg(μ::PowerMeasure, x::Any)
 end
 
 massof(m::PowerMeasure) = massof(m.parent)^prod(m.axes)
+
+logdensity_def(::PowerMeasure{P}, x) where {P<:PrimitiveMeasure} = static(0.0)
+
+# To avoid ambiguities
+function logdensity_def(
+    ::PowerMeasure{P,Tuple{Vararg{Base.OneTo{Static.StaticInt{0}},N}}},
+    x,
+) where {P<:PrimitiveMeasure,N}
+    static(0.0)
+end

src/combinators/product.jl

@@ -212,10 +212,11 @@ end
 
 @inline function insupport(d::AbstractProductMeasure, x::AbstractArray)
     mar = marginals(d)
-    for (j, mj) in enumerate(mar)
-        dynamic(insupport(mj, x[j])) || return false
+    # We might get lucky and know statically that everything is inbounds
+    T = Core.Compiler.return_type(insupport, Tuple{eltype(mar),eltype(x)})
+    T <: True || all(zip(x, mar)) do (xj, mj)
+        insupport(mj, xj) == true
     end
-    return true
 end
 
 @inline function insupport(d::AbstractProductMeasure, x)

src/combinators/superpose.jl

@@ -70,8 +70,8 @@ oneplus(x::ULogarithmic) = exp(ULogarithmic, log1pexp(x.log))
 @inline function density_def(s::SuperpositionMeasure{Tuple{A,B}}, x) where {A,B}
     (μ, ν) = s.components
 
-    insupport(μ, x) || return exp(ULogarithmic, logdensity_def(ν, x))
-    insupport(ν, x) || return exp(ULogarithmic, logdensity_def(μ, x))
+    istrue(insupport(μ, x)) || return exp(ULogarithmic, logdensity_def(ν, x))
+    istrue(insupport(ν, x)) || return exp(ULogarithmic, logdensity_def(μ, x))
 
     α = basemeasure(μ)
     β = basemeasure(ν)
@@ -110,8 +110,8 @@ end
 ) where {T<:(SuperpositionMeasure{Tuple{A,B}} where {A,B})}
     (μ, ν) = s.components
 
-    insupport(μ, x) == true || return logdensity_rel(ν, β, x)
-    insupport(ν, x) == true || return logdensity_rel(μ, β, x)
+    istrue(insupport(μ, x)) || return logdensity_rel(ν, β, x)
+    istrue(insupport(ν, x)) || return logdensity_rel(μ, β, x)
     return logaddexp(logdensity_rel(μ, β, x), logdensity_rel(ν, β, x))
 end
 
@@ -121,8 +121,8 @@ end
     x,
 ) where {A,B}
     (μ, ν) = s.components
-    insupport(μ, x) == true || return logdensity_rel(ν, β, x)
-    insupport(ν, x) == true || return logdensity_rel(μ, β, x)
+    istrue(insupport(μ, x)) || return logdensity_rel(ν, β, x)
+    istrue(insupport(ν, x)) || return logdensity_rel(μ, β, x)
     return logaddexp(logdensity_rel(μ, β, x), logdensity_rel(ν, β, x))
 end
 

src/interface.jl

@@ -30,7 +30,7 @@ function dynamic_basemeasure_depth(μ::M) where {M}
         π = proxy(μ)
         if static_hasmethod(basemeasure, Tuple{typeof(π)})
             basemeasure(π) == basemeasure(μ) && return dynamic_basemeasure_depth(π)
-        end        
+        end
     end
     β = basemeasure(μ)
     depth = 0
@@ -112,17 +112,17 @@ function test_smf(μ, n = 100)
         p = rand(n)
         p .+= 0:n-1
         p .*= inv(n)
-        
+
         F(x) = smf(μ, x)
         Finv(p) = invsmf(μ, p)
-        
+
         @assert issorted(p)
         x = invsmf.(μ, p)
         @test issorted(x)
         @test all(insupport(μ), x)
-        
+
         @test all((Finv ∘ F).(x) .≈ x)
-        
+
         for j in 1:n
             a = rand()
             b = rand()

src/primitive.jl

@@ -19,7 +19,7 @@ basemeasure(μ::PrimitiveMeasure) = μ
 
 @inline basemeasure_depth(::PrimitiveMeasure) = static(0)
 
-logdensity_def(μ::PrimitiveMeasure, x) = static(0.0)
+logdensity_def(::PrimitiveMeasure, x) = static(0.0)
 
 logdensity_def(μ::M, ν::M, x) where {M<:PrimitiveMeasure} = 0.0