(p)vnd.infoPerCoord::Vector{Float64} replaces .inferdim::Float64

Author: dehann

src/Deprecated.jl

@@ -197,3 +197,79 @@ end
 
 @deprecate getSofttype(args...) getVariableType(args...)
 @deprecate getSofttypename(args...) getVariableTypeName(args...)
+
+
+## ================================================================================
+## Deprecate before v0.17
+##=================================================================================
+
+
+Base.propertynames(x::VariableNodeData, private::Bool=false) = private ? (:inferdim, :infoPerCoord) : (:infoPerCoord,)
+
+Base.getproperty(x::VariableNodeData,f::Symbol) = begin
+  if f == :inferdim
+    Base.depwarn("vnd.inferdim::Float64 is deprecated, use vnd.infoPerCoord::Vector{Float64} instead", :getproperty)
+    # @warn "vnd.inferdim is deprecated, use .infoPerCoord instead"
+    getfield(x, :infoPerCoord)
+  else
+    getfield(x,f)
+  end
+end
+
+function Base.setproperty!(x::VariableNodeData, f::Symbol, val::Real)
+  _val = if f == :inferdim
+    Base.depwarn("vnd.inferdim::Float64 is deprecated, use vnd.infoPerCoord::Vector{Float64} instead", :setproperty!)
+    f = :infoPerCoord
+    Float64[val;]
+  else
+    val
+  end
+  return setfield!(x, f, _val)
+end
+
+function Base.setproperty!(x::VariableNodeData, f::Symbol, val::AbstractVector{<:Real})
+  if f == :inferdim
+    Base.depwarn("vnd.inferdim::Float64 is deprecated, use vnd.infoPerCoord::Vector{Float64} instead", :setproperty!)
+    f = :infoPerCoord
+  end
+  return setfield!(x, f, val)
+end
+
+#
+
+Base.propertynames(x::PackedVariableNodeData, private::Bool=false) = private ? (:inferdim, :infoPerCoord) : (:infoPerCoord,)
+
+Base.getproperty(x::PackedVariableNodeData,f::Symbol) = begin
+  if f == :inferdim
+    Base.depwarn("pvnd.inferdim::Float64 is deprecated, use vnd.infoPerCoord::Vector{Float64} instead", :getproperty)
+    getfield(x, :infoPerCoord)
+  else
+    getfield(x,f)
+  end
+end
+
+function Base.setproperty!(x::PackedVariableNodeData, f::Symbol, val::Real)
+  _val = if f == :inferdim
+    Base.depwarn("pvnd.inferdim::Float64 is deprecated, use vnd.infoPerCoord::Vector{Float64} instead", :setproperty!)
+    f = :infoPerCoord
+    Float64[val;]
+  else
+    val
+  end
+  return setfield!(x, f, _val)
+end
+
+function Base.setproperty!(x::PackedVariableNodeData, f::Symbol, val::AbstractVector{<:Real})
+  if f == :inferdim
+    Base.depwarn("pvnd.inferdim::Float64 is deprecated, use vnd.infoPerCoord::Vector{Float64} instead", :setproperty!)
+    f = :infoPerCoord
+  end
+  return setfield!(x, f, val)
+end
+
+
+@deprecate VariableNodeData(val::Vector,bw::AbstractMatrix{<:Real},BayesNetOutVertIDs::AbstractVector{Symbol},dimIDs::AbstractVector{Int},dims::Int,eliminated::Bool,BayesNetVertID::Symbol,separator::AbstractVector{Symbol},variableType,initialized::Bool,inferdim::Real,w...;kw...) VariableNodeData(val,bw,BayesNetOutVertIDs,dimIDs,dims,eliminated,BayesNetVertID,separator,variableType,initialized,Float64[inferdim;],w...;kw...)
+
+
+
+#

src/entities/DFGVariable.jl

@@ -29,7 +29,12 @@ mutable struct VariableNodeData{T<:InferenceVariable, P}
 
     variableType::T
     initialized::Bool
-    inferdim::Float64
+    """
+    Replacing previous `inferdim::Float64`, new `.infoPerCoord::Vector{Float64}` will in 
+    future stores the amount information (per measurement dimension) captured in each 
+    coordinate dimension.
+    """
+    infoPerCoord::Vector{Float64}
     ismargin::Bool
 
     dontmargin::Bool
@@ -52,7 +57,7 @@ mutable struct VariableNodeData{T<:InferenceVariable, P}
             Symbol[], 
             T(), 
             false, 
-            0.0, 
+            Float64[0.0;], 
             false, 
             false, 
             0, 
@@ -67,55 +72,57 @@ end
 
 VariableNodeData{T}(;solveKey::Symbol=:default ) where T <: InferenceVariable = VariableNodeData{T, getPointType(T)}(solveKey=solveKey)
 
+# VariableNodeData(   val::Vector{P},
+#                     bw::Matrix{<:Real},
+#                     BayesNetOutVertIDs::AbstractVector{Symbol},
+#                     dimIDs::AbstractVector{Int},
+#                     dims::Int,
+#                     eliminated::Bool,
+#                     BayesNetVertID::Symbol,
+#                     separator::Array{Symbol,1},
+#                     variableType::T,
+#                     initialized::Bool,
+#                     inferdim::Float64,
+#                     ismargin::Bool,
+#                     dontmargin::Bool,
+#                     solveInProgress::Int=0,
+#                     solvedCount::Int=0,
+#                     solveKey::Symbol=:default,
+#                     events::Dict{Symbol,Threads.Condition}=Dict{Symbol,Threads.Condition}()
+#                 ) where {T <: InferenceVariable, P} = 
+#                     VariableNodeData{T,P}(  val,bw,BayesNetOutVertIDs,dimIDs,dims,
+#                                             eliminated,BayesNetVertID,separator,
+#                                             variableType,initialized,inferdim,ismargin,
+#                                             dontmargin, solveInProgress, solvedCount, 
+#                                             solveKey, events  )
+#
+
+
+#
+
 VariableNodeData(   val::Vector{P},
-                    bw::Matrix{<:Real},
+                    bw::AbstractMatrix{<:Real},
                     BayesNetOutVertIDs::AbstractVector{Symbol},
                     dimIDs::AbstractVector{Int},
                     dims::Int,
                     eliminated::Bool,
                     BayesNetVertID::Symbol,
-                    separator::Array{Symbol,1},
+                    separator::AbstractVector{Symbol},
                     variableType::T,
                     initialized::Bool,
-                    inferdim::Float64,
+                    ipc::AbstractVector{<:Real},
                     ismargin::Bool,
                     dontmargin::Bool,
                     solveInProgress::Int=0,
                     solvedCount::Int=0,
                     solveKey::Symbol=:default,
                     events::Dict{Symbol,Threads.Condition}=Dict{Symbol,Threads.Condition}()
-                ) where {T <: InferenceVariable, P} = VariableNodeData{T,P}( 
-                                        val,bw,BayesNetOutVertIDs,dimIDs,dims,
-                                        eliminated,BayesNetVertID,separator,
-                                        variableType,initialized,inferdim,ismargin,
-                                        dontmargin, solveInProgress, solvedCount, solveKey, events  )
-#
-
-
-#
-
-VariableNodeData(val::Vector{P},
-                 bw::Matrix{<:Real},
-                 BayesNetOutVertIDs::AbstractVector{Symbol},
-                 dimIDs::AbstractVector{Int},
-                 dims::Int,
-                 eliminated::Bool,
-                 BayesNetVertID::Symbol,
-                 separator::AbstractVector{Symbol},
-                 variableType::T,
-                 initialized::Bool,
-                 inferdim::Float64,
-                 ismargin::Bool,
-                 dontmargin::Bool,
-                 solveInProgress::Int=0,
-                 solvedCount::Int=0,
-                 solveKey::Symbol=:default
-                 ) where {T <: InferenceVariable, P} =
-                   VariableNodeData{T,P}(   val,bw,BayesNetOutVertIDs,dimIDs,dims,
+                ) where {T <: InferenceVariable, P} =
+                    VariableNodeData{T,P}(  val,bw,BayesNetOutVertIDs,dimIDs,dims,
                                             eliminated,BayesNetVertID,separator,
-                                            variableType,initialized,inferdim,ismargin,
+                                            variableType,initialized,ipc,ismargin,
                                             dontmargin, solveInProgress, solvedCount,
-                                            solveKey  )
+                                            solveKey, events  )
 #
 
 function VariableNodeData(variableType::T; solveKey::Symbol=:default) where T <: InferenceVariable
@@ -131,6 +138,8 @@ function VariableNodeData(variableType::T; solveKey::Symbol=:default) where T <:
                         false, 0, 0, solveKey  )
 end
 
+
+
 ##==============================================================================
 ## PackedVariableNodeData.jl
 ##==============================================================================
@@ -156,7 +165,7 @@ mutable struct PackedVariableNodeData
     separator::Array{Symbol,1} # Int
     variableType::String
     initialized::Bool
-    inferdim::Float64
+    infoPerCoord::Vector{Float64}
     ismargin::Bool
     dontmargin::Bool
     solveInProgress::Int
@@ -175,7 +184,7 @@ mutable struct PackedVariableNodeData
                          x10::Vector{Symbol}, # Int
                          x11::String,
                          x12::Bool,
-                         x13::Float64,
+                         x13::AbstractVector{<:Real},
                          x14::Bool,
                          x15::Bool,
                          x16::Int,
@@ -194,7 +203,7 @@ mutable struct PackedVariableNodeData
                           x10::Vector, # Int
                           x11::String,
                           x12::Bool,
-                          x13::Float64,
+                          x13::AbstractVector{<:Real},
                           x14::Bool,
                           x15::Bool,
                           x16::Int,
@@ -204,7 +213,8 @@ mutable struct PackedVariableNodeData
                                 convert(Vector{Float64},x3),x4,
                                 convert(Vector{Symbol},x5),
                                 convert(Vector{Int},x6),x7,x8,x9,
-                                convert(Vector{Symbol},x10),x11,x12,x13,x14,x15,x16, solvedCount, solveKey)
+                                convert(Vector{Symbol},x10),x11,x12,
+                                x13,x14,x15,x16, solvedCount, solveKey )
 end
 
 ##==============================================================================

src/services/CompareUtils.jl

@@ -164,7 +164,7 @@ function compare(a::VariableNodeData, b::VariableNodeData)
     a.BayesNetVertID != b.BayesNetVertID && @debug("BayesNetVertID is not equal")==nothing && return false
     a.separator != b.separator && @debug("separator is not equal")==nothing && return false
     a.initialized != b.initialized && @debug("initialized is not equal")==nothing && return false
-    abs(a.inferdim - b.inferdim) > 1e-14 && @debug("inferdim is not equal")==nothing && return false
+    !isapprox(a.infoPerCoord, b.infoPerCoord, atol=1e-13) && @debug("infoPerCoord is not equal")==nothing && return false
     a.ismargin != b.ismargin && @debug("ismargin is not equal")==nothing && return false
     a.dontmargin != b.dontmargin && @debug("dontmargin is not equal")==nothing && return false
     a.solveInProgress != b.solveInProgress && @debug("solveInProgress is not equal")==nothing && return false

src/services/Serialization.jl

@@ -243,7 +243,7 @@ function packVariableNodeData(::G, d::VariableNodeData{T}) where {G <: AbstractD
                                 d.BayesNetVertID, d.separator,
                                 typeModuleName(d.variableType),
                                 d.initialized,
-                                d.inferdim,
+                                d.infoPerCoord,
                                 d.ismargin,
                                 d.dontmargin,
                                 d.solveInProgress,
@@ -276,7 +276,7 @@ function unpackVariableNodeData(dfg::G, d::PackedVariableNodeData) where G <: Ab
     # 
     return VariableNodeData{T, getPointType(T)}(vals, BW, d.BayesNetOutVertIDs,
         d.dimIDs, d.dims, d.eliminated, d.BayesNetVertID, d.separator,
-        T(), d.initialized, d.inferdim, d.ismargin, d.dontmargin, 
+        T(), d.initialized, d.infoPerCoord, d.ismargin, d.dontmargin, 
         d.solveInProgress, d.solvedCount, d.solveKey,
         Dict{Symbol,Threads.Condition}() )
 end

test/testBlocks.jl

@@ -737,21 +737,20 @@ function  VSDTestBlock!(fg, v1)
 
     altVnd = vnd |> deepcopy
     keepVnd = getSolverData(getVariable(fg, :a), :parametric) |> deepcopy
-    altVnd.inferdim = -99.0
-    retVnd = updateVariableSolverData!(fg, :a, altVnd, false, [:inferdim;])
+    altVnd.infoPerCoord = [-99.0;]
+    retVnd = updateVariableSolverData!(fg, :a, altVnd, false, [:infoPerCoord;])
     @test retVnd == altVnd
 
     altVnd.bw = -ones(1,1)
     retVnd = updateVariableSolverData!(fg, :a, altVnd, false, [:bw;])
     @test retVnd == altVnd
 
-    altVnd.inferdim = -98.0
+    altVnd.infoPerCoord[1] = -98.0
     @test retVnd != altVnd
 
     # restore without copy
-    # @show vnd.inferdim
-    @test updateVariableSolverData!(fg, :a, keepVnd, false, [:inferdim;:bw]) == vnd
-    @test getSolverData(getVariable(fg, :a), :parametric).inferdim !=  altVnd.inferdim
+    @test updateVariableSolverData!(fg, :a, keepVnd, false, [:infoPerCoord;:bw]) == vnd
+    @test getSolverData(getVariable(fg, :a), :parametric).infoPerCoord[1] !=  altVnd.infoPerCoord[1]
     @test getSolverData(getVariable(fg, :a), :parametric).bw !=  altVnd.bw
 
     # Delete parametric from v1
@@ -1557,7 +1556,7 @@ function FileDFGTestBlock(testDFGAPI; kwargs...)
         vnd.dims = 1
         vnd.dontmargin = true
         vnd.eliminated = true
-        vnd.inferdim = 1.5
+        vnd.infoPerCoord = Float64[1.5;]
         vnd.initialized = true
         vnd.ismargin = true
         push!(vnd.separator, :sep)