Add UnspecifiedParallel (#31)

Author: junyuan-chen

src/DiffinDiffsBase.jl

@@ -70,7 +70,10 @@ export cb,
        exact,
        Approximate,
        AbstractParallel,
+       UnspecifiedParallel,
+       unspecifiedpr,
        TrendParallel,
+       TrendOrUnspecifiedPR,
        NeverTreatedParallel,
        nevertreated,
        NotYetTreatedParallel,

src/parallels.jl

@@ -22,7 +22,7 @@ show(io::IO, ::Unconditional) =
 """
     unconditional()
 
-Alias for [`Unconditional()`](@ref).
+Alias of [`Unconditional()`](@ref).
 """
 unconditional() = Unconditional()
 
@@ -56,7 +56,7 @@ show(io::IO, ::Exact) =
 """
     exact()
 
-Alias for [`Exact()`](@ref).
+Alias of [`Exact()`](@ref).
 """
 exact() = Exact()
 
@@ -76,6 +76,49 @@ abstract type AbstractParallel{C<:ParallelCondition, S<:ParallelStrength} end
 
 @fieldequal AbstractParallel
 
+"""
+    UnspecifiedParallel{C,S} <: AbstractParallel{C,S}
+
+A parallel trends assumption (PTA) without explicitly specified
+relations across treatment groups.
+See also [`unspecifiedpr`](@ref).
+
+With this parallel type,
+operations for complying with a PTA are suppressed.
+This is useful, for example,
+when the user-provided regressors and sample restrictions
+need to be accepted without any PTA-specific alteration.
+
+# Fields
+- `c::C`: an instance of [`ParallelCondition`](@ref).
+- `s::S`: an instance of [`ParallelStrength`](@ref).
+"""
+struct UnspecifiedParallel{C,S} <: AbstractParallel{C,S}
+    c::C
+    s::S
+    function UnspecifiedParallel(c::ParallelCondition=Unconditional(),
+            s::ParallelStrength=Exact())
+        return new{typeof(c),typeof(s)}(c, s)
+    end
+end
+
+"""
+    unspecifiedpr(c::ParallelCondition=Unconditional(), s::ParallelStrength=Exact())
+
+Construct an [`UnspecifiedParallel`](@ref) with fields set by the arguments.
+This is an alias of the inner constructor of [`UnspecifiedParallel`](@ref).
+"""
+unspecifiedpr(c::ParallelCondition=Unconditional(), s::ParallelStrength=Exact()) =
+    UnspecifiedParallel(c, s)
+
+show(io::IO, pr::UnspecifiedParallel) =
+    print(IOContext(io, :compact=>true), "Unspecified{", pr.c, ",", pr.s, "}")
+
+function show(io::IO, ::MIME"text/plain", pr::UnspecifiedParallel)
+    print(io, pr.s, " among unspecified treatment groups")
+    pr.c isa Unconditional || print(io, ":\n  ", pr.c)
+end
+
 """
     TrendParallel{C,S} <: AbstractParallel{C,S}
 
@@ -84,6 +127,13 @@ assume a parallel trends assumption holds over all the relevant time periods.
 """
 abstract type TrendParallel{C,S} <: AbstractParallel{C,S} end
 
+"""
+    TrendOrUnspecifiedPR{C,S}
+
+Union type of [`TrendParallel{C,S}`](@ref) and [`UnspecifiedParallel{C,S}`](@ref).
+"""
+const TrendOrUnspecifiedPR{C,S} = Union{TrendParallel{C,S}, UnspecifiedParallel{C,S}}
+
 """
     istreated(pr::TrendParallel, x)
 
@@ -306,5 +356,6 @@ termvars(s::ParallelStrength) =
 termvars(::Exact) = Symbol[]
 termvars(pr::AbstractParallel) =
     error("StatsModels.termvars is not defined for $(typeof(pr))")
+termvars(pr::UnspecifiedParallel) = union(termvars(pr.c), termvars(pr.s))
 termvars(pr::NeverTreatedParallel) = union(termvars(pr.c), termvars(pr.s))
 termvars(pr::NotYetTreatedParallel) = union(termvars(pr.c), termvars(pr.s))

src/procedures.jl

@@ -80,8 +80,8 @@ function _checkscales(col1::AbstractArray, col2::AbstractArray, treatvars::Vecto
     end
 end
 
-function checktreatvars(::DynamicTreatment{SharpDesign}, pr::TrendParallel{Unconditional},
-        treatvars::Vector{Symbol}, data)
+function checktreatvars(::DynamicTreatment{SharpDesign},
+        pr::TrendOrUnspecifiedPR{Unconditional}, treatvars::Vector{Symbol}, data)
     # treatvars should be cohort and time variables
     col1 = getcolumn(data, treatvars[1])
     col2 = getcolumn(data, treatvars[2])
@@ -91,7 +91,9 @@ function checktreatvars(::DynamicTreatment{SharpDesign}, pr::TrendParallel{Uncon
         "nonmissing elements from columns $(treatvars[1]) and $(treatvars[2]) have different types $T1 and $T2"))
     T1 <: ValidTimeType ||
         throw(ArgumentError("column $(treatvars[1]) has unaccepted element type $(T1)"))
-    eltype(pr.e) == T1 || throw(ArgumentError("element type $(eltype(pr.e)) of control cohorts from $pr does not match element type $T1 from data; expect $T1"))
+    if pr isa TrendParallel
+        eltype(pr.e) == T1 || throw(ArgumentError("element type $(eltype(pr.e)) of control cohorts from $pr does not match element type $T1 from data; expect $T1"))
+    end
     if T1 <: RotatingTimeValue
         col1 isa RotatingTimeArray && col2 isa RotatingTimeArray ||
             throw(ArgumentError("columns $(treatvars[1]) and $(treatvars[2]) must be RotatingTimeArrays; see settime"))
@@ -147,6 +149,9 @@ function overlap!(esample::BitVector, tr_rows::BitVector, aux::BitVector, tr::Dy
     tr_rows .&= esample
 end
 
+overlap!(esample::BitVector, tr_rows::BitVector, aux::BitVector, tr::DynamicTreatment,
+    pr::UnspecifiedParallel{Unconditional}, treatname::Symbol, data) = nothing
+
 """
     checkvars!(args...)
 
@@ -171,8 +176,10 @@ function checkvars!(data, tr::AbstractTreatment, pr::AbstractParallel,
     end
     # Values of treatintterms from untreated units are ignored
     tr_rows = copy(esample)
-    istreated!(view(aux, esample), pr, view(getcolumn(data, treatname), esample))
-    tr_rows[esample] .&= view(aux, esample)
+    if !(pr isa UnspecifiedParallel)
+        istreated!(view(aux, esample), pr, view(getcolumn(data, treatname), esample))
+        tr_rows[esample] .&= view(aux, esample)
+    end
     treatintvars = termvars(treatintterms)
     for v in treatintvars
         col = getcolumn(data, v)

test/parallels.jl

@@ -13,6 +13,17 @@
     end
 end
 
+@testset "unspecifiedpr" begin
+    us = UnspecifiedParallel()
+    @test unspecifiedpr() === us
+    @test unspecifiedpr(Unconditional()) === us
+    @test unspecifiedpr(Unconditional(), Exact()) === us
+
+    @test sprint(show, us) == "Unspecified{U,P}"
+    @test sprint(show, MIME("text/plain"), us) ==
+        "Parallel among unspecified treatment groups"
+end
+
 @testset "nevertreated" begin
     nt0 = NeverTreatedParallel([0], Unconditional(), Exact())
     nt0y = NeverTreatedParallel(Date(0), Unconditional(), Exact())
@@ -223,6 +234,7 @@ end
 @testset "termvars" begin
     @test termvars(Unconditional()) == Symbol[]
     @test termvars(Exact()) == Symbol[]
+    @test termvars(unspecifiedpr()) == Symbol[]
     @test termvars(nevertreated(-1)) == Symbol[]
     @test termvars(notyettreated(5)) == Symbol[]
 

test/procedures.jl

@@ -62,9 +62,13 @@ end
     @testset "checkvars!" begin
         hrs = exampledata("hrs")
         N = size(hrs,1)
-        nt = (data=hrs, tr=dynamic(:wave, -1), pr=nevertreated(11), yterm=term(:oop_spend),
+        us = unspecifiedpr()
+        nt = (data=hrs, tr=dynamic(:wave, -1), pr=us, yterm=term(:oop_spend),
             treatname=:wave_hosp, esample=trues(N), aux=BitVector(undef, N),
             treatintterms=TermSet(), xterms=TermSet())
+        @test checkvars!(nt...) == (esample=trues(N), tr_rows=trues(N))
+
+        nt = merge(nt, (pr=nevertreated(11),))
         @test checkvars!(nt...) == (esample=trues(N), tr_rows=hrs.wave_hosp.!=11)
 
         nt = merge(nt, (pr=notyettreated(11),))
@@ -76,19 +80,31 @@ end
             (esample=.!(hrs.wave_hosp.∈(10,)).& .!(hrs.wave.∈((10,11),)),
             tr_rows=(.!(hrs.wave_hosp.∈((10,11),)).& .!(hrs.wave.∈((10,11),))))
 
+        nt = merge(nt, (pr=us, treatintterms=TermSet(term(:male)),
+            xterms=TermSet(term(:white)), esample=trues(N)))
+        @test checkvars!(nt...) == (esample=trues(N), tr_rows=trues(N))
+
         nt = merge(nt, (pr=nevertreated(11), treatintterms=TermSet(term(:male)),
             xterms=TermSet(term(:white)), esample=trues(N)))
         @test checkvars!(nt...) == (esample=trues(N), tr_rows=hrs.wave_hosp.!=11)
 
         df = DataFrame(hrs)
         allowmissing!(df, :male)
-        df.male .= ifelse.(df.wave_hosp.==11, missing, df.male)
-        nt = merge(nt, (data=df,))
+        df.male .= ifelse.(hrs.wave_hosp.==11, missing, df.male)
+
+        nt = merge(nt, (data=df, pr=us, esample=trues(N)))
+        @test checkvars!(nt...) == (esample=hrs.wave_hosp.!=11, tr_rows=hrs.wave_hosp.!=11)
+        df.male .= ifelse.(hrs.wave_hosp.==10, missing, hrs.male)
+        nt = merge(nt, (esample=trues(N),))
+        @test checkvars!(nt...) == (esample=hrs.wave_hosp.!=10, tr_rows=hrs.wave_hosp.!=10)
+
+        df.male .= ifelse.(hrs.wave_hosp.==11, missing, hrs.male)
+        nt = merge(nt, (pr=nevertreated(11), esample=trues(N)))
         @test checkvars!(nt...) == (esample=trues(N), tr_rows=hrs.wave_hosp.!=11)
-        df.male .= ifelse.(df.wave_hosp.==10, missing, df.male)
-        @test checkvars!(nt...) == (esample=df.wave_hosp.!=10, tr_rows=hrs.wave_hosp.∈((8,9),))
-        df.white = ifelse.(df.wave_hosp.==9, missing, df.white.+0.5)
-        ret = (esample=df.wave_hosp.∈((8,11),), tr_rows=hrs.wave_hosp.==8)
+        df.male .= ifelse.(hrs.wave_hosp.==10, missing, df.male)
+        @test checkvars!(nt...) == (esample=hrs.wave_hosp.!=10, tr_rows=hrs.wave_hosp.∈((8,9),))
+        df.white = ifelse.(hrs.wave_hosp.==9, missing, df.white.+0.5)
+        ret = (esample=hrs.wave_hosp.∈((8,11),), tr_rows=hrs.wave_hosp.==8)
         @test checkvars!(nt...) == ret
 
         df.wave_hosp = Date.(df.wave_hosp)