Merge pull request #739 from JuliaRobotics/21Q1/feat/inflation

add GFND.inflation, and cleanup

Author: dehann

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2017-2020 NavAbility
+Copyright (c) 2017-2021 NavAbility
 
 NOTICE: this license will be relaxed to be much more permissive soon.
 
@@ -18,13 +18,10 @@ Other general use or modification of the software beyond that of
 webservices or clouds (private or public) is permitted 
 according to terms defined by Apache 2.0 or other library specifc licenses.
 
-   Copyright 2017-2020 NavAbility
+   Copyright 2017-2021 NavAbility
 
-   Licensed under the Apache License, Version 2.0 (the "License");
+   Licensed under a Market Limited version of the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,

Project.toml

@@ -1,6 +1,6 @@
 name = "DistributedFactorGraphs"
 uuid = "b5cc3c7e-6572-11e9-2517-99fb8daf2f04"
-version = "0.11.3"
+version = "0.12.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -35,7 +35,7 @@ Reexport = "0.2, 0.3, 0.4, 0.5, 1"
 Requires = "0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 1"
 TimeZones = "1.3.1"
 Unmarshal = "0.4"
-julia = "1.2"
+julia = "1.4"
 
 [extras]
 GraphPlot = "a2cc645c-3eea-5389-862e-a155d0052231"

src/entities/DFGFactor.jl

@@ -4,9 +4,10 @@
 
 # TODO consider changing this to AbstractFactor
 abstract type AbstractFactor end
-const FunctorInferenceType = AbstractFactor
 abstract type AbstractPackedFactor end
-const PackedInferenceType = AbstractPackedFactor
+
+const FunctorInferenceType = AbstractFactor       # will eventually deprecate
+const PackedInferenceType = AbstractPackedFactor  # will eventually deprecate
 
 abstract type AbstractPrior <: AbstractFactor end
 abstract type AbstractRelative <: AbstractFactor end
@@ -15,8 +16,8 @@ abstract type AbstractRelativeMinimize <: AbstractRelative end
 
 # NOTE DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
 # DF, IIF.CommonConvWrapper <: FactorOperationalMemory #
-# TODO resolve whether `<: Function` is really needed here
-abstract type FactorOperationalMemory <: Function end
+# NOTE was `<: Function` as unnecessary
+abstract type FactorOperationalMemory end   # <: Function
 # TODO to be removed from DFG,
 # we can add to IIF or have IIF.CommonConvWrapper <: FactorOperationalMemory directly
 # abstract type ConvolutionObject <: FactorOperationalMemory end
@@ -46,36 +47,40 @@ mutable struct GenericFunctionNodeData{T<:Union{PackedInferenceType, FunctorInfe
     certainhypo::Vector{Int}
     nullhypo::Float64
     solveInProgress::Int
-
+    inflation::Float64
+    # inner constructor needed for dual use
+    # GenericFunctionNodeData{T}(x1::Bool,x2::Bool,x3,x4::T,args...) where T = new{T}(x1,x2,x3,x4,args...)
     # TODO deprecate all these inner constructors at end of DFG v0.9.x (was added for GFND.nullhypo::Float64 breaking change)
-    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)
+    # 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,infl::Real) where T = new{T}(el,po,ed,fn,mu,ce,nu,so,infl)
 end
 
 ## Constructors
 
 GenericFunctionNodeData{T}() where T =
-    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)
+    GenericFunctionNodeData(false, false, Int[], T())
+
+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,
+                                    inflation::Real=0.0 ) where T
+    return GenericFunctionNodeData{T}(eliminated, potentialused, edgeIDs, fnc, multihypo, certainhypo, nullhypo, solveInP, inflation)
 end
 
 
 ##------------------------------------------------------------------------------
 ## PackedFunctionNodeData and FunctionNodeData
 
-const PackedFunctionNodeData{T} = GenericFunctionNodeData{T} where T <: PackedInferenceType
+const PackedFunctionNodeData{T} = GenericFunctionNodeData{T} where T <: AbstractPackedFactor
 PackedFunctionNodeData(args...) = PackedFunctionNodeData{typeof(args[4])}(args...)
 
-const FunctionNodeData{T} = GenericFunctionNodeData{T} where T <: Union{FunctorInferenceType, FactorOperationalMemory}
+const FunctionNodeData{T} = GenericFunctionNodeData{T} where T <: Union{AbstractFactor, FactorOperationalMemory}
 FunctionNodeData(args...) = FunctionNodeData{typeof(args[4])}(args...)
 
 

src/services/CompareUtils.jl

@@ -130,7 +130,7 @@ function compareAll(Al::T,
   return true
 end
 
-function compareAll(Al::T, Bl::T; show::Bool=true, skip::Vector{Symbol}=Symbol[])::Bool where T
+function compareAll(Al::T, Bl::T; show::Bool=true, skip::Vector{Symbol}=Symbol[]) where T
   @debug "Comparing types $T:"
   # @debug "  Al = $Al"
   # @debug "  Bl = $Bl"

src/services/DFGFactor.jl

@@ -18,9 +18,7 @@ Return reference to the user factor in `<:AbstractDFG` identified by `::Symbol`.
 """
 getFactorFunction(fcd::GenericFunctionNodeData) = fcd.fnc.usrfnc!
 getFactorFunction(fc::DFGFactor) = getFactorFunction(getSolverData(fc))
-function getFactorFunction(dfg::G, fsym::Symbol) where G <: AbstractDFG
-  getFactorFunction(getFactor(dfg, fsym))
-end
+getFactorFunction(dfg::AbstractDFG, fsym::Symbol) = getFactorFunction(getFactor(dfg, fsym))
 
 """
     $SIGNATURES
@@ -32,9 +30,8 @@ Notes
 """
 getFactorType(data::GenericFunctionNodeData) = data.fnc.usrfnc!
 getFactorType(fct::DFGFactor) = getFactorType(getSolverData(fct))
-function getFactorType(dfg::G, lbl::Symbol) where G <: AbstractDFG
-  getFactorType(getFactor(dfg, lbl))
-end
+getFactorType(dfg::AbstractDFG, lbl::Symbol) = getFactorType(getFactor(dfg, lbl))
+
 
 ##==============================================================================
 ## Factors
@@ -68,14 +65,8 @@ end
 # getTimestamp
 
 setTimestamp(f::AbstractDFGFactor, ts::DateTime, timezone=localzone()) = setTimestamp(f, ZonedDateTime(ts,  timezone))
-
-function setTimestamp(f::DFGFactor, ts::ZonedDateTime)
-    return DFGFactor(f.label, ts, f.nstime, f.tags, f.solverData, f.solvable, getfield(f,:_variableOrderSymbols))
-end
-
-function setTimestamp(f::DFGFactorSummary, ts::ZonedDateTime)
-    return DFGFactorSummary(f.label, ts, f.tags, f._variableOrderSymbols)
-end
+setTimestamp(f::DFGFactor, ts::ZonedDateTime) = DFGFactor(f.label, ts, f.nstime, f.tags, f.solverData, f.solvable, getfield(f,:_variableOrderSymbols))
+setTimestamp(f::DFGFactorSummary, ts::ZonedDateTime) = DFGFactorSummary(f.label, ts, f.tags, f._variableOrderSymbols)
 
 
 ##------------------------------------------------------------------------------
@@ -105,7 +96,7 @@ $SIGNATURES
 Get the variable ordering for this factor.
 Should be equivalent to getNeighbors unless something was deleted in the graph.
 """
-getVariableOrder(fct::DFGFactor)::Vector{Symbol} = fct._variableOrderSymbols
+getVariableOrder(fct::DFGFactor) = fct._variableOrderSymbols::Vector{Symbol}
 getVariableOrder(dfg::AbstractDFG, fct::Symbol) = getVariableOrder(getFactor(dfg, fct))
 
 ##------------------------------------------------------------------------------

src/services/Serialization.jl

@@ -307,6 +307,7 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
     @debug "DECODING factor type = '$(datatype)' for factor '$label'"
     packtype = getTypeFromSerializationModule(dfg, Symbol("Packed"*datatype))
 
+    # FIXME type instability from nothing to T
     packed = nothing
     fullFactorData = nothing
     try

test/testBlocks.jl

@@ -57,7 +57,7 @@ function Base.convert(::Type{TestAbstractPrior}, d::PackedTestAbstractPrior)
     TestAbstractPrior()
 end
 
-struct TestCCW{T} <: FactorOperationalMemory where {T<:FunctorInferenceType}
+struct TestCCW{T <: AbstractFactor} <: FactorOperationalMemory
     usrfnc!::T
 end
 
@@ -69,7 +69,7 @@ DFG.getFactorOperationalMemoryType(par::NoSolverParams) = TestCCW
 DFG.rebuildFactorMetadata!(dfg::AbstractDFG{NoSolverParams}, fac::DFGFactor) = fac
 
 function Base.convert(::Type{DFG.FunctionNodeData{TestCCW{F}}},
-                     d::DFG.PackedFunctionNodeData{<:PackedInferenceType}) where F<:FunctorInferenceType
+                     d::DFG.PackedFunctionNodeData{<:AbstractPackedFactor}) where {F <: DFG.AbstractFactor}
 
     return DFG.FunctionNodeData(d.eliminated,
                                 d.potentialused,
@@ -78,19 +78,20 @@ function Base.convert(::Type{DFG.FunctionNodeData{TestCCW{F}}},
                                 d.multihypo,
                                 d.certainhypo,
                                 d.nullhypo,
-                                d.solveInProgress)
+                                d.solveInProgress,
+                                d.inflation)
 end
 
-function Base.convert(::Type{DFG.PackedFunctionNodeData{P}}, d::DFG.FunctionNodeData{<:FactorOperationalMemory}) where P <: PackedInferenceType
-  # mhstr = packmultihypo(d.fnc)  # this is where certainhypo error occurs
+function Base.convert(::Type{DFG.PackedFunctionNodeData{P}}, d::DFG.FunctionNodeData{<:FactorOperationalMemory}) where P <: AbstractPackedFactor
   return DFG.PackedFunctionNodeData(d.eliminated,
                                     d.potentialused,
                                     d.edgeIDs,
                                     convert(P, d.fnc.usrfnc!),
                                     d.multihypo,
                                     d.certainhypo,
                                     d.nullhypo,
-                                    d.solveInProgress)
+                                    d.solveInProgress,
+                                    d.inflation)
 end