add GFND.nullhypo::Float64 (#536)

* add GFND.nullhypo::Float64,

to persist nullhypo factor data

* bump v0.9.0

* try fix test failure

* fix stackoverflow

Author: dehann

Project.toml

@@ -1,6 +1,6 @@
 name = "DistributedFactorGraphs"
 uuid = "b5cc3c7e-6572-11e9-2517-99fb8daf2f04"
-version = "0.8.1"
+version = "0.9.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/entities/DFGFactor.jl

@@ -39,23 +39,31 @@ mutable struct GenericFunctionNodeData{T<:Union{PackedInferenceType, FunctorInfe
     potentialused::Bool
     edgeIDs::Vector{Int}
     fnc::T
-    multihypo::Vector{Float64} # FIXME likely to moved when GenericWrapParam is refactored #477
+    multihypo::Vector{Float64} # TODO re-evaluate after refactoring w #477
     certainhypo::Vector{Int}
+    nullhypo::Float64
     solveInProgress::Int
+
+    # TODO deprecate all these inner constructors at end of DFG v0.9.x (was added for GFND.nullhypo::Float64 breaking change)
+    GenericFunctionNodeData{T}() where T = new{T}()
+    GenericFunctionNodeData{T}(el,po,ed,fn,mu::Vector{<:Real},ce::Vector{Int},so::Int) where T = new{T}(el,po,ed,fn,mu,ce,0.0,so)
+    GenericFunctionNodeData{T}(el,po,ed,fn,mu::Vector{<:Real},ce::Vector{Int},nu::Real,so::Int) where T = new{T}(el,po,ed,fn,mu,ce,nu,so)
 end
 
 ## Constructors
 
 GenericFunctionNodeData{T}() where T =
-    GenericFunctionNodeData{T}(false, false, Int[], T(), Float64[], Int[], 0)
-
-function GenericFunctionNodeData(eliminated,
-                                 potentialused,
-                                 edgeIDs,
-                                 fnc,
-                                 multihypo=Float64[],
-                                 certainhypo=Int[])
-    return GenericFunctionNodeData(eliminated, potentialused, edgeIDs, fnc, multihypo, certainhypo, 0)
+    GenericFunctionNodeData{T}(false, false, Int[], T(), Float64[], Int[], 0, 0)
+
+function GenericFunctionNodeData(eliminated::Bool,
+                                 potentialused::Bool,
+                                 edgeIDs::Vector{Int},
+                                 fnc::T,
+                                 multihypo::Vector{<:Real}=Float64[],
+                                 certainhypo::Vector{Int}=Int[],
+                                 nullhypo::Real=0,
+                                 solveInP::Int=0) where T
+    return GenericFunctionNodeData{T}(eliminated, potentialused, edgeIDs, fnc, multihypo, certainhypo, nullhypo, solveInP)
 end
 
 

src/services/CompareUtils.jl

@@ -217,6 +217,10 @@ function compare(a::GenericFunctionNodeData{T1},b::GenericFunctionNodeData{T2})
   TP = TP && a.potentialused == b.potentialused
   TP = TP && a.edgeIDs == b.edgeIDs
   # TP = TP && typeof(a.fnc) == typeof(b.fnc)
+  TP = TP && (a.multihypo - b.multihypo |> norm < 1e-10)
+  TP = TP && a.certainhypo == b.certainhypo
+  TP = TP && a.nullhypo == b.nullhypo
+  TP = TP && a.solveInProgress == b.solveInProgress
   return TP
 end
 

test/testBlocks.jl

@@ -1050,7 +1050,7 @@ function connectivityTestGraph(::Type{T}; VARTYPE=DFGVariable, FACTYPE=DFGFactor
         setSolvable!(dfg, :x8, 0)
         setSolvable!(dfg, :x9, 0)
 
-        gfnd = GenericFunctionNodeData(true, true, Int[], TestCCW(TestFunctorInferenceType1()), Float64[], Int[], 1)
+        gfnd = GenericFunctionNodeData(true, true, Int[], TestCCW(TestFunctorInferenceType1()), Float64[], Int[], 0, 1)
         f_tags = Set([:FACTOR])
         # f1 = DFGFactor(f1_lbl, [:a,:b], gfnd, tags = f_tags)