test setup

Author: shashi

Project.toml

@@ -4,7 +4,6 @@ authors = ["Shashi Gowda", "Chris Rackauckas <contact@chrisrackauckas.com>"]
 version = "0.1.1"
 
 [deps]
-Amb = "c42f9944-9a8f-11e9-2851-1930a3e1c813"
 Cassette = "7057c7e9-c182-5462-911a-8362d720325c"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
@@ -14,7 +13,8 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 julia = "1"
 
 [extras]
+FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test"]
+test = ["Test", "FiniteDiff"]

src/SparsityDetection.jl

@@ -16,7 +16,7 @@ include("jacobian.jl")
 include("hessian.jl")
 include("blas.jl")
 
-Base.@deprecate sparsity!(args...) jacobian_sparsity(args...)
-Base.@deprecate hsparsity(args...) hessian_sparsity(args...)
+sparsity!(args...; kwargs...) = jacobian_sparsity(args...; kwargs...)
+hsparsity(args...; kwargs...) = hessian_sparsity(args...; kwargs...)
 
 end

src/hessian.jl

@@ -222,17 +222,19 @@ end
 
 function hessian_sparsity(f, X, args...; raw=false)
 
-    terms = zero(TermCombination)
+    terms = Ref(zero(TermCombination))
     ctx = HessianSparsityContext()
     ctx = Cassette.enabletagging(ctx, f)
     ctx = Cassette.disablehooks(ctx)
     val = nothing
     function process(result)
-        try
-            terms += metadata(result, ctx)
-        catch err
-            @warn("Could not extract hessian sparsity")
-            println(err)
+        if Cassette.hasmetadata(result, ctx)
+            try
+                terms[] += metadata(result, ctx)
+            catch err
+                @warn("Could not extract hessian sparsity")
+                println(err)
+            end
         end
         val=result
     end
@@ -242,9 +244,9 @@ function hessian_sparsity(f, X, args...; raw=false)
                      arg.value : tag(arg, ctx, one(TermCombination)), args)...)
 
     if raw
-        return ctx, val
+        return ctx, terms[], val
     end
-    _sparse(terms, length(X))
+    _sparse(terms[], length(X))
 end
 
 

src/jacobian.jl

@@ -124,6 +124,7 @@ end
 
 function jacobian_sparsity(f!, Y, X, args...;
                            sparsity=Sparsity(length(Y), length(X)),
+                           verbose = true,
                            raw = false)
 
     ctx = JacobianSparsityContext(metadata=sparsity)
@@ -137,7 +138,8 @@ function jacobian_sparsity(f!, Y, X, args...;
                  tag(Y, ctx, JacOutput()),
                  tag(X, ctx, JacInput()),
                  map(arg -> arg isa Fixed ?
-                     arg.value : tag(arg, ctx, ProvinanceSet(())), args)...)
+                     arg.value : tag(arg, ctx, ProvinanceSet(())), args)...;
+                 verbose=verbose)
 
     if raw
         return (ctx, res)

src/propagate_tags.jl

@@ -12,11 +12,17 @@ macro proptagcontext(name)
         ## of x and y. So here we recurse into promote, and then tag each
         ## element of the result with the original tag
         function Cassette.overdub(ctx::$name, f::typeof(promote), args...)
-            promoted = Cassette.recurse(ctx, f, args...)
+            promoted = Cassette.fallback(ctx, f, args...)
 
             # put the tags back on:
-            tagged_promoted = map((x,v)->tag(v, ctx, metadata(x, ctx)), args, promoted)
-            Cassette.overdub(ctx, tuple, tagged_promoted...)
+            tagged_promoted = map(args, promoted) do orig, prom
+                if Cassette.hasmetadata(orig, ctx)
+                    tag(prom, ctx, metadata(orig, ctx))
+                else
+                    prom
+                end
+            end
+            Cassette.recurse(ctx, tuple, tagged_promoted...)
         end
 
         function Cassette.overdub(ctx::$name, f, args...)

src/sparsity.jl

@@ -4,23 +4,28 @@ using Cassette
 import Cassette: tag, untag, Tagged, metadata, hasmetadata, istagged
 using SparseArrays
 using SparsityDetection
-import SparsityDetection: abstract_run, HessianSparsityContext, JacobianSparsityContext
+import SparsityDetection: abstract_run, HessianSparsityContext,
+                          JacobianSparsityContext, TermCombination, HessInput
+using Test
+
+Term(i...) = TermCombination(Set([Dict(j=>1 for j in i)]))
 
 function jactester(f, Y, X, args...)
     ctx, val = jacobian_sparsity(f, Y, X, args...; raw=true)
 end
 
-jactestmeta(args...) = jactester(args...)[1].metadata[1]
+jactestmeta(args...) = jactester(args...)[1].metadata
 jactestval(args...) = jactester(args...) |> ((ctx,val),) -> untag(val, ctx)
 jactesttag(args...) = jactester(args...) |> ((ctx,val),) -> metadata(val, ctx)
 
 function hesstester(f, X, args...)
-    ctx, val = hessian_sparsity(f, X, args...; raw=true)
+    ctx, terms, val = hessian_sparsity(f, X, args...; raw=true)
 end
 
-hesstestmeta(args...) = hesstester(args...)[1].metadata[1]
-hesstestval(args...)  = hesstester(args...) |> ((ctx,val),) -> untag(val, ctx)
-hesstesttag(args...)  = hesstester(args...) |> ((ctx,val),) -> metadata(val, ctx)
+hesstestmeta(args...) = hesstester(args...)[1].metadata
+hesstestval(args...)  = hesstester(args...) |> ((ctx,terms,val),) -> untag(val, ctx)
+hesstesttag(args...)  = hesstester(args...) |> ((ctx,terms,val),) -> metadata(val, ctx)
+hesstestterms(args...)  = hesstester(args...) |> ((ctx,terms,val),) -> terms
 
 
 Base.show(io::IO, ::Type{<:Cassette.Context}) = print(io, "ctx")

test/common.jl

@@ -1,19 +1,16 @@
-import SparsityDetection: TermCombination, HessInput
-using Test
 
-Term(i...) = TermCombination(Set([Dict(j=>1 for j in i)]))
-
-@test hesstesttag(x->x, [1,2]) == HessInput()
-@test hesstesttag(x->x[1], [1,2]) == Term(1)
+@test hesstestterms(x->x[1], [1,2]) == Term(1)
 
 # Tuple / struct
 @test hesstesttag(x->(x[1],x[2])[2], [1,2]) == Term(2)
 
+@test hesstesttag(x->promote(x[1],convert(Float64, x[2]))[2], [1,2]) == Term(2)
+
 # 1-arg linear
 @test hesstesttag(x->deg2rad(x[1]), [1,2]) == Term(1)
 
 # 1-arg nonlinear
-@test hesstesttag(x->sin(x[1]), [1,2]) == (Term(1) * Term(1))
+@test hesstestterms(x->sin(x[1]), [1,2]) == (Term(1) + Term(1) * Term(1))
 
 # 2-arg (true,true,true)
 @test hesstesttag(x->x[1]+x[2], [1,2]) == Term(1)+Term(2)