Dev (#107)

* clean up `For` dispatch

* simplify _logdensityof

* optimize for Returns{True} case

* rework basemeasure_depth

* aggressive tests passing!!

* drop type-level stuff

* drop help

* license

* affero

* copyright notice

* merge

* Drop Create Commons

* cleanup after merge

* update support computations

* insupport(d::SuperpositionMeasure, x)

* dorp ParamWeighted

* insupport(d::FactoredBase, x)

* export unsafe_logdensityof

* call promote_type instead of promote_rule

* logdensity_def for named tuple product measures

* type annotation for now

* debugging

* drop shows

* speed up mapped arrays

* throw an error for `Union{}` types

* MT tests passing

* updates

* get tests passing

* MIT license for MeasureBase

* bump version

* cleanup

* spacing

* Move ConditionalMeasure to MeasureBase

* add LogarithmicNumbers

* export basemeasure_sequence

* update superpose

* fix logdensity_rel

* remove FIXME (it's fixed!!)

* logdensityof(d::Density, x)

* simplify insupport(::Lebesgue, ::Real)

* clean up

* assume insupport yields Bool

* change logdensity_rel fall-through to warning and return NaN

* update logdensity_rel

* drop old code

* fix warning

* export logdensity_rel

* logdensity_def(μ::Dirac, ν::Dirac, x)

* logdensity_def methods

* drop `static`

* ]add StatsFuns

* Fixing up superposition

* [compat] entries

* trying to speed things up

* bugfixes

* logdensity_rel tests

* logdensity_rel tests

* drop qualifier, and add a test

* more tests

* type constraint in "logdensityof(μ::AbstractMeasure, x)" (was piracy, oops)

* add some docs

* docs

* docs

* typo

* moar speed

* don't export Test

* some more updates

* logdensity_rel for products

* `kleisli` docs

* update instance_type

* instance_type => Core.Typeof

* `powermeasure` bug fix

* fix logdensity_rel bug

* get `commonbase` to take x type into account

* test powers

* commonbase docstring

* deprecate instance_type

* avoid breakage

* switch || terms

* @ifelse macro

* simplify logdensity_rel

* give up on this @ifelse business

* bump version

* working on likelihoods

* update likelihood

* powerweightedmeasure

* powerweighted update

* more powerweighted methods

* bugfix

* dropFactoredBase

* drop FactoredBase

* (::ProductMeasure) | constraint

* update conditional measure

* update Dirac

* move conditional.jl down in the `include`s

* Kleisli => TransitionKernel

* simplify logdensity_def(::PowerMeasure, x)

* rename kleisli.jl to kernel.jl

* update Dirac tests

* update Half

* get tests passing

* update kernel

* Update Project.toml

* no call-site inlining

* restrict single-arg `kernel` to <:ParameterizedMeasure

* export log_likelihood_ratio

* Drop DensityKind(::Likelihood), at least for now

* isfinite(x) instead of x>-Inf

* add `condition` constructor

* EOF newline

* simplify logdensity_def for power measures

* finishing up

* updates

* kernel stuff

* kernel stuff

* update showe methods

* ass a TODO

* use `dot` instead of `sum`

* drop old code

* typo

* formatting

* cleanup

* kernel updates

* uncomment

* bugfix

* drop old code

* pretty printing

* exports, cleanup

* drop old for.jl

* Make DensityKind(::AbstractLikelihood) = IsDensity()

* update Compat version

* Make likelihoods work with Distributions

* _map(f, x::MappedArrays.ReadonlyMappedArray)

* export productmeasure

* AbstractMeasure(::AbstractMeasure)

* fixedrng

* StdNormal

* add SpecialFunctions

* no need to qualify

* update basemeasure

* include stdnormal

* include fixedrng

* update tests

* using SpecialFunctions

* fixing transport_def

* transport_def bugfix

* StdMeasure(::typeof(randn))

* checked_arg  for LebesgueMeasure

* NoTransformOrigin => NoTransportOrigin

* transport interface for pushforwards

* transporting pushforwards

* Use LebesgueMeasure for basemeasure

* updates

* make testvalue fall back on FixedRNG approach

* un-break testvalue

* CI for Juila 1.8

* fixes

* `rand` on a pushforward calls rand on its parent

* LebesgueMeasure => LebesgueBase
CountingMeasure => CountingBase

* tests passing!

* change `invoke` type

* Change `test_interface` to check for 2-arg testvalue

* manually-specifed inverses

* more pushfwd stuff

* A little less wrong

* add mass interface

* pullback

* mass interface

* working on mass interface

* add some `massof` methods

* Maybe <:Number is better for invalidations?

* float instead of Int

* logmassof

* transports for proxies

* drop latent-joint.jl

* drop exports

* Drop `logmassof` for now

* reorganize Lebesgue measure

* IntervalSets

* proxy(::Lebesgue{MeasureBase.RealNumbers}) = LebesgueBase()

* calling a "useproxy" measure calls its proxy

* StdUniform()(s::Interval)

* typo

* (m::AbstractMeasure)(s::Interval)

* bugfix

* comment

* IntervalSets version constraint

* update dynamic_basemeasure_depth

* format

* Calling a measure calls `massof`

* work on massof

* AbstractSuperpositionMeasure

* fix typo

* typo

* format

* docstrings

* remove massof(::PowerWeightedMeasure) method

* make `massof` better

* update testvalue

* formatting

* update _massof

* Update transports for weighted measures

* add chain rules

* invariant mass under transport

* typo

* bugfix

* hasmethod => Tricks.static_hasmethod

* `massof` methods

* roll back tranports for WeightedMeasure

* Improve transport implementation and add product support (#97)

* Improve default transport implementation

Increases type stability.

* Rename NoTransformOrigin to NoTransportOrigin

* Add rrule for _origin_depth

* Fix ambiguities when forwarding NoTransportOrigin and NoTransportOrigin

* Define getdof for product measures

* Generalize test_transport to tuple-valued measures

* Implement transport for tuple-based products

Co-authored-by: Chad Scherrer <chad.scherrer@gmail.com>

* `@useproxy` delegates `massof`

* drop CI for nightly

* callable densities (#85)

* callable densities

* separate `Density` and `LogDensity`, etc

* bugfix

* move some code around

* format

* updates

* working on densities

* update CI

* bugfix

* formatting

* reorg

* fix typos

* Drop LogDensityMeasure and refactor

* docstring

* inner type constructor with assertion

* type parameters

* 2-arg density_rel and logdensity_rel

* oops

* properties

* typo

* fix ambiguity

* bugfix

* bugfix

* updates

* drop densityof and logdensityof for AbstractDensity

* updates

* update tests

* update

* formatting

* bad calls throw errors

* drop CI for nightly

* Pushfwd-inverses (#98)

* use InverseFunctions.setinverse

* bug fixes

* bugfix

* bugfix

* pushfwd of a pushfwd

* format

* drop old comment

* drop CI for nightly

* working on pushfwd

* bugfix

* inverse(f) => ν.finv

* separate logdensity functions from transport API

* format

* don't unwrap FunctionWithInverse

* drop redundant method

* leave logdensityof alone, instead write unsafe_logdensityof

* more tests

* more work on tests

* tests

* tests

* still messing with tests

* tests passing

* small edits

* formatting

* add some more failing tests

* add atol to isapprox in test

* getdof(μ::PushforwardMeasure) = getdof(transport_origin(μ))

* update atol

* small fix

* drop ((-) ∘ log1p ∘ (-), StdUniform(), StdExponential())

* remove duplicate method

* remove duplicate `include`

* simplify getdof(::PushforwardMeasure)

* Stieltjes measure function (#100)

* smf

* more smf stuff

* transport_to

* Lebesgue smf

* smf for std measures

* format

* transport_to

* oops

* smfinv

* bugfix

* more fixes

* minor refactoring

* formatting

* change x to p

* bugfix

* smfinv(::StdLogistic, p)

* add NoSMF and NoSMFInverse

* roll back some changes

* transport_def methods

* formatting

* another rollback

* make transport_def depend on smf(inv)

* update smf and transports for ::Half

* change `include` order

* test_smf

* more tests

* tests

* add tests

* formatting

* Drop unneeded type parameters

* smfinv => invsmf

* add some inverses

* Base.Fix1 versions

* some more methods

* drop redundant `transport_def`s

* update `pushfwd`

* change name

* add type

* formatting

* fix docstring

* depend on FunctinoChains

* Use fchain

* simplify transport_def for StdLogistic

* simplify transport_def for StdNormal

* drop redundant method

* update test_interface

* useproxy for smf

* update test_smf

* bump version

Co-authored-by: Oliver Schulz <oschulz@mpp.mpg.de>

Author: cscherrer

Project.toml

@@ -1,7 +1,7 @@
 name = "MeasureBase"
 uuid = "fa1605e6-acd5-459c-a1e6-7e635759db14"
 authors = ["Chad Scherrer <chad.scherrer@gmail.com> and contributors"]
-version = "0.14.1"
+version = "0.14.2"
 
 [deps]
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"

src/interface.jl

@@ -27,7 +27,10 @@ using Test
 
 function dynamic_basemeasure_depth(μ::M) where {M}
     if static_hasmethod(proxy, Tuple{M})
-        return dynamic_basemeasure_depth(proxy(μ))
+        π = proxy(μ)
+        if static_hasmethod(basemeasure, Tuple{typeof(π)})
+            basemeasure(π) == basemeasure(μ) && return dynamic_basemeasure_depth(π)
+        end        
     end
     β = basemeasure(μ)
     depth = 0
@@ -104,28 +107,30 @@ function test_transport(ν, μ)
 end
 
 function test_smf(μ, n = 100)
-    # Get `n` sorted uniforms in O(n) time
-    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()
-        a, b = minmax(a, b)
-        x = Finv(a)
-        y = Finv(b)
-        @test μ(Interval{:open,:closed}(x, y)) ≈ (F(y) - F(x))
+    @testset "smf($μ)" begin
+        # Get `n` sorted uniforms in O(n) time
+        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()
+            a, b = minmax(a, b)
+            x = Finv(a)
+            y = Finv(b)
+            @test μ(Interval{:open,:closed}(x, y)) ≈ (F(y) - F(x))
+        end
     end
 end
 

src/proxies.jl

@@ -26,6 +26,9 @@ macro useproxy(M)
 
         @inline $MeasureBase.massof(μ::$M) = massof(proxy(μ))
         @inline $MeasureBase.massof(μ::$M, s) = massof(proxy(μ), s)
+
+        @inline $MeasureBase.smf(μ::$M, x) = smf(proxy(μ), x)
+        @inline $MeasureBase.invsmf(μ::$M, x) = invsmf(proxy(μ), x)
         (μ::$M)(s) = proxy(μ)(s)
     end
 end