logJ -> logjac

Author: penelopeysm

src/abstract_varinfo.jl

@@ -204,7 +204,7 @@ Jacobian here is taken with respect to the forward (link) transform.
 
 See also: [`setlogjac!!`](@ref).
 """
-getlogjac(vi::AbstractVarInfo) = getacc(vi, Val(:LogJacobian)).logJ
+getlogjac(vi::AbstractVarInfo) = getacc(vi, Val(:LogJacobian)).logjac
 
 """
     getloglikelihood(vi::AbstractVarInfo)
@@ -239,14 +239,14 @@ See also: [`setloglikelihood!!`](@ref), [`setlogp!!`](@ref), [`getlogprior`](@re
 setlogprior!!(vi::AbstractVarInfo, logp) = setacc!!(vi, LogPriorAccumulator(logp))
 
 """
-    setlogjac!!(vi::AbstractVarInfo, logJ)
+    setlogjac!!(vi::AbstractVarInfo, logjac)
 
 Set the accumulated log-Jacobian term for any linked parameters in `vi`. The
 Jacobian here is taken with respect to the forward (link) transform.
 
 See also: [`getlogjac`](@ref), [`acclogjac!!`](@ref).
 """
-setlogjac!!(vi::AbstractVarInfo, logJ) = setacc!!(vi, LogJacobianAccumulator(logJ))
+setlogjac!!(vi::AbstractVarInfo, logjac) = setacc!!(vi, LogJacobianAccumulator(logjac))
 
 """
     setloglikelihood!!(vi::AbstractVarInfo, logp)
@@ -362,15 +362,15 @@ function acclogprior!!(vi::AbstractVarInfo, logp)
 end
 
 """
-    acclogjac!!(vi::AbstractVarInfo, logJ)
+    acclogjac!!(vi::AbstractVarInfo, logjac)
 
-Add `logJ` to the value of the log Jacobian in `vi`.
+Add `logjac` to the value of the log Jacobian in `vi`.
 
 See also: [`getlogjac`](@ref), [`setlogjac!!`](@ref).
 """
-function acclogjac!!(vi::AbstractVarInfo, logJ)
+function acclogjac!!(vi::AbstractVarInfo, logjac)
     return map_accumulator!!(
-        acc -> acc + LogJacobianAccumulator(logJ), vi, Val(:LogJacobian)
+        acc -> acc + LogJacobianAccumulator(logjac), vi, Val(:LogJacobian)
     )
 end
 

src/default_accumulators.jl

@@ -55,7 +55,7 @@ $(TYPEDFIELDS)
 """
 struct LogJacobianAccumulator{T<:Real} <: AbstractAccumulator
     "the logabsdet of the link transform Jacobian"
-    logJ::T
+    logjac::T
 end
 
 """
@@ -128,7 +128,7 @@ function Base.show(io::IO, acc::LogPriorAccumulator)
     return print(io, "LogPriorAccumulator($(repr(acc.logp)))")
 end
 function Base.show(io::IO, acc::LogJacobianAccumulator)
-    return print(io, "LogJacobianAccumulator($(repr(acc.logJ)))")
+    return print(io, "LogJacobianAccumulator($(repr(acc.logjac)))")
 end
 function Base.show(io::IO, acc::LogLikelihoodAccumulator)
     return print(io, "LogLikelihoodAccumulator($(repr(acc.logp)))")
@@ -144,7 +144,7 @@ end
 # implementation for structs.
 Base.:(==)(acc1::LogPriorAccumulator, acc2::LogPriorAccumulator) = acc1.logp == acc2.logp
 function Base.:(==)(acc1::LogJacobianAccumulator, acc2::LogJacobianAccumulator)
-    return acc1.logJ == acc2.logJ
+    return acc1.logjac == acc2.logjac
 end
 function Base.:(==)(acc1::LogLikelihoodAccumulator, acc2::LogLikelihoodAccumulator)
     return acc1.logp == acc2.logp
@@ -157,7 +157,7 @@ function Base.isequal(acc1::LogPriorAccumulator, acc2::LogPriorAccumulator)
     return isequal(acc1.logp, acc2.logp)
 end
 function Base.isequal(acc1::LogJacobianAccumulator, acc2::LogJacobianAccumulator)
-    return isequal(acc1.logJ, acc2.logJ)
+    return isequal(acc1.logjac, acc2.logjac)
 end
 function Base.isequal(acc1::LogLikelihoodAccumulator, acc2::LogLikelihoodAccumulator)
     return isequal(acc1.logp, acc2.logp)
@@ -168,7 +168,7 @@ end
 
 Base.hash(acc::LogPriorAccumulator, h::UInt) = hash((LogPriorAccumulator, acc.logp), h)
 function Base.hash(acc::LogJacobianAccumulator, h::UInt)
-    return hash((LogJacobianAccumulator, acc.logJ), h)
+    return hash((LogJacobianAccumulator, acc.logjac), h)
 end
 function Base.hash(acc::LogLikelihoodAccumulator, h::UInt)
     return hash((LogLikelihoodAccumulator, acc.logp), h)
@@ -191,7 +191,7 @@ function combine(acc::LogPriorAccumulator, acc2::LogPriorAccumulator)
     return LogPriorAccumulator(acc.logp + acc2.logp)
 end
 function combine(acc::LogJacobianAccumulator, acc2::LogJacobianAccumulator)
-    return LogJacobianAccumulator(acc.logJ + acc2.logJ)
+    return LogJacobianAccumulator(acc.logjac + acc2.logjac)
 end
 function combine(acc::LogLikelihoodAccumulator, acc2::LogLikelihoodAccumulator)
     return LogLikelihoodAccumulator(acc.logp + acc2.logp)
@@ -208,7 +208,7 @@ function Base.:+(acc1::LogPriorAccumulator, acc2::LogPriorAccumulator)
     return LogPriorAccumulator(acc1.logp + acc2.logp)
 end
 function Base.:+(acc1::LogJacobianAccumulator, acc2::LogJacobianAccumulator)
-    return LogJacobianAccumulator(acc1.logJ + acc2.logJ)
+    return LogJacobianAccumulator(acc1.logjac + acc2.logjac)
 end
 function Base.:+(acc1::LogLikelihoodAccumulator, acc2::LogLikelihoodAccumulator)
     return LogLikelihoodAccumulator(acc1.logp + acc2.logp)
@@ -218,7 +218,7 @@ function increment(acc::VariableOrderAccumulator)
 end
 
 Base.zero(acc::LogPriorAccumulator) = LogPriorAccumulator(zero(acc.logp))
-Base.zero(acc::LogJacobianAccumulator) = LogJacobianAccumulator(zero(acc.logJ))
+Base.zero(acc::LogJacobianAccumulator) = LogJacobianAccumulator(zero(acc.logjac))
 Base.zero(acc::LogLikelihoodAccumulator) = LogLikelihoodAccumulator(zero(acc.logp))
 
 function accumulate_assume!!(acc::LogPriorAccumulator, val, logjac, vn, right)
@@ -251,7 +251,7 @@ end
 function Base.convert(
     ::Type{LogJacobianAccumulator{T}}, acc::LogJacobianAccumulator
 ) where {T}
-    return LogJacobianAccumulator(convert(T, acc.logJ))
+    return LogJacobianAccumulator(convert(T, acc.logjac))
 end
 function Base.convert(
     ::Type{LogLikelihoodAccumulator{T}}, acc::LogLikelihoodAccumulator
@@ -277,7 +277,7 @@ function convert_eltype(::Type{T}, acc::LogPriorAccumulator) where {T}
     return LogPriorAccumulator(convert(T, acc.logp))
 end
 function convert_eltype(::Type{T}, acc::LogJacobianAccumulator) where {T}
-    return LogJacobianAccumulator(convert(T, acc.logJ))
+    return LogJacobianAccumulator(convert(T, acc.logjac))
 end
 function convert_eltype(::Type{T}, acc::LogLikelihoodAccumulator) where {T}
     return LogLikelihoodAccumulator(convert(T, acc.logp))