From 5c8ee850be661bbb3043d1682052f03c9edb51d3 Mon Sep 17 00:00:00 2001 From: Johannes Terblanche Date: Thu, 26 Jun 2025 09:41:31 +0200 Subject: [PATCH 1/3] Spllitting out IIFTypes and updates for updateState -> copytoState --- IncrementalInferenceTypes/Project.toml | 26 ++++++ .../src/IncrementalInferenceTypes.jl | 69 +++++++++++++++ .../src/factors/Circular.jl | 30 +++++++ .../src/factors/DefaultPrior.jl | 29 +++++++ .../src/factors/LinearRelative.jl | 33 +++++++ .../entities/SerializingDistributions.jl | 47 ++++++++++ .../services/SerializingDistributions.jl | 30 +++++++ .../src/solverparams}/SolverParams.jl | 11 ++- .../src/variables/DefaultVariableTypes.jl | 58 +++++++++++++ Project.toml | 1 + src/Factors/Circular.jl | 87 ++----------------- src/Factors/DefaultPrior.jl | 38 +------- src/Factors/LinearRelative.jl | 55 ------------ src/IncrementalInference.jl | 5 +- .../entities/SerializingDistributions.jl | 47 ---------- .../services/SerializationMKD.jl | 4 +- .../services/SerializingDistributions.jl | 31 ------- src/Variables/Circular.jl | 14 --- src/Variables/DefaultVariables.jl | 52 +---------- src/services/GraphInit.jl | 8 +- src/services/SubGraphFunctions.jl | 15 ++-- 21 files changed, 360 insertions(+), 330 deletions(-) create mode 100644 IncrementalInferenceTypes/Project.toml create mode 100644 IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl create mode 100644 IncrementalInferenceTypes/src/factors/Circular.jl create mode 100644 IncrementalInferenceTypes/src/factors/DefaultPrior.jl create mode 100644 IncrementalInferenceTypes/src/factors/LinearRelative.jl create mode 100644 IncrementalInferenceTypes/src/serialization/entities/SerializingDistributions.jl create mode 100644 IncrementalInferenceTypes/src/serialization/services/SerializingDistributions.jl rename {src/entities => IncrementalInferenceTypes/src/solverparams}/SolverParams.jl (91%) create mode 100644 IncrementalInferenceTypes/src/variables/DefaultVariableTypes.jl delete mode 100644 src/Variables/Circular.jl diff --git a/IncrementalInferenceTypes/Project.toml b/IncrementalInferenceTypes/Project.toml new file mode 100644 index 00000000..025be32b --- /dev/null +++ b/IncrementalInferenceTypes/Project.toml @@ -0,0 +1,26 @@ +name = "IncrementalInferenceTypes" +uuid = "9808408f-4dbc-47e4-913c-6068b950e289" +authors = ["Johannes Terblanche "] +version = "0.1.0" + +[deps] +Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" +Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b" +DistributedFactorGraphs = "b5cc3c7e-6572-11e9-2517-99fb8daf2f04" +Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +Manifolds = "1cead3c2-87b3-11e9-0ccd-23c62b72b94e" +RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" +StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" +StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" + +[compat] +Dates = "1.11.0" +Distributed = "1.11.0" +DistributedFactorGraphs = "0.27.0" +Distributions = "0.25.120" +DocStringExtensions = "0.9.5" +Manifolds = "=0.10.16" +RecursiveArrayTools = "3.33.0" +StaticArrays = "1.9.13" +StructTypes = "1.11.0" diff --git a/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl b/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl new file mode 100644 index 00000000..143d12ea --- /dev/null +++ b/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl @@ -0,0 +1,69 @@ +module IncrementalInferenceTypes + +using DistributedFactorGraphs +using DocStringExtensions +using Manifolds +using Distributions +using StaticArrays +import StructTypes + +using Dates: now +using Distributed: nprocs +# using RecursiveArrayTools + +# export variable types +export + Position, + Position1, + Position2, + Position3, + Position4, + ContinuousScalar, + ContinuousEuclid, + Ciruclar + +#export factor types +export + Prior, + PackedPrior, + LinearRelative, + PackedLinearRelative, + CircularCircular, + PriorCircular, + PackedCircularCircular, + PackedPriorCircular + +# export packed distributions +export + PackedCategorical, + PackedUniform, + PackedNormal, + PackedZeroMeanDiagNormal, + PackedZeroMeanFullNormal, + PackedDiagNormal, + PackedFullNormal, + PackedRayleigh + +export + SolverParams + +const IIFTypes = IncrementalInferenceTypes +export IIFTypes + +# Variable Definitions +include("variables/DefaultVariableTypes.jl") + +# Factor Definitions +include("factors/DefaultPrior.jl") +#FIXME maybe upgrade linear relative to this +include("factors/LinearRelative.jl") +include("factors/Circular.jl") + +# Distribution Serialization +include("serialization/entities/SerializingDistributions.jl") +include("serialization/services/SerializingDistributions.jl") + +# solver params +include("solverparams/SolverParams.jl") + +end # module IncrementalInferenceTypes diff --git a/IncrementalInferenceTypes/src/factors/Circular.jl b/IncrementalInferenceTypes/src/factors/Circular.jl new file mode 100644 index 00000000..2d06f7d9 --- /dev/null +++ b/IncrementalInferenceTypes/src/factors/Circular.jl @@ -0,0 +1,30 @@ + +""" +$(TYPEDEF) + +Factor between two Sphere1 variables. + +Related + +[`Sphere1`](@ref), [`PriorSphere1`](@ref), [`Polar`](@ref), [`ContinuousEuclid`](@ref) +""" +DFG.@defFactorType CircularCircular AbstractManifoldMinimize Manifolds.RealCircleGroup() + + +""" +$(TYPEDEF) + +Introduce direct observations on all dimensions of a Circular variable: + +Example: +-------- +```julia +PriorCircular( MvNormal([10; 10; pi/6.0], diagm([0.1;0.1;0.05].^2)) ) +``` + +Related + +[`Circular`](@ref), [`Prior`](@ref), [`PartialPrior`](@ref) +""" +DFG.@defFactorType PriorCircular AbstractPrior Manifolds.RealCircleGroup() + diff --git a/IncrementalInferenceTypes/src/factors/DefaultPrior.jl b/IncrementalInferenceTypes/src/factors/DefaultPrior.jl new file mode 100644 index 00000000..623ce03e --- /dev/null +++ b/IncrementalInferenceTypes/src/factors/DefaultPrior.jl @@ -0,0 +1,29 @@ +""" +$(TYPEDEF) + +Default prior on all dimensions of a variable node in the factor graph. `Prior` is +not recommended when non-Euclidean dimensions are used in variables. +""" +struct Prior{T} <: AbstractPrior + Z::T +end +DFG.getManifold(pr::Prior) = TranslationGroup(getDimension(pr.Z)) + +""" +$(TYPEDEF) + +Serialization type for Prior. +""" +Base.@kwdef mutable struct PackedPrior <: AbstractPackedFactor + Z::PackedSamplableBelief +end + +function DFG.pack(d::Prior) + return PackedPrior(DFG.packDistribution(d.Z)) +end + +function DFG.unpack(d::PackedPrior) + return Prior(DFG.unpackDistribution(d.Z)) +end + +# diff --git a/IncrementalInferenceTypes/src/factors/LinearRelative.jl b/IncrementalInferenceTypes/src/factors/LinearRelative.jl new file mode 100644 index 00000000..db37b13e --- /dev/null +++ b/IncrementalInferenceTypes/src/factors/LinearRelative.jl @@ -0,0 +1,33 @@ + +""" +$(TYPEDEF) + +Default linear offset between two scalar variables. + +```math +X_2 = X_1 + η_Z +``` +""" +struct LinearRelative{T} <: AbstractManifoldMinimize + Z::T +end + +DFG.getManifold(obs::LinearRelative) = TranslationGroup(getDimension(obs.Z)) + +""" +$(TYPEDEF) +Serialization type for `LinearRelative` binary factor. +""" +Base.@kwdef mutable struct PackedLinearRelative <: AbstractPackedFactor + Z::PackedSamplableBelief +end + +function DFG.pack(d::LinearRelative) + return PackedLinearRelative(DFG.packDistribution(d.Z)) +end + +function DFG.unpack(d::PackedLinearRelative) + return LinearRelative(DFG.unpackDistribution(d.Z)) +end + +# diff --git a/IncrementalInferenceTypes/src/serialization/entities/SerializingDistributions.jl b/IncrementalInferenceTypes/src/serialization/entities/SerializingDistributions.jl new file mode 100644 index 00000000..cc3316f9 --- /dev/null +++ b/IncrementalInferenceTypes/src/serialization/entities/SerializingDistributions.jl @@ -0,0 +1,47 @@ + +Base.@kwdef struct PackedCategorical <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedCategorical" + p::Vector{Float64} = [1.0;] +end + +Base.@kwdef mutable struct PackedUniform <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedUniform" + a::Float64 = 0.0 + b::Float64 = 1.0 + PackedSamplableTypeJSON::String = "IncrementalInferenceTypes.PackedUniform" +end + +Base.@kwdef struct PackedNormal <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedNormal" + mu::Float64 = 0.0 + sigma::Float64 = 1.0 +end + +Base.@kwdef struct PackedZeroMeanDiagNormal <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedZeroMeanDiagNormal" + diag::Vector{Float64} = ones(1) +end + +Base.@kwdef struct PackedZeroMeanFullNormal <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedZeroMeanFullNormal" + cov::Vector{Float64} = ones(1) +end + +Base.@kwdef mutable struct PackedDiagNormal <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedDiagNormal" + mu::Vector{Float64} = zeros(1) + diag::Vector{Float64} = ones(1) +end + +Base.@kwdef struct PackedFullNormal <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedFullNormal" + mu::Vector{Float64} = zeros(1) + cov::Vector{Float64} = ones(1) +end + +Base.@kwdef struct PackedRayleigh <: PackedSamplableBelief + _type::String = "IncrementalInferenceTypes.PackedRayleigh" + sigma::Float64 = 1.0 +end + +# diff --git a/IncrementalInferenceTypes/src/serialization/services/SerializingDistributions.jl b/IncrementalInferenceTypes/src/serialization/services/SerializingDistributions.jl new file mode 100644 index 00000000..9e1929c6 --- /dev/null +++ b/IncrementalInferenceTypes/src/serialization/services/SerializingDistributions.jl @@ -0,0 +1,30 @@ + +## Distributions to JSON/Packed types + +DFG.packDistribution(dtr::Categorical) = PackedCategorical(; p = dtr.p) +DFG.packDistribution(dtr::Uniform) = PackedUniform(; a = dtr.a, b = dtr.b) +DFG.packDistribution(dtr::Normal) = PackedNormal(; mu = dtr.μ, sigma = dtr.σ) +DFG.packDistribution(dtr::ZeroMeanDiagNormal) = PackedZeroMeanDiagNormal(; diag = dtr.Σ.diag) +DFG.packDistribution(dtr::ZeroMeanFullNormal) = PackedZeroMeanFullNormal(; cov = dtr.Σ.mat[:]) +DFG.packDistribution(dtr::DiagNormal) = PackedDiagNormal(; mu = dtr.μ, diag = dtr.Σ.diag) +DFG.packDistribution(dtr::FullNormal) = PackedFullNormal(; mu = dtr.μ, cov = dtr.Σ.mat[:]) +DFG.packDistribution(dtr::Rayleigh) = PackedRayleigh(; sigma = dtr.σ) + +## Unpack JSON/Packed to Distribution types + +DFG.unpackDistribution(dtr::PackedCategorical) = Categorical(dtr.p ./ sum(dtr.p)) +DFG.unpackDistribution(dtr::PackedUniform) = Uniform(dtr.a, dtr.b) +DFG.unpackDistribution(dtr::PackedNormal) = Normal(dtr.mu, dtr.sigma) +function DFG.unpackDistribution(dtr::PackedZeroMeanDiagNormal) + return MvNormal(LinearAlgebra.Diagonal(map(abs2, sqrt.(dtr.diag)))) +end # sqrt.(dtr.diag) +function DFG.unpackDistribution(dtr::PackedZeroMeanFullNormal) + d = round(Int, sqrt(size(dtr.cov)[1])) + return MvNormal(reshape(dtr.cov, d, d)) +end +DFG.unpackDistribution(dtr::PackedDiagNormal) = MvNormal(dtr.mu, sqrt.(dtr.diag)) +function DFG.unpackDistribution(dtr::PackedFullNormal) + return MvNormal(dtr.mu, reshape(dtr.cov, length(dtr.mu), :)) +end +DFG.unpackDistribution(dtr::PackedRayleigh) = Rayleigh(dtr.sigma) + diff --git a/src/entities/SolverParams.jl b/IncrementalInferenceTypes/src/solverparams/SolverParams.jl similarity index 91% rename from src/entities/SolverParams.jl rename to IncrementalInferenceTypes/src/solverparams/SolverParams.jl index 6ae00e4f..6ac99fe4 100644 --- a/src/entities/SolverParams.jl +++ b/IncrementalInferenceTypes/src/solverparams/SolverParams.jl @@ -11,7 +11,7 @@ Dev Notes """ Base.@kwdef mutable struct SolverParams <: DFG.AbstractParams dimID::Int = 0 - reference::NothingUnion{Dict{Symbol, Tuple{Symbol, Vector{Float64}}}} = nothing + reference::Union{Nothing, Dict{Symbol, Tuple{Symbol, Vector{Float64}}}} = nothing stateless::Bool = false """ Quasi fixed length """ qfl::Int = (2^(Sys.WORD_SIZE - 1) - 1) @@ -45,7 +45,7 @@ Base.@kwdef mutable struct SolverParams <: DFG.AbstractParams """ should Distributed.jl tree solve compute features be used """ multiproc::Bool = 1 < nprocs() """ "/tmp/caesar/logs/$(now())" # unique temporary file storage location for a solve """ - logpath::String = joinpath(tempdir(),"caesar","logs","$(now(UTC))") + logpath::String = joinpath(tempdir(),"caesar","logs","$(now(DFG.UTC))") """ default to graph-based initialization of variables """ graphinit::Bool = true """ init variables on the tree """ @@ -76,6 +76,9 @@ end StructTypes.omitempties(::Type{SolverParams}) = (:reference,) - -convert(::Type{SolverParams}, ::NoSolverParams) = SolverParams() # +Base.convert(::Type{SolverParams}, ::NoSolverParams) = begin + @warn "FIXME Why converting NoSolverParams to SolverParams?" + SolverParams() +end + diff --git a/IncrementalInferenceTypes/src/variables/DefaultVariableTypes.jl b/IncrementalInferenceTypes/src/variables/DefaultVariableTypes.jl new file mode 100644 index 00000000..7d9dad09 --- /dev/null +++ b/IncrementalInferenceTypes/src/variables/DefaultVariableTypes.jl @@ -0,0 +1,58 @@ +#FIXME This is discouraged in the julia style guide, rather standardize to instance or type +const InstanceType{T} = Union{Type{<:T}, <:T} + +## Euclid 1 + +""" + $TYPEDEF + +Continuous Euclidean variable of dimension `N` representing a Position in cartesian space. +""" +struct Position{N} <: InferenceVariable end + +Position(N::Int) = Position{N}() + +# not sure if these overloads are necessary since DFG 775? +DFG.getManifold(::InstanceType{Position{N}}) where {N} = TranslationGroup(N) +function DFG.getDimension(val::InstanceType{Position{N}}) where {N} + return manifold_dimension(getManifold(val)) +end +DFG.getPointType(::Type{Position{N}}) where {N} = SVector{N, Float64} +DFG.getPointIdentity(M_::Type{Position{N}}) where {N} = @SVector(zeros(N)) # identity_element(getManifold(M_), zeros(N)) + + +# + +""" +$(TYPEDEF) + +Most basic continuous scalar variable in a `::DFG.AbstractDFG` object. + +Alias of `Position{1}` +""" +const ContinuousScalar = Position{1} +const ContinuousEuclid{N} = Position{N} + +const Position1 = Position{1} +const Position2 = Position{2} +const Position3 = Position{3} +const Position4 = Position{4} + +#TODO maybe just use @defVariable for all Position types? +# @defVariable Position1 TranslationGroup(1) @SVector(zeros(1)) +# @defVariable Position2 TranslationGroup(2) @SVector(zeros(2)) +# @defVariable Position3 TranslationGroup(3) @SVector(zeros(3)) +# @defVariable Position4 TranslationGroup(4) @SVector(zeros(4)) + +## Circular + +""" +$(TYPEDEF) + +Circular is a `Manifolds.Circle{ℝ}` mechanization of one rotation, with `theta in [-pi,pi)`. +""" +@defVariable Circular RealCircleGroup() [0.0;] +#TODO This is an example of what we want working, possible issue upstream in Manifolds.jl +# @defVariable Circular RealCircleGroup() Scalar(0.0) + +# diff --git a/Project.toml b/Project.toml index 8a133ac7..b1a7ea43 100644 --- a/Project.toml +++ b/Project.toml @@ -21,6 +21,7 @@ FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" FunctionalStateMachine = "3e9e306e-7e3c-11e9-12d2-8f8f67a2f951" +IncrementalInferenceTypes = "9808408f-4dbc-47e4-913c-6068b950e289" JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" KernelDensityEstimate = "2472808a-b354-52ea-a80e-1658a3c6056d" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" diff --git a/src/Factors/Circular.jl b/src/Factors/Circular.jl index 85926ad4..b65b26a4 100644 --- a/src/Factors/Circular.jl +++ b/src/Factors/Circular.jl @@ -1,28 +1,8 @@ - -export CircularCircular, PriorCircular, PackedCircularCircular, PackedPriorCircular - -""" -$(TYPEDEF) - -Factor between two Sphere1 variables. - -Related - -[`Sphere1`](@ref), [`PriorSphere1`](@ref), [`Polar`](@ref), [`ContinuousEuclid`](@ref) -""" -mutable struct CircularCircular{T <: SamplableBelief} <: AbstractManifoldMinimize - Z::T - # Sphere1Sphere1(z::T=Normal()) where {T <: SamplableBelief} = new{T}(z) -end - -const Sphere1Sphere1 = CircularCircular - -CircularCircular(::UniformScaling) = CircularCircular(Normal()) - -DFG.getManifold(::CircularCircular) = RealCircleGroup() +# --------------------------------------------- +# CircularCircular +# --------------------------------------------- function (cf::CalcFactor{<:CircularCircular})(X, p, q) - # M = getManifold(cf) return distanceTangent2Point(M, X, p, q) end @@ -36,30 +16,13 @@ function Base.convert(::Type{<:MB.AbstractManifold}, ::InstanceType{CircularCirc return Manifolds.RealCircleGroup() end -""" -$(TYPEDEF) - -Introduce direct observations on all dimensions of a Circular variable: - -Example: --------- -```julia -PriorCircular( MvNormal([10; 10; pi/6.0], diagm([0.1;0.1;0.05].^2)) ) -``` - -Related +IIFTypes.CircularCircular(::UniformScaling) = CircularCircular(Normal()) -[`Circular`](@ref), [`Prior`](@ref), [`PartialPrior`](@ref) -""" -DFG.@defFactorType PriorCircular AbstractPrior Manifolds.RealCircleGroup() +# --------------------------------------------- +# PriorCircular +# --------------------------------------------- -# mutable struct PriorCircular{T <: SamplableBelief} <: AbstractPrior -# Z::T -# end - -PriorCircular(::UniformScaling) = PriorCircular(Normal()) - -# DFG.getManifold(::PriorCircular) = RealCircleGroup() +IIFTypes.PriorCircular(::UniformScaling) = PriorCircular(Normal()) function getSample(cf::CalcFactor{<:PriorCircular}) # FIXME workaround for issue #TBD with manifolds CircularGroup, @@ -79,38 +42,4 @@ function Base.convert(::Type{<:MB.AbstractManifold}, ::InstanceType{PriorCircula return Manifolds.RealCircleGroup() end -# """ -# $(TYPEDEF) - -# Serialized object for storing PriorCircular. -# """ -# Base.@kwdef struct PackedPriorCircular <: AbstractPackedFactor -# Z::PackedSamplableBelief -# end - -# function convert(::Type{PackedPriorCircular}, d::PriorCircular) -# return PackedPriorCircular(convert(PackedSamplableBelief, d.Z)) -# end -# function convert(::Type{PriorCircular}, d::PackedPriorCircular) -# distr = convert(SamplableBelief, d.Z) -# return PriorCircular{typeof(distr)}(distr) -# end - -# -------------------------------------------- - -""" -$(TYPEDEF) - -Serialized object for storing CircularCircular. -""" -Base.@kwdef struct PackedCircularCircular <: AbstractPackedFactor - Z::PackedSamplableBelief -end -function convert(::Type{CircularCircular}, d::PackedCircularCircular) - return CircularCircular(convert(SamplableBelief, d.Z)) -end -function convert(::Type{PackedCircularCircular}, d::CircularCircular) - return PackedCircularCircular(convert(PackedSamplableBelief, d.Z)) -end - # -------------------------------------------- diff --git a/src/Factors/DefaultPrior.jl b/src/Factors/DefaultPrior.jl index 44df22ca..bd7a6677 100644 --- a/src/Factors/DefaultPrior.jl +++ b/src/Factors/DefaultPrior.jl @@ -1,43 +1,7 @@ -""" -$(TYPEDEF) +IIFTypes.Prior(::UniformScaling) = Prior(Normal()) -Default prior on all dimensions of a variable node in the factor graph. `Prior` is -not recommended when non-Euclidean dimensions are used in variables. -""" -struct Prior{T <: SamplableBelief} <: AbstractPrior - Z::T -end -Prior(::UniformScaling) = Prior(Normal()) - -getManifold(pr::Prior) = TranslationGroup(getDimension(pr.Z)) # getSample(cf::CalcFactor{<:Prior}) = rand(cf.factor.Z) # basic default (s::CalcFactor{<:Prior})(z, x1) = z .- x1 - -## packed types are still developed by hand. Future versions would likely use a @packable macro to write Protobuf safe versions of factors - -""" -$(TYPEDEF) - -Serialization type for Prior. -""" -Base.@kwdef mutable struct PackedPrior <: AbstractPackedFactor - Z::PackedSamplableBelief -end -function convert(::Type{PackedPrior}, d::Prior) - return PackedPrior(convert(PackedSamplableBelief, d.Z)) -end -function convert(::Type{Prior}, d::PackedPrior) - return Prior(convert(SamplableBelief, d.Z)) -end - -function DFG.pack(d::Prior) - return PackedPrior(DFG.packDistribution(d.Z)) -end -function DFG.unpack(d::PackedPrior) - return Prior(DFG.unpackDistribution(d.Z)) -end - -# diff --git a/src/Factors/LinearRelative.jl b/src/Factors/LinearRelative.jl index d0c7cbe6..d48c529b 100644 --- a/src/Factors/LinearRelative.jl +++ b/src/Factors/LinearRelative.jl @@ -1,40 +1,6 @@ export LinearRelative, PackedLinearRelative -""" -$(TYPEDEF) - -Default linear offset between two scalar variables. - -```math -X_2 = X_1 + η_Z -``` -""" -struct LinearRelative{N, T <: SamplableBelief} <: AbstractManifoldMinimize # AbstractRelativeMinimize - Z::T -end - -# need several helper constructors since the dimension over which LinearRelative will be used is unknown at this point -function LinearRelative{N}( - z0::T = MvNormal(zeros(N), diagm(ones(N))), -) where {N, T <: SamplableBelief} - # - return LinearRelative{N, T}(z0) -end - -function LinearRelative(::UniformScaling = LinearAlgebra.I) - return LinearRelative{1}(MvNormal(zeros(1), diagm(ones(1)))) -end -function LinearRelative(nm::Distributions.ContinuousUnivariateDistribution) - return LinearRelative{1, typeof(nm)}(nm) -end -LinearRelative(nm::MvNormal) = LinearRelative{length(nm.μ), typeof(nm)}(nm) -function LinearRelative(nm::Union{<:BallTreeDensity, <:ManifoldKernelDensity}) - return LinearRelative{Ndim(nm), typeof(nm)}(nm) -end - -getManifold(::InstanceType{LinearRelative{N}}) where {N} = getManifold(ContinuousEuclid{N}) - # TODO standardize getDimension(::InstanceType{LinearRelative{N}}) where {N} = N @@ -55,24 +21,3 @@ function Base.convert( return Manifolds.TranslationGroup(N) end -""" -$(TYPEDEF) -Serialization type for `LinearRelative` binary factor. -""" -Base.@kwdef mutable struct PackedLinearRelative <: AbstractPackedFactor - Z::PackedSamplableBelief -end -function convert(::Type{PackedLinearRelative}, d::LinearRelative) - return PackedLinearRelative(convert(PackedSamplableBelief, d.Z)) -end -function convert(::Type{LinearRelative}, d::PackedLinearRelative) - return LinearRelative(convert(SamplableBelief, d.Z)) -end -function DFG.pack(d::LinearRelative) - return PackedLinearRelative(DFG.packDistribution(d.Z)) -end -function DFG.unpack(d::PackedLinearRelative) - return LinearRelative(DFG.unpackDistribution(d.Z)) -end - -# diff --git a/src/IncrementalInference.jl b/src/IncrementalInference.jl index 2f01daf6..64cb2d89 100644 --- a/src/IncrementalInference.jl +++ b/src/IncrementalInference.jl @@ -102,6 +102,9 @@ const BeliefArray{T} = Union{<:AbstractMatrix{<:T}, <:Adjoint{<:T, AbstractMatri # FIXME, remove this and let the user do either import or const definitions export KDE, AMP, DFG, FSM, IIF +# include("../IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl") +@reexport using IncrementalInferenceTypes + # TODO temporary for initial version of on-manifold products KDE.setForceEvalDirect!(true) @@ -116,7 +119,6 @@ include("ExportAPI.jl") # regular -include("entities/SolverParams.jl") include("entities/HypoRecipe.jl") include("entities/CalcFactor.jl") @@ -173,7 +175,6 @@ include("services/TreeBasedInitialization.jl") # included variables of IIF, easy to extend in user's context include("Variables/DefaultVariables.jl") -include("Variables/Circular.jl") # included factors, see RoME.jl for more examples include("Factors/GenericFunctions.jl") diff --git a/src/Serialization/entities/SerializingDistributions.jl b/src/Serialization/entities/SerializingDistributions.jl index faea7bdd..8fb163c3 100644 --- a/src/Serialization/entities/SerializingDistributions.jl +++ b/src/Serialization/entities/SerializingDistributions.jl @@ -19,50 +19,3 @@ StringThemSamplableBeliefs = Union{ # Base.@kwdef struct PackedDiscreteNonParametric <: PackedSamplableBelief # _type::String = "IncrementalInference.PackedDiscreteNonParametric" # end - -Base.@kwdef struct PackedCategorical <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedCategorical" - p::Vector{Float64} = [1.0;] -end - -Base.@kwdef mutable struct PackedUniform <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedUniform" - a::Float64 = 0.0 - b::Float64 = 1.0 - PackedSamplableTypeJSON::String = "IncrementalInference.PackedUniform" -end - -Base.@kwdef struct PackedNormal <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedNormal" - mu::Float64 = 0.0 - sigma::Float64 = 1.0 -end - -Base.@kwdef struct PackedZeroMeanDiagNormal <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedZeroMeanDiagNormal" - diag::Vector{Float64} = ones(1) -end - -Base.@kwdef struct PackedZeroMeanFullNormal <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedZeroMeanFullNormal" - cov::Vector{Float64} = ones(1) -end - -Base.@kwdef mutable struct PackedDiagNormal <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedDiagNormal" - mu::Vector{Float64} = zeros(1) - diag::Vector{Float64} = ones(1) -end - -Base.@kwdef struct PackedFullNormal <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedFullNormal" - mu::Vector{Float64} = zeros(1) - cov::Vector{Float64} = ones(1) -end - -Base.@kwdef struct PackedRayleigh <: PackedSamplableBelief - _type::String = "IncrementalInference.PackedRayleigh" - sigma::Float64 = 1.0 -end - -# diff --git a/src/Serialization/services/SerializationMKD.jl b/src/Serialization/services/SerializationMKD.jl index be80f886..2a492b39 100644 --- a/src/Serialization/services/SerializationMKD.jl +++ b/src/Serialization/services/SerializationMKD.jl @@ -43,7 +43,7 @@ function parchDistribution(mkd::ManifoldKernelDensity) end # Data converters for MKD -function packDistribution(mkd::ManifoldKernelDensity) +function DFG.packDistribution(mkd::ManifoldKernelDensity) # pts = getPoints(mkd) @@ -58,7 +58,7 @@ function packDistribution(mkd::ManifoldKernelDensity) ) end -function unpackDistribution(dtr::PackedManifoldKernelDensity) +function DFG.unpackDistribution(dtr::PackedManifoldKernelDensity) # find InferenceVariable type from string (anything Manifolds.jl?) M = DFG.getTypeFromSerializationModule(dtr.varType) |> getManifold vecP = [AMP.makePointFromCoords(M, pt) for pt in dtr.pts] diff --git a/src/Serialization/services/SerializingDistributions.jl b/src/Serialization/services/SerializingDistributions.jl index 511b5e6c..d846f27f 100644 --- a/src/Serialization/services/SerializingDistributions.jl +++ b/src/Serialization/services/SerializingDistributions.jl @@ -1,43 +1,12 @@ -## Distributions to JSON/Packed types - -packDistribution(dtr::Categorical) = PackedCategorical(; p = dtr.p) -packDistribution(dtr::Uniform) = PackedUniform(; a = dtr.a, b = dtr.b) -packDistribution(dtr::Normal) = PackedNormal(; mu = dtr.μ, sigma = dtr.σ) -packDistribution(dtr::ZeroMeanDiagNormal) = PackedZeroMeanDiagNormal(; diag = dtr.Σ.diag) -packDistribution(dtr::ZeroMeanFullNormal) = PackedZeroMeanFullNormal(; cov = dtr.Σ.mat[:]) -packDistribution(dtr::DiagNormal) = PackedDiagNormal(; mu = dtr.μ, diag = dtr.Σ.diag) -packDistribution(dtr::FullNormal) = PackedFullNormal(; mu = dtr.μ, cov = dtr.Σ.mat[:]) -packDistribution(dtr::Rayleigh) = PackedRayleigh(; sigma = dtr.σ) - function packDistribution(dtr::AliasingScalarSampler) return PackedAliasingScalarSampler(; domain = dtr.domain, weights = dtr.weights.values) end - -## Unpack JSON/Packed to Distribution types - -unpackDistribution(dtr::PackedCategorical) = Categorical(dtr.p ./ sum(dtr.p)) -unpackDistribution(dtr::PackedUniform) = Uniform(dtr.a, dtr.b) -unpackDistribution(dtr::PackedNormal) = Normal(dtr.mu, dtr.sigma) -function unpackDistribution(dtr::PackedZeroMeanDiagNormal) - return MvNormal(LinearAlgebra.Diagonal(map(abs2, sqrt.(dtr.diag)))) -end # sqrt.(dtr.diag) -function unpackDistribution(dtr::PackedZeroMeanFullNormal) - d = round(Int,sqrt(size(dtr.cov)[1])) - return MvNormal(reshape(dtr.cov, d, d)) -end -unpackDistribution(dtr::PackedDiagNormal) = MvNormal(dtr.mu, sqrt.(dtr.diag)) -function unpackDistribution(dtr::PackedFullNormal) - return MvNormal(dtr.mu, reshape(dtr.cov, length(dtr.mu), :)) -end -unpackDistribution(dtr::PackedRayleigh) = Rayleigh(dtr.sigma) - function unpackDistribution(dtr::PackedAliasingScalarSampler) return AliasingScalarSampler(dtr.domain, dtr.weights ./ sum(dtr.weights)) end - # ## strip field from NamedTuple # function _delete( nt::Union{<:NamedTuple, <:Dict{K,T}}, diff --git a/src/Variables/Circular.jl b/src/Variables/Circular.jl deleted file mode 100644 index 2ec32fd6..00000000 --- a/src/Variables/Circular.jl +++ /dev/null @@ -1,14 +0,0 @@ - -# export Circular, Circle - -# """ -# $(TYPEDEF) - -# Circular is a `Manifolds.Circle{ℝ}` mechanization of one rotation, with `theta in [-pi,pi)`. -# """ -# @defVariable Circular Circle() [0.0;] - - -# Base.convert(::Type{<:MB.AbstractManifold}, ::InstanceType{Circular}) = Manifolds.Circle() - -# diff --git a/src/Variables/DefaultVariables.jl b/src/Variables/DefaultVariables.jl index 597435bf..2ba8dc8e 100644 --- a/src/Variables/DefaultVariables.jl +++ b/src/Variables/DefaultVariables.jl @@ -1,56 +1,6 @@ - -## Euclid 1 - -""" - $TYPEDEF - -Continuous Euclidean variable of dimension `N` representing a Position in cartesian space. -""" -struct Position{N} <: InferenceVariable end - -Position(N::Int) = Position{N}() - -# not sure if these overloads are necessary since DFG 775? -DFG.getManifold(::InstanceType{Position{N}}) where {N} = TranslationGroup(N) -function DFG.getDimension(val::InstanceType{Position{N}}) where {N} - return manifold_dimension(getManifold(val)) -end -DFG.getPointType(::Type{Position{N}}) where {N} = SVector{N, Float64} -DFG.getPointIdentity(M_::Type{Position{N}}) where {N} = @SVector(zeros(N)) # identity_element(getManifold(M_), zeros(N)) - function Base.convert( ::Type{<:ManifoldsBase.AbstractManifold}, ::InstanceType{Position{N}}, ) where {N} return TranslationGroup(N) -end - -# - -""" -$(TYPEDEF) - -Most basic continuous scalar variable in a `::DFG.AbstractDFG` object. - -Alias of `Position{1}` -""" -const ContinuousScalar = Position{1} -const ContinuousEuclid{N} = Position{N} - -const Position1 = Position{1} -const Position2 = Position{2} -const Position3 = Position{3} -const Position4 = Position{4} - -## Circular - -""" -$(TYPEDEF) - -Circular is a `Manifolds.Circle{ℝ}` mechanization of one rotation, with `theta in [-pi,pi)`. -""" -@defVariable Circular RealCircleGroup() [0.0;] -#TODO This is an example of what we want working, possible issue upstream in Manifolds.jl -# @defVariable Circular RealCircleGroup() Scalar(0.0) - -# +end \ No newline at end of file diff --git a/src/services/GraphInit.jl b/src/services/GraphInit.jl index 0d1bcbab..1fcc3cd3 100644 --- a/src/services/GraphInit.jl +++ b/src/services/GraphInit.jl @@ -448,7 +448,13 @@ function resetInitialValues!( for vs in varList vnd = getVariableState(getVariable(src, vs), initKey) # guess we definitely want to use copy to preserve the initKey memory - updateVariableSolverData!(dest, vs, vnd, solveKey, true; warn_if_absent = false) + # updateVariableSolverData!(dest, vs, vnd, solveKey, true; warn_if_absent = false) + DFG.copytoVariableState!( + dest, + vs, + solveKey, + vnd, + ) end return dest end diff --git a/src/services/SubGraphFunctions.jl b/src/services/SubGraphFunctions.jl index c2e75ffd..bb93c2fd 100644 --- a/src/services/SubGraphFunctions.jl +++ b/src/services/SubGraphFunctions.jl @@ -142,16 +142,17 @@ function transferUpdateSubGraph!( end # transfer specific fields into dest from src - for var in (x -> getVariable(src, x)).(syms) - # copy not required since a broadcast is used internally - updateVariableSolverData!( + @time for var in (x -> getVariable(src, x)).(syms) + # NOTE compared copytoVariableState! vs surgical updateVariableSolverData! + # updateVariableSolverData! 0.000626 seconds (1.11 k allocations: 114.289 KiB) + # copytoVariableState! 0.000099 seconds (315 allocations: 27.758 KiB) + DFG.copytoVariableState!( dest, - var, + getLabel(var), solveKey, - false, - [:val; :bw; :infoPerCoord; :solvedCount; :initialized]; - warn_if_absent = false, + getVariableState(var, solveKey), ) + if updatePPE # create ppe on new key using defaults, TODO improve if haskey(getPPEDict(var), solveKey) From 4588832ae535d333a10ed9637593b3cb6e8ad657 Mon Sep 17 00:00:00 2001 From: Johannes Terblanche Date: Thu, 26 Jun 2025 09:44:39 +0200 Subject: [PATCH 2/3] Also move IIF to subproject (no code changes) --- Project.toml => IncrementalInference/Project.toml | 0 {ext => IncrementalInference/ext}/FluxModelsSerialization.jl | 0 {ext => IncrementalInference/ext}/HeatmapSampler.jl | 0 {ext => IncrementalInference/ext}/IncrInfrApproxMinDegreeExt.jl | 0 {ext => IncrementalInference/ext}/IncrInfrDiffEqFactorExt.jl | 0 {ext => IncrementalInference/ext}/IncrInfrFluxFactorsExt.jl | 0 {ext => IncrementalInference/ext}/IncrInfrGadflyExt.jl | 0 {ext => IncrementalInference/ext}/IncrInfrInteractiveUtilsExt.jl | 0 {ext => IncrementalInference/ext}/IncrInfrInterpolationsExt.jl | 0 {ext => IncrementalInference/ext}/WeakDepsPrototypes.jl | 0 .../src}/CliqueStateMachine/services/CliqStateMachineUtils.jl | 0 .../src}/CliqueStateMachine/services/CliqueStateMachine.jl | 0 {src => IncrementalInference/src}/Deprecated.jl | 0 {src => IncrementalInference/src}/ExportAPI.jl | 0 {src => IncrementalInference/src}/Factors/Circular.jl | 0 {src => IncrementalInference/src}/Factors/DefaultPrior.jl | 0 {src => IncrementalInference/src}/Factors/EuclidDistance.jl | 0 {src => IncrementalInference/src}/Factors/GenericFunctions.jl | 0 {src => IncrementalInference/src}/Factors/GenericMarginal.jl | 0 {src => IncrementalInference/src}/Factors/LinearRelative.jl | 0 {src => IncrementalInference/src}/Factors/MetaPrior.jl | 0 {src => IncrementalInference/src}/Factors/Mixture.jl | 0 {src => IncrementalInference/src}/Factors/MsgPrior.jl | 0 {src => IncrementalInference/src}/Factors/PartialPrior.jl | 0 .../src}/Factors/PartialPriorPassThrough.jl | 0 {src => IncrementalInference/src}/IncrementalInference.jl | 0 {src => IncrementalInference/src}/NeedsResolution.jl | 0 .../src}/Serialization/entities/AdditionalDensities.jl | 0 .../src}/Serialization/entities/SerializingDistributions.jl | 0 .../src}/Serialization/entities/SerializingOptionalDensities.jl | 0 .../src}/Serialization/services/DispatchPackedConversions.jl | 0 .../src}/Serialization/services/SerializationMKD.jl | 0 .../src}/Serialization/services/SerializingDistributions.jl | 0 .../src}/Serialization/services/SerializingOptionalDensities.jl | 0 {src => IncrementalInference/src}/Variables/DefaultVariables.jl | 0 {src => IncrementalInference/src}/entities/AliasScalarSampling.jl | 0 {src => IncrementalInference/src}/entities/BeliefTypes.jl | 0 {src => IncrementalInference/src}/entities/CalcFactor.jl | 0 {src => IncrementalInference/src}/entities/CliqueTypes.jl | 0 {src => IncrementalInference/src}/entities/ExtDensities.jl | 0 {src => IncrementalInference/src}/entities/ExtFactors.jl | 0 {src => IncrementalInference/src}/entities/FactorGradients.jl | 0 .../src}/entities/FactorOperationalMemory.jl | 0 {src => IncrementalInference/src}/entities/HypoRecipe.jl | 0 {src => IncrementalInference/src}/entities/JunctionTreeTypes.jl | 0 .../src}/manifolds/services/ManifoldSampling.jl | 0 .../src}/manifolds/services/ManifoldsExtentions.jl | 0 .../src}/parametric/services/ConsolidateParametricRelatives.jl | 0 .../src}/parametric/services/ParametricCSMFunctions.jl | 0 .../src}/parametric/services/ParametricManopt.jl | 0 .../src}/parametric/services/ParametricOptim.jl | 0 .../src}/parametric/services/ParametricUtils.jl | 0 {src => IncrementalInference/src}/services/AdditionalUtils.jl | 0 {src => IncrementalInference/src}/services/AnalysisTools.jl | 0 {src => IncrementalInference/src}/services/ApproxConv.jl | 0 {src => IncrementalInference/src}/services/BayesNet.jl | 0 {src => IncrementalInference/src}/services/CalcFactor.jl | 0 .../src}/services/CanonicalGraphExamples.jl | 0 {src => IncrementalInference/src}/services/CliqueTypes.jl | 0 {src => IncrementalInference/src}/services/CompareUtils.jl | 0 {src => IncrementalInference/src}/services/DeconvUtils.jl | 0 {src => IncrementalInference/src}/services/DefaultNodeTypes.jl | 0 {src => IncrementalInference/src}/services/EvalFactor.jl | 0 .../src}/services/ExplicitDiscreteMarginalizations.jl | 0 {src => IncrementalInference/src}/services/FGOSUtils.jl | 0 {src => IncrementalInference/src}/services/FactorGradients.jl | 0 {src => IncrementalInference/src}/services/FactorGraph.jl | 0 {src => IncrementalInference/src}/services/GraphInit.jl | 0 .../src}/services/GraphProductOperations.jl | 0 {src => IncrementalInference/src}/services/HypoRecipe.jl | 0 {src => IncrementalInference/src}/services/JunctionTree.jl | 0 {src => IncrementalInference/src}/services/JunctionTreeUtils.jl | 0 {src => IncrementalInference/src}/services/MaxMixture.jl | 0 .../src}/services/NumericalCalculations.jl | 0 {src => IncrementalInference/src}/services/SolveTree.jl | 0 {src => IncrementalInference/src}/services/SolverAPI.jl | 0 {src => IncrementalInference/src}/services/SolverUtilities.jl | 0 {src => IncrementalInference/src}/services/SubGraphFunctions.jl | 0 {src => IncrementalInference/src}/services/TetherUtils.jl | 0 .../src}/services/TreeBasedInitialization.jl | 0 {src => IncrementalInference/src}/services/TreeDebugTools.jl | 0 .../src}/services/TreeMessageAccessors.jl | 0 {src => IncrementalInference/src}/services/TreeMessageUtils.jl | 0 {src => IncrementalInference/src}/services/VariableStatistics.jl | 0 {test => IncrementalInference/test}/TestCSMMultihypo.jl | 0 {test => IncrementalInference/test}/TestModuleFunctions.jl | 0 {test => IncrementalInference/test}/basicGraphsOperations.jl | 0 {test => IncrementalInference/test}/fourdoortest.jl | 0 {test => IncrementalInference/test}/manifolds/factordiff.jl | 0 {test => IncrementalInference/test}/manifolds/manifolddiff.jl | 0 {test => IncrementalInference/test}/priorusetest.jl | 0 {test => IncrementalInference/test}/runtests.jl | 0 {test => IncrementalInference/test}/saveconvertertypes.jl | 0 {test => IncrementalInference/test}/testAnalysisTools.jl | 0 {test => IncrementalInference/test}/testApproxConv.jl | 0 {test => IncrementalInference/test}/testBasicCSM.jl | 0 {test => IncrementalInference/test}/testBasicForwardConvolve.jl | 0 {test => IncrementalInference/test}/testBasicGraphs.jl | 0 {test => IncrementalInference/test}/testBasicManifolds.jl | 0 {test => IncrementalInference/test}/testBasicParametric.jl | 0 {test => IncrementalInference/test}/testBasicRecycling.jl | 0 {test => IncrementalInference/test}/testBasicTreeInit.jl | 0 {test => IncrementalInference/test}/testBayesTreeiSAM2Example.jl | 0 {test => IncrementalInference/test}/testCSMMonitor.jl | 0 {test => IncrementalInference/test}/testCalcFactorHypos.jl | 0 {test => IncrementalInference/test}/testCcolamdOrdering.jl | 0 {test => IncrementalInference/test}/testCircular.jl | 0 {test => IncrementalInference/test}/testCliqSolveDbgUtils.jl | 0 {test => IncrementalInference/test}/testCliqueFactors.jl | 0 {test => IncrementalInference/test}/testCliqueTreesOrderings.jl | 0 {test => IncrementalInference/test}/testCommonConvWrapper.jl | 0 .../test}/testCompareVariablesFactors.jl | 0 {test => IncrementalInference/test}/testDERelative.jl | 0 {test => IncrementalInference/test}/testDeadReckoningTether.jl | 0 {test => IncrementalInference/test}/testDefaultDeconv.jl | 0 {test => IncrementalInference/test}/testDistributionsGeneric.jl | 0 {test => IncrementalInference/test}/testEuclidDistance.jl | 0 {test => IncrementalInference/test}/testExpXstroke.jl | 0 {test => IncrementalInference/test}/testExplicitMultihypo.jl | 0 {test => IncrementalInference/test}/testFactorGradients.jl | 0 {test => IncrementalInference/test}/testFluxModelsDistribution.jl | 0 {test => IncrementalInference/test}/testGradientUtils.jl | 0 {test => IncrementalInference/test}/testHasPriors913.jl | 0 {test => IncrementalInference/test}/testHeatmapGridDensity.jl | 0 {test => IncrementalInference/test}/testInitVariableOrder.jl | 0 {test => IncrementalInference/test}/testJointEnforcement.jl | 0 .../test}/testJunctionTreeConstruction.jl | 0 {test => IncrementalInference/test}/testManualInit.jl | 0 .../test}/testMixtureLinearConditional.jl | 0 {test => IncrementalInference/test}/testMixtureParametric.jl | 0 {test => IncrementalInference/test}/testMixturePrior.jl | 0 {test => IncrementalInference/test}/testMultiHypo3Door.jl | 0 {test => IncrementalInference/test}/testMultihypoAndChain.jl | 0 {test => IncrementalInference/test}/testMultimodal1D.jl | 0 {test => IncrementalInference/test}/testMultiprocess.jl | 0 {test => IncrementalInference/test}/testMultithreaded.jl | 0 {test => IncrementalInference/test}/testPackedDistributions.jl | 0 {test => IncrementalInference/test}/testPackingMixtures.jl | 0 {test => IncrementalInference/test}/testPartialFactors.jl | 0 {test => IncrementalInference/test}/testPartialNH.jl | 0 {test => IncrementalInference/test}/testPartialPrior.jl | 0 {test => IncrementalInference/test}/testProductReproducable.jl | 0 {test => IncrementalInference/test}/testSaveLoadDFG.jl | 0 {test => IncrementalInference/test}/testSkipUpDown.jl | 0 {test => IncrementalInference/test}/testSolveKey.jl | 0 {test => IncrementalInference/test}/testSolveOrphanedFG.jl | 0 {test => IncrementalInference/test}/testSolveSetPPE.jl | 0 {test => IncrementalInference/test}/testSpecialEuclidean2Mani.jl | 0 {test => IncrementalInference/test}/testSpecialOrthogonalMani.jl | 0 {test => IncrementalInference/test}/testSpecialSampler.jl | 0 {test => IncrementalInference/test}/testSphereMani.jl | 0 {test => IncrementalInference/test}/testStateMachine.jl | 0 {test => IncrementalInference/test}/testTexTreeIllustration.jl | 0 {test => IncrementalInference/test}/testTranslationMani.jl | 0 {test => IncrementalInference/test}/testTreeFunctions.jl | 0 {test => IncrementalInference/test}/testTreeMessageUtils.jl | 0 {test => IncrementalInference/test}/testTreeSaveLoad.jl | 0 {test => IncrementalInference/test}/testUseMsgLikelihoods.jl | 0 {test => IncrementalInference/test}/testVariousNSolveSize.jl | 0 {test => IncrementalInference/test}/testgraphpackingconverters.jl | 0 .../test}/testlocalconstraintexamples.jl | 0 {test => IncrementalInference/test}/testmultihypothesisapi.jl | 0 {test => IncrementalInference/test}/testnullhypothesis.jl | 0 {test => IncrementalInference/test}/testpartialconstraint.jl | 0 {test => IncrementalInference/test}/tmp/.gitkeep | 0 {test => IncrementalInference/test}/typeReturnMemRef.jl | 0 166 files changed, 0 insertions(+), 0 deletions(-) rename Project.toml => IncrementalInference/Project.toml (100%) rename {ext => IncrementalInference/ext}/FluxModelsSerialization.jl (100%) rename {ext => IncrementalInference/ext}/HeatmapSampler.jl (100%) rename {ext => IncrementalInference/ext}/IncrInfrApproxMinDegreeExt.jl (100%) rename {ext => IncrementalInference/ext}/IncrInfrDiffEqFactorExt.jl (100%) rename {ext => IncrementalInference/ext}/IncrInfrFluxFactorsExt.jl (100%) rename {ext => IncrementalInference/ext}/IncrInfrGadflyExt.jl (100%) rename {ext => IncrementalInference/ext}/IncrInfrInteractiveUtilsExt.jl (100%) rename {ext => IncrementalInference/ext}/IncrInfrInterpolationsExt.jl (100%) rename {ext => IncrementalInference/ext}/WeakDepsPrototypes.jl (100%) rename {src => IncrementalInference/src}/CliqueStateMachine/services/CliqStateMachineUtils.jl (100%) rename {src => IncrementalInference/src}/CliqueStateMachine/services/CliqueStateMachine.jl (100%) rename {src => IncrementalInference/src}/Deprecated.jl (100%) rename {src => IncrementalInference/src}/ExportAPI.jl (100%) rename {src => IncrementalInference/src}/Factors/Circular.jl (100%) rename {src => IncrementalInference/src}/Factors/DefaultPrior.jl (100%) rename {src => IncrementalInference/src}/Factors/EuclidDistance.jl (100%) rename {src => IncrementalInference/src}/Factors/GenericFunctions.jl (100%) rename {src => IncrementalInference/src}/Factors/GenericMarginal.jl (100%) rename {src => IncrementalInference/src}/Factors/LinearRelative.jl (100%) rename {src => IncrementalInference/src}/Factors/MetaPrior.jl (100%) rename {src => IncrementalInference/src}/Factors/Mixture.jl (100%) rename {src => IncrementalInference/src}/Factors/MsgPrior.jl (100%) rename {src => IncrementalInference/src}/Factors/PartialPrior.jl (100%) rename {src => IncrementalInference/src}/Factors/PartialPriorPassThrough.jl (100%) rename {src => IncrementalInference/src}/IncrementalInference.jl (100%) rename {src => IncrementalInference/src}/NeedsResolution.jl (100%) rename {src => IncrementalInference/src}/Serialization/entities/AdditionalDensities.jl (100%) rename {src => IncrementalInference/src}/Serialization/entities/SerializingDistributions.jl (100%) rename {src => IncrementalInference/src}/Serialization/entities/SerializingOptionalDensities.jl (100%) rename {src => IncrementalInference/src}/Serialization/services/DispatchPackedConversions.jl (100%) rename {src => IncrementalInference/src}/Serialization/services/SerializationMKD.jl (100%) rename {src => IncrementalInference/src}/Serialization/services/SerializingDistributions.jl (100%) rename {src => IncrementalInference/src}/Serialization/services/SerializingOptionalDensities.jl (100%) rename {src => IncrementalInference/src}/Variables/DefaultVariables.jl (100%) rename {src => IncrementalInference/src}/entities/AliasScalarSampling.jl (100%) rename {src => IncrementalInference/src}/entities/BeliefTypes.jl (100%) rename {src => IncrementalInference/src}/entities/CalcFactor.jl (100%) rename {src => IncrementalInference/src}/entities/CliqueTypes.jl (100%) rename {src => IncrementalInference/src}/entities/ExtDensities.jl (100%) rename {src => IncrementalInference/src}/entities/ExtFactors.jl (100%) rename {src => IncrementalInference/src}/entities/FactorGradients.jl (100%) rename {src => IncrementalInference/src}/entities/FactorOperationalMemory.jl (100%) rename {src => IncrementalInference/src}/entities/HypoRecipe.jl (100%) rename {src => IncrementalInference/src}/entities/JunctionTreeTypes.jl (100%) rename {src => IncrementalInference/src}/manifolds/services/ManifoldSampling.jl (100%) rename {src => IncrementalInference/src}/manifolds/services/ManifoldsExtentions.jl (100%) rename {src => IncrementalInference/src}/parametric/services/ConsolidateParametricRelatives.jl (100%) rename {src => IncrementalInference/src}/parametric/services/ParametricCSMFunctions.jl (100%) rename {src => IncrementalInference/src}/parametric/services/ParametricManopt.jl (100%) rename {src => IncrementalInference/src}/parametric/services/ParametricOptim.jl (100%) rename {src => IncrementalInference/src}/parametric/services/ParametricUtils.jl (100%) rename {src => IncrementalInference/src}/services/AdditionalUtils.jl (100%) rename {src => IncrementalInference/src}/services/AnalysisTools.jl (100%) rename {src => IncrementalInference/src}/services/ApproxConv.jl (100%) rename {src => IncrementalInference/src}/services/BayesNet.jl (100%) rename {src => IncrementalInference/src}/services/CalcFactor.jl (100%) rename {src => IncrementalInference/src}/services/CanonicalGraphExamples.jl (100%) rename {src => IncrementalInference/src}/services/CliqueTypes.jl (100%) rename {src => IncrementalInference/src}/services/CompareUtils.jl (100%) rename {src => IncrementalInference/src}/services/DeconvUtils.jl (100%) rename {src => IncrementalInference/src}/services/DefaultNodeTypes.jl (100%) rename {src => IncrementalInference/src}/services/EvalFactor.jl (100%) rename {src => IncrementalInference/src}/services/ExplicitDiscreteMarginalizations.jl (100%) rename {src => IncrementalInference/src}/services/FGOSUtils.jl (100%) rename {src => IncrementalInference/src}/services/FactorGradients.jl (100%) rename {src => IncrementalInference/src}/services/FactorGraph.jl (100%) rename {src => IncrementalInference/src}/services/GraphInit.jl (100%) rename {src => IncrementalInference/src}/services/GraphProductOperations.jl (100%) rename {src => IncrementalInference/src}/services/HypoRecipe.jl (100%) rename {src => IncrementalInference/src}/services/JunctionTree.jl (100%) rename {src => IncrementalInference/src}/services/JunctionTreeUtils.jl (100%) rename {src => IncrementalInference/src}/services/MaxMixture.jl (100%) rename {src => IncrementalInference/src}/services/NumericalCalculations.jl (100%) rename {src => IncrementalInference/src}/services/SolveTree.jl (100%) rename {src => IncrementalInference/src}/services/SolverAPI.jl (100%) rename {src => IncrementalInference/src}/services/SolverUtilities.jl (100%) rename {src => IncrementalInference/src}/services/SubGraphFunctions.jl (100%) rename {src => IncrementalInference/src}/services/TetherUtils.jl (100%) rename {src => IncrementalInference/src}/services/TreeBasedInitialization.jl (100%) rename {src => IncrementalInference/src}/services/TreeDebugTools.jl (100%) rename {src => IncrementalInference/src}/services/TreeMessageAccessors.jl (100%) rename {src => IncrementalInference/src}/services/TreeMessageUtils.jl (100%) rename {src => IncrementalInference/src}/services/VariableStatistics.jl (100%) rename {test => IncrementalInference/test}/TestCSMMultihypo.jl (100%) rename {test => IncrementalInference/test}/TestModuleFunctions.jl (100%) rename {test => IncrementalInference/test}/basicGraphsOperations.jl (100%) rename {test => IncrementalInference/test}/fourdoortest.jl (100%) rename {test => IncrementalInference/test}/manifolds/factordiff.jl (100%) rename {test => IncrementalInference/test}/manifolds/manifolddiff.jl (100%) rename {test => IncrementalInference/test}/priorusetest.jl (100%) rename {test => IncrementalInference/test}/runtests.jl (100%) rename {test => IncrementalInference/test}/saveconvertertypes.jl (100%) rename {test => IncrementalInference/test}/testAnalysisTools.jl (100%) rename {test => IncrementalInference/test}/testApproxConv.jl (100%) rename {test => IncrementalInference/test}/testBasicCSM.jl (100%) rename {test => IncrementalInference/test}/testBasicForwardConvolve.jl (100%) rename {test => IncrementalInference/test}/testBasicGraphs.jl (100%) rename {test => IncrementalInference/test}/testBasicManifolds.jl (100%) rename {test => IncrementalInference/test}/testBasicParametric.jl (100%) rename {test => IncrementalInference/test}/testBasicRecycling.jl (100%) rename {test => IncrementalInference/test}/testBasicTreeInit.jl (100%) rename {test => IncrementalInference/test}/testBayesTreeiSAM2Example.jl (100%) rename {test => IncrementalInference/test}/testCSMMonitor.jl (100%) rename {test => IncrementalInference/test}/testCalcFactorHypos.jl (100%) rename {test => IncrementalInference/test}/testCcolamdOrdering.jl (100%) rename {test => IncrementalInference/test}/testCircular.jl (100%) rename {test => IncrementalInference/test}/testCliqSolveDbgUtils.jl (100%) rename {test => IncrementalInference/test}/testCliqueFactors.jl (100%) rename {test => IncrementalInference/test}/testCliqueTreesOrderings.jl (100%) rename {test => IncrementalInference/test}/testCommonConvWrapper.jl (100%) rename {test => IncrementalInference/test}/testCompareVariablesFactors.jl (100%) rename {test => IncrementalInference/test}/testDERelative.jl (100%) rename {test => IncrementalInference/test}/testDeadReckoningTether.jl (100%) rename {test => IncrementalInference/test}/testDefaultDeconv.jl (100%) rename {test => IncrementalInference/test}/testDistributionsGeneric.jl (100%) rename {test => IncrementalInference/test}/testEuclidDistance.jl (100%) rename {test => IncrementalInference/test}/testExpXstroke.jl (100%) rename {test => IncrementalInference/test}/testExplicitMultihypo.jl (100%) rename {test => IncrementalInference/test}/testFactorGradients.jl (100%) rename {test => IncrementalInference/test}/testFluxModelsDistribution.jl (100%) rename {test => IncrementalInference/test}/testGradientUtils.jl (100%) rename {test => IncrementalInference/test}/testHasPriors913.jl (100%) rename {test => IncrementalInference/test}/testHeatmapGridDensity.jl (100%) rename {test => IncrementalInference/test}/testInitVariableOrder.jl (100%) rename {test => IncrementalInference/test}/testJointEnforcement.jl (100%) rename {test => IncrementalInference/test}/testJunctionTreeConstruction.jl (100%) rename {test => IncrementalInference/test}/testManualInit.jl (100%) rename {test => IncrementalInference/test}/testMixtureLinearConditional.jl (100%) rename {test => IncrementalInference/test}/testMixtureParametric.jl (100%) rename {test => IncrementalInference/test}/testMixturePrior.jl (100%) rename {test => IncrementalInference/test}/testMultiHypo3Door.jl (100%) rename {test => IncrementalInference/test}/testMultihypoAndChain.jl (100%) rename {test => IncrementalInference/test}/testMultimodal1D.jl (100%) rename {test => IncrementalInference/test}/testMultiprocess.jl (100%) rename {test => IncrementalInference/test}/testMultithreaded.jl (100%) rename {test => IncrementalInference/test}/testPackedDistributions.jl (100%) rename {test => IncrementalInference/test}/testPackingMixtures.jl (100%) rename {test => IncrementalInference/test}/testPartialFactors.jl (100%) rename {test => IncrementalInference/test}/testPartialNH.jl (100%) rename {test => IncrementalInference/test}/testPartialPrior.jl (100%) rename {test => IncrementalInference/test}/testProductReproducable.jl (100%) rename {test => IncrementalInference/test}/testSaveLoadDFG.jl (100%) rename {test => IncrementalInference/test}/testSkipUpDown.jl (100%) rename {test => IncrementalInference/test}/testSolveKey.jl (100%) rename {test => IncrementalInference/test}/testSolveOrphanedFG.jl (100%) rename {test => IncrementalInference/test}/testSolveSetPPE.jl (100%) rename {test => IncrementalInference/test}/testSpecialEuclidean2Mani.jl (100%) rename {test => IncrementalInference/test}/testSpecialOrthogonalMani.jl (100%) rename {test => IncrementalInference/test}/testSpecialSampler.jl (100%) rename {test => IncrementalInference/test}/testSphereMani.jl (100%) rename {test => IncrementalInference/test}/testStateMachine.jl (100%) rename {test => IncrementalInference/test}/testTexTreeIllustration.jl (100%) rename {test => IncrementalInference/test}/testTranslationMani.jl (100%) rename {test => IncrementalInference/test}/testTreeFunctions.jl (100%) rename {test => IncrementalInference/test}/testTreeMessageUtils.jl (100%) rename {test => IncrementalInference/test}/testTreeSaveLoad.jl (100%) rename {test => IncrementalInference/test}/testUseMsgLikelihoods.jl (100%) rename {test => IncrementalInference/test}/testVariousNSolveSize.jl (100%) rename {test => IncrementalInference/test}/testgraphpackingconverters.jl (100%) rename {test => IncrementalInference/test}/testlocalconstraintexamples.jl (100%) rename {test => IncrementalInference/test}/testmultihypothesisapi.jl (100%) rename {test => IncrementalInference/test}/testnullhypothesis.jl (100%) rename {test => IncrementalInference/test}/testpartialconstraint.jl (100%) rename {test => IncrementalInference/test}/tmp/.gitkeep (100%) rename {test => IncrementalInference/test}/typeReturnMemRef.jl (100%) diff --git a/Project.toml b/IncrementalInference/Project.toml similarity index 100% rename from Project.toml rename to IncrementalInference/Project.toml diff --git a/ext/FluxModelsSerialization.jl b/IncrementalInference/ext/FluxModelsSerialization.jl similarity index 100% rename from ext/FluxModelsSerialization.jl rename to IncrementalInference/ext/FluxModelsSerialization.jl diff --git a/ext/HeatmapSampler.jl b/IncrementalInference/ext/HeatmapSampler.jl similarity index 100% rename from ext/HeatmapSampler.jl rename to IncrementalInference/ext/HeatmapSampler.jl diff --git a/ext/IncrInfrApproxMinDegreeExt.jl b/IncrementalInference/ext/IncrInfrApproxMinDegreeExt.jl similarity index 100% rename from ext/IncrInfrApproxMinDegreeExt.jl rename to IncrementalInference/ext/IncrInfrApproxMinDegreeExt.jl diff --git a/ext/IncrInfrDiffEqFactorExt.jl b/IncrementalInference/ext/IncrInfrDiffEqFactorExt.jl similarity index 100% rename from ext/IncrInfrDiffEqFactorExt.jl rename to IncrementalInference/ext/IncrInfrDiffEqFactorExt.jl diff --git a/ext/IncrInfrFluxFactorsExt.jl b/IncrementalInference/ext/IncrInfrFluxFactorsExt.jl similarity index 100% rename from ext/IncrInfrFluxFactorsExt.jl rename to IncrementalInference/ext/IncrInfrFluxFactorsExt.jl diff --git a/ext/IncrInfrGadflyExt.jl b/IncrementalInference/ext/IncrInfrGadflyExt.jl similarity index 100% rename from ext/IncrInfrGadflyExt.jl rename to IncrementalInference/ext/IncrInfrGadflyExt.jl diff --git a/ext/IncrInfrInteractiveUtilsExt.jl b/IncrementalInference/ext/IncrInfrInteractiveUtilsExt.jl similarity index 100% rename from ext/IncrInfrInteractiveUtilsExt.jl rename to IncrementalInference/ext/IncrInfrInteractiveUtilsExt.jl diff --git a/ext/IncrInfrInterpolationsExt.jl b/IncrementalInference/ext/IncrInfrInterpolationsExt.jl similarity index 100% rename from ext/IncrInfrInterpolationsExt.jl rename to IncrementalInference/ext/IncrInfrInterpolationsExt.jl diff --git a/ext/WeakDepsPrototypes.jl b/IncrementalInference/ext/WeakDepsPrototypes.jl similarity index 100% rename from ext/WeakDepsPrototypes.jl rename to IncrementalInference/ext/WeakDepsPrototypes.jl diff --git a/src/CliqueStateMachine/services/CliqStateMachineUtils.jl b/IncrementalInference/src/CliqueStateMachine/services/CliqStateMachineUtils.jl similarity index 100% rename from src/CliqueStateMachine/services/CliqStateMachineUtils.jl rename to IncrementalInference/src/CliqueStateMachine/services/CliqStateMachineUtils.jl diff --git a/src/CliqueStateMachine/services/CliqueStateMachine.jl b/IncrementalInference/src/CliqueStateMachine/services/CliqueStateMachine.jl similarity index 100% rename from src/CliqueStateMachine/services/CliqueStateMachine.jl rename to IncrementalInference/src/CliqueStateMachine/services/CliqueStateMachine.jl diff --git a/src/Deprecated.jl b/IncrementalInference/src/Deprecated.jl similarity index 100% rename from src/Deprecated.jl rename to IncrementalInference/src/Deprecated.jl diff --git a/src/ExportAPI.jl b/IncrementalInference/src/ExportAPI.jl similarity index 100% rename from src/ExportAPI.jl rename to IncrementalInference/src/ExportAPI.jl diff --git a/src/Factors/Circular.jl b/IncrementalInference/src/Factors/Circular.jl similarity index 100% rename from src/Factors/Circular.jl rename to IncrementalInference/src/Factors/Circular.jl diff --git a/src/Factors/DefaultPrior.jl b/IncrementalInference/src/Factors/DefaultPrior.jl similarity index 100% rename from src/Factors/DefaultPrior.jl rename to IncrementalInference/src/Factors/DefaultPrior.jl diff --git a/src/Factors/EuclidDistance.jl b/IncrementalInference/src/Factors/EuclidDistance.jl similarity index 100% rename from src/Factors/EuclidDistance.jl rename to IncrementalInference/src/Factors/EuclidDistance.jl diff --git a/src/Factors/GenericFunctions.jl b/IncrementalInference/src/Factors/GenericFunctions.jl similarity index 100% rename from src/Factors/GenericFunctions.jl rename to IncrementalInference/src/Factors/GenericFunctions.jl diff --git a/src/Factors/GenericMarginal.jl b/IncrementalInference/src/Factors/GenericMarginal.jl similarity index 100% rename from src/Factors/GenericMarginal.jl rename to IncrementalInference/src/Factors/GenericMarginal.jl diff --git a/src/Factors/LinearRelative.jl b/IncrementalInference/src/Factors/LinearRelative.jl similarity index 100% rename from src/Factors/LinearRelative.jl rename to IncrementalInference/src/Factors/LinearRelative.jl diff --git a/src/Factors/MetaPrior.jl b/IncrementalInference/src/Factors/MetaPrior.jl similarity index 100% rename from src/Factors/MetaPrior.jl rename to IncrementalInference/src/Factors/MetaPrior.jl diff --git a/src/Factors/Mixture.jl b/IncrementalInference/src/Factors/Mixture.jl similarity index 100% rename from src/Factors/Mixture.jl rename to IncrementalInference/src/Factors/Mixture.jl diff --git a/src/Factors/MsgPrior.jl b/IncrementalInference/src/Factors/MsgPrior.jl similarity index 100% rename from src/Factors/MsgPrior.jl rename to IncrementalInference/src/Factors/MsgPrior.jl diff --git a/src/Factors/PartialPrior.jl b/IncrementalInference/src/Factors/PartialPrior.jl similarity index 100% rename from src/Factors/PartialPrior.jl rename to IncrementalInference/src/Factors/PartialPrior.jl diff --git a/src/Factors/PartialPriorPassThrough.jl b/IncrementalInference/src/Factors/PartialPriorPassThrough.jl similarity index 100% rename from src/Factors/PartialPriorPassThrough.jl rename to IncrementalInference/src/Factors/PartialPriorPassThrough.jl diff --git a/src/IncrementalInference.jl b/IncrementalInference/src/IncrementalInference.jl similarity index 100% rename from src/IncrementalInference.jl rename to IncrementalInference/src/IncrementalInference.jl diff --git a/src/NeedsResolution.jl b/IncrementalInference/src/NeedsResolution.jl similarity index 100% rename from src/NeedsResolution.jl rename to IncrementalInference/src/NeedsResolution.jl diff --git a/src/Serialization/entities/AdditionalDensities.jl b/IncrementalInference/src/Serialization/entities/AdditionalDensities.jl similarity index 100% rename from src/Serialization/entities/AdditionalDensities.jl rename to IncrementalInference/src/Serialization/entities/AdditionalDensities.jl diff --git a/src/Serialization/entities/SerializingDistributions.jl b/IncrementalInference/src/Serialization/entities/SerializingDistributions.jl similarity index 100% rename from src/Serialization/entities/SerializingDistributions.jl rename to IncrementalInference/src/Serialization/entities/SerializingDistributions.jl diff --git a/src/Serialization/entities/SerializingOptionalDensities.jl b/IncrementalInference/src/Serialization/entities/SerializingOptionalDensities.jl similarity index 100% rename from src/Serialization/entities/SerializingOptionalDensities.jl rename to IncrementalInference/src/Serialization/entities/SerializingOptionalDensities.jl diff --git a/src/Serialization/services/DispatchPackedConversions.jl b/IncrementalInference/src/Serialization/services/DispatchPackedConversions.jl similarity index 100% rename from src/Serialization/services/DispatchPackedConversions.jl rename to IncrementalInference/src/Serialization/services/DispatchPackedConversions.jl diff --git a/src/Serialization/services/SerializationMKD.jl b/IncrementalInference/src/Serialization/services/SerializationMKD.jl similarity index 100% rename from src/Serialization/services/SerializationMKD.jl rename to IncrementalInference/src/Serialization/services/SerializationMKD.jl diff --git a/src/Serialization/services/SerializingDistributions.jl b/IncrementalInference/src/Serialization/services/SerializingDistributions.jl similarity index 100% rename from src/Serialization/services/SerializingDistributions.jl rename to IncrementalInference/src/Serialization/services/SerializingDistributions.jl diff --git a/src/Serialization/services/SerializingOptionalDensities.jl b/IncrementalInference/src/Serialization/services/SerializingOptionalDensities.jl similarity index 100% rename from src/Serialization/services/SerializingOptionalDensities.jl rename to IncrementalInference/src/Serialization/services/SerializingOptionalDensities.jl diff --git a/src/Variables/DefaultVariables.jl b/IncrementalInference/src/Variables/DefaultVariables.jl similarity index 100% rename from src/Variables/DefaultVariables.jl rename to IncrementalInference/src/Variables/DefaultVariables.jl diff --git a/src/entities/AliasScalarSampling.jl b/IncrementalInference/src/entities/AliasScalarSampling.jl similarity index 100% rename from src/entities/AliasScalarSampling.jl rename to IncrementalInference/src/entities/AliasScalarSampling.jl diff --git a/src/entities/BeliefTypes.jl b/IncrementalInference/src/entities/BeliefTypes.jl similarity index 100% rename from src/entities/BeliefTypes.jl rename to IncrementalInference/src/entities/BeliefTypes.jl diff --git a/src/entities/CalcFactor.jl b/IncrementalInference/src/entities/CalcFactor.jl similarity index 100% rename from src/entities/CalcFactor.jl rename to IncrementalInference/src/entities/CalcFactor.jl diff --git a/src/entities/CliqueTypes.jl b/IncrementalInference/src/entities/CliqueTypes.jl similarity index 100% rename from src/entities/CliqueTypes.jl rename to IncrementalInference/src/entities/CliqueTypes.jl diff --git a/src/entities/ExtDensities.jl b/IncrementalInference/src/entities/ExtDensities.jl similarity index 100% rename from src/entities/ExtDensities.jl rename to IncrementalInference/src/entities/ExtDensities.jl diff --git a/src/entities/ExtFactors.jl b/IncrementalInference/src/entities/ExtFactors.jl similarity index 100% rename from src/entities/ExtFactors.jl rename to IncrementalInference/src/entities/ExtFactors.jl diff --git a/src/entities/FactorGradients.jl b/IncrementalInference/src/entities/FactorGradients.jl similarity index 100% rename from src/entities/FactorGradients.jl rename to IncrementalInference/src/entities/FactorGradients.jl diff --git a/src/entities/FactorOperationalMemory.jl b/IncrementalInference/src/entities/FactorOperationalMemory.jl similarity index 100% rename from src/entities/FactorOperationalMemory.jl rename to IncrementalInference/src/entities/FactorOperationalMemory.jl diff --git a/src/entities/HypoRecipe.jl b/IncrementalInference/src/entities/HypoRecipe.jl similarity index 100% rename from src/entities/HypoRecipe.jl rename to IncrementalInference/src/entities/HypoRecipe.jl diff --git a/src/entities/JunctionTreeTypes.jl b/IncrementalInference/src/entities/JunctionTreeTypes.jl similarity index 100% rename from src/entities/JunctionTreeTypes.jl rename to IncrementalInference/src/entities/JunctionTreeTypes.jl diff --git a/src/manifolds/services/ManifoldSampling.jl b/IncrementalInference/src/manifolds/services/ManifoldSampling.jl similarity index 100% rename from src/manifolds/services/ManifoldSampling.jl rename to IncrementalInference/src/manifolds/services/ManifoldSampling.jl diff --git a/src/manifolds/services/ManifoldsExtentions.jl b/IncrementalInference/src/manifolds/services/ManifoldsExtentions.jl similarity index 100% rename from src/manifolds/services/ManifoldsExtentions.jl rename to IncrementalInference/src/manifolds/services/ManifoldsExtentions.jl diff --git a/src/parametric/services/ConsolidateParametricRelatives.jl b/IncrementalInference/src/parametric/services/ConsolidateParametricRelatives.jl similarity index 100% rename from src/parametric/services/ConsolidateParametricRelatives.jl rename to IncrementalInference/src/parametric/services/ConsolidateParametricRelatives.jl diff --git a/src/parametric/services/ParametricCSMFunctions.jl b/IncrementalInference/src/parametric/services/ParametricCSMFunctions.jl similarity index 100% rename from src/parametric/services/ParametricCSMFunctions.jl rename to IncrementalInference/src/parametric/services/ParametricCSMFunctions.jl diff --git a/src/parametric/services/ParametricManopt.jl b/IncrementalInference/src/parametric/services/ParametricManopt.jl similarity index 100% rename from src/parametric/services/ParametricManopt.jl rename to IncrementalInference/src/parametric/services/ParametricManopt.jl diff --git a/src/parametric/services/ParametricOptim.jl b/IncrementalInference/src/parametric/services/ParametricOptim.jl similarity index 100% rename from src/parametric/services/ParametricOptim.jl rename to IncrementalInference/src/parametric/services/ParametricOptim.jl diff --git a/src/parametric/services/ParametricUtils.jl b/IncrementalInference/src/parametric/services/ParametricUtils.jl similarity index 100% rename from src/parametric/services/ParametricUtils.jl rename to IncrementalInference/src/parametric/services/ParametricUtils.jl diff --git a/src/services/AdditionalUtils.jl b/IncrementalInference/src/services/AdditionalUtils.jl similarity index 100% rename from src/services/AdditionalUtils.jl rename to IncrementalInference/src/services/AdditionalUtils.jl diff --git a/src/services/AnalysisTools.jl b/IncrementalInference/src/services/AnalysisTools.jl similarity index 100% rename from src/services/AnalysisTools.jl rename to IncrementalInference/src/services/AnalysisTools.jl diff --git a/src/services/ApproxConv.jl b/IncrementalInference/src/services/ApproxConv.jl similarity index 100% rename from src/services/ApproxConv.jl rename to IncrementalInference/src/services/ApproxConv.jl diff --git a/src/services/BayesNet.jl b/IncrementalInference/src/services/BayesNet.jl similarity index 100% rename from src/services/BayesNet.jl rename to IncrementalInference/src/services/BayesNet.jl diff --git a/src/services/CalcFactor.jl b/IncrementalInference/src/services/CalcFactor.jl similarity index 100% rename from src/services/CalcFactor.jl rename to IncrementalInference/src/services/CalcFactor.jl diff --git a/src/services/CanonicalGraphExamples.jl b/IncrementalInference/src/services/CanonicalGraphExamples.jl similarity index 100% rename from src/services/CanonicalGraphExamples.jl rename to IncrementalInference/src/services/CanonicalGraphExamples.jl diff --git a/src/services/CliqueTypes.jl b/IncrementalInference/src/services/CliqueTypes.jl similarity index 100% rename from src/services/CliqueTypes.jl rename to IncrementalInference/src/services/CliqueTypes.jl diff --git a/src/services/CompareUtils.jl b/IncrementalInference/src/services/CompareUtils.jl similarity index 100% rename from src/services/CompareUtils.jl rename to IncrementalInference/src/services/CompareUtils.jl diff --git a/src/services/DeconvUtils.jl b/IncrementalInference/src/services/DeconvUtils.jl similarity index 100% rename from src/services/DeconvUtils.jl rename to IncrementalInference/src/services/DeconvUtils.jl diff --git a/src/services/DefaultNodeTypes.jl b/IncrementalInference/src/services/DefaultNodeTypes.jl similarity index 100% rename from src/services/DefaultNodeTypes.jl rename to IncrementalInference/src/services/DefaultNodeTypes.jl diff --git a/src/services/EvalFactor.jl b/IncrementalInference/src/services/EvalFactor.jl similarity index 100% rename from src/services/EvalFactor.jl rename to IncrementalInference/src/services/EvalFactor.jl diff --git a/src/services/ExplicitDiscreteMarginalizations.jl b/IncrementalInference/src/services/ExplicitDiscreteMarginalizations.jl similarity index 100% rename from src/services/ExplicitDiscreteMarginalizations.jl rename to IncrementalInference/src/services/ExplicitDiscreteMarginalizations.jl diff --git a/src/services/FGOSUtils.jl b/IncrementalInference/src/services/FGOSUtils.jl similarity index 100% rename from src/services/FGOSUtils.jl rename to IncrementalInference/src/services/FGOSUtils.jl diff --git a/src/services/FactorGradients.jl b/IncrementalInference/src/services/FactorGradients.jl similarity index 100% rename from src/services/FactorGradients.jl rename to IncrementalInference/src/services/FactorGradients.jl diff --git a/src/services/FactorGraph.jl b/IncrementalInference/src/services/FactorGraph.jl similarity index 100% rename from src/services/FactorGraph.jl rename to IncrementalInference/src/services/FactorGraph.jl diff --git a/src/services/GraphInit.jl b/IncrementalInference/src/services/GraphInit.jl similarity index 100% rename from src/services/GraphInit.jl rename to IncrementalInference/src/services/GraphInit.jl diff --git a/src/services/GraphProductOperations.jl b/IncrementalInference/src/services/GraphProductOperations.jl similarity index 100% rename from src/services/GraphProductOperations.jl rename to IncrementalInference/src/services/GraphProductOperations.jl diff --git a/src/services/HypoRecipe.jl b/IncrementalInference/src/services/HypoRecipe.jl similarity index 100% rename from src/services/HypoRecipe.jl rename to IncrementalInference/src/services/HypoRecipe.jl diff --git a/src/services/JunctionTree.jl b/IncrementalInference/src/services/JunctionTree.jl similarity index 100% rename from src/services/JunctionTree.jl rename to IncrementalInference/src/services/JunctionTree.jl diff --git a/src/services/JunctionTreeUtils.jl b/IncrementalInference/src/services/JunctionTreeUtils.jl similarity index 100% rename from src/services/JunctionTreeUtils.jl rename to IncrementalInference/src/services/JunctionTreeUtils.jl diff --git a/src/services/MaxMixture.jl b/IncrementalInference/src/services/MaxMixture.jl similarity index 100% rename from src/services/MaxMixture.jl rename to IncrementalInference/src/services/MaxMixture.jl diff --git a/src/services/NumericalCalculations.jl b/IncrementalInference/src/services/NumericalCalculations.jl similarity index 100% rename from src/services/NumericalCalculations.jl rename to IncrementalInference/src/services/NumericalCalculations.jl diff --git a/src/services/SolveTree.jl b/IncrementalInference/src/services/SolveTree.jl similarity index 100% rename from src/services/SolveTree.jl rename to IncrementalInference/src/services/SolveTree.jl diff --git a/src/services/SolverAPI.jl b/IncrementalInference/src/services/SolverAPI.jl similarity index 100% rename from src/services/SolverAPI.jl rename to IncrementalInference/src/services/SolverAPI.jl diff --git a/src/services/SolverUtilities.jl b/IncrementalInference/src/services/SolverUtilities.jl similarity index 100% rename from src/services/SolverUtilities.jl rename to IncrementalInference/src/services/SolverUtilities.jl diff --git a/src/services/SubGraphFunctions.jl b/IncrementalInference/src/services/SubGraphFunctions.jl similarity index 100% rename from src/services/SubGraphFunctions.jl rename to IncrementalInference/src/services/SubGraphFunctions.jl diff --git a/src/services/TetherUtils.jl b/IncrementalInference/src/services/TetherUtils.jl similarity index 100% rename from src/services/TetherUtils.jl rename to IncrementalInference/src/services/TetherUtils.jl diff --git a/src/services/TreeBasedInitialization.jl b/IncrementalInference/src/services/TreeBasedInitialization.jl similarity index 100% rename from src/services/TreeBasedInitialization.jl rename to IncrementalInference/src/services/TreeBasedInitialization.jl diff --git a/src/services/TreeDebugTools.jl b/IncrementalInference/src/services/TreeDebugTools.jl similarity index 100% rename from src/services/TreeDebugTools.jl rename to IncrementalInference/src/services/TreeDebugTools.jl diff --git a/src/services/TreeMessageAccessors.jl b/IncrementalInference/src/services/TreeMessageAccessors.jl similarity index 100% rename from src/services/TreeMessageAccessors.jl rename to IncrementalInference/src/services/TreeMessageAccessors.jl diff --git a/src/services/TreeMessageUtils.jl b/IncrementalInference/src/services/TreeMessageUtils.jl similarity index 100% rename from src/services/TreeMessageUtils.jl rename to IncrementalInference/src/services/TreeMessageUtils.jl diff --git a/src/services/VariableStatistics.jl b/IncrementalInference/src/services/VariableStatistics.jl similarity index 100% rename from src/services/VariableStatistics.jl rename to IncrementalInference/src/services/VariableStatistics.jl diff --git a/test/TestCSMMultihypo.jl b/IncrementalInference/test/TestCSMMultihypo.jl similarity index 100% rename from test/TestCSMMultihypo.jl rename to IncrementalInference/test/TestCSMMultihypo.jl diff --git a/test/TestModuleFunctions.jl b/IncrementalInference/test/TestModuleFunctions.jl similarity index 100% rename from test/TestModuleFunctions.jl rename to IncrementalInference/test/TestModuleFunctions.jl diff --git a/test/basicGraphsOperations.jl b/IncrementalInference/test/basicGraphsOperations.jl similarity index 100% rename from test/basicGraphsOperations.jl rename to IncrementalInference/test/basicGraphsOperations.jl diff --git a/test/fourdoortest.jl b/IncrementalInference/test/fourdoortest.jl similarity index 100% rename from test/fourdoortest.jl rename to IncrementalInference/test/fourdoortest.jl diff --git a/test/manifolds/factordiff.jl b/IncrementalInference/test/manifolds/factordiff.jl similarity index 100% rename from test/manifolds/factordiff.jl rename to IncrementalInference/test/manifolds/factordiff.jl diff --git a/test/manifolds/manifolddiff.jl b/IncrementalInference/test/manifolds/manifolddiff.jl similarity index 100% rename from test/manifolds/manifolddiff.jl rename to IncrementalInference/test/manifolds/manifolddiff.jl diff --git a/test/priorusetest.jl b/IncrementalInference/test/priorusetest.jl similarity index 100% rename from test/priorusetest.jl rename to IncrementalInference/test/priorusetest.jl diff --git a/test/runtests.jl b/IncrementalInference/test/runtests.jl similarity index 100% rename from test/runtests.jl rename to IncrementalInference/test/runtests.jl diff --git a/test/saveconvertertypes.jl b/IncrementalInference/test/saveconvertertypes.jl similarity index 100% rename from test/saveconvertertypes.jl rename to IncrementalInference/test/saveconvertertypes.jl diff --git a/test/testAnalysisTools.jl b/IncrementalInference/test/testAnalysisTools.jl similarity index 100% rename from test/testAnalysisTools.jl rename to IncrementalInference/test/testAnalysisTools.jl diff --git a/test/testApproxConv.jl b/IncrementalInference/test/testApproxConv.jl similarity index 100% rename from test/testApproxConv.jl rename to IncrementalInference/test/testApproxConv.jl diff --git a/test/testBasicCSM.jl b/IncrementalInference/test/testBasicCSM.jl similarity index 100% rename from test/testBasicCSM.jl rename to IncrementalInference/test/testBasicCSM.jl diff --git a/test/testBasicForwardConvolve.jl b/IncrementalInference/test/testBasicForwardConvolve.jl similarity index 100% rename from test/testBasicForwardConvolve.jl rename to IncrementalInference/test/testBasicForwardConvolve.jl diff --git a/test/testBasicGraphs.jl b/IncrementalInference/test/testBasicGraphs.jl similarity index 100% rename from test/testBasicGraphs.jl rename to IncrementalInference/test/testBasicGraphs.jl diff --git a/test/testBasicManifolds.jl b/IncrementalInference/test/testBasicManifolds.jl similarity index 100% rename from test/testBasicManifolds.jl rename to IncrementalInference/test/testBasicManifolds.jl diff --git a/test/testBasicParametric.jl b/IncrementalInference/test/testBasicParametric.jl similarity index 100% rename from test/testBasicParametric.jl rename to IncrementalInference/test/testBasicParametric.jl diff --git a/test/testBasicRecycling.jl b/IncrementalInference/test/testBasicRecycling.jl similarity index 100% rename from test/testBasicRecycling.jl rename to IncrementalInference/test/testBasicRecycling.jl diff --git a/test/testBasicTreeInit.jl b/IncrementalInference/test/testBasicTreeInit.jl similarity index 100% rename from test/testBasicTreeInit.jl rename to IncrementalInference/test/testBasicTreeInit.jl diff --git a/test/testBayesTreeiSAM2Example.jl b/IncrementalInference/test/testBayesTreeiSAM2Example.jl similarity index 100% rename from test/testBayesTreeiSAM2Example.jl rename to IncrementalInference/test/testBayesTreeiSAM2Example.jl diff --git a/test/testCSMMonitor.jl b/IncrementalInference/test/testCSMMonitor.jl similarity index 100% rename from test/testCSMMonitor.jl rename to IncrementalInference/test/testCSMMonitor.jl diff --git a/test/testCalcFactorHypos.jl b/IncrementalInference/test/testCalcFactorHypos.jl similarity index 100% rename from test/testCalcFactorHypos.jl rename to IncrementalInference/test/testCalcFactorHypos.jl diff --git a/test/testCcolamdOrdering.jl b/IncrementalInference/test/testCcolamdOrdering.jl similarity index 100% rename from test/testCcolamdOrdering.jl rename to IncrementalInference/test/testCcolamdOrdering.jl diff --git a/test/testCircular.jl b/IncrementalInference/test/testCircular.jl similarity index 100% rename from test/testCircular.jl rename to IncrementalInference/test/testCircular.jl diff --git a/test/testCliqSolveDbgUtils.jl b/IncrementalInference/test/testCliqSolveDbgUtils.jl similarity index 100% rename from test/testCliqSolveDbgUtils.jl rename to IncrementalInference/test/testCliqSolveDbgUtils.jl diff --git a/test/testCliqueFactors.jl b/IncrementalInference/test/testCliqueFactors.jl similarity index 100% rename from test/testCliqueFactors.jl rename to IncrementalInference/test/testCliqueFactors.jl diff --git a/test/testCliqueTreesOrderings.jl b/IncrementalInference/test/testCliqueTreesOrderings.jl similarity index 100% rename from test/testCliqueTreesOrderings.jl rename to IncrementalInference/test/testCliqueTreesOrderings.jl diff --git a/test/testCommonConvWrapper.jl b/IncrementalInference/test/testCommonConvWrapper.jl similarity index 100% rename from test/testCommonConvWrapper.jl rename to IncrementalInference/test/testCommonConvWrapper.jl diff --git a/test/testCompareVariablesFactors.jl b/IncrementalInference/test/testCompareVariablesFactors.jl similarity index 100% rename from test/testCompareVariablesFactors.jl rename to IncrementalInference/test/testCompareVariablesFactors.jl diff --git a/test/testDERelative.jl b/IncrementalInference/test/testDERelative.jl similarity index 100% rename from test/testDERelative.jl rename to IncrementalInference/test/testDERelative.jl diff --git a/test/testDeadReckoningTether.jl b/IncrementalInference/test/testDeadReckoningTether.jl similarity index 100% rename from test/testDeadReckoningTether.jl rename to IncrementalInference/test/testDeadReckoningTether.jl diff --git a/test/testDefaultDeconv.jl b/IncrementalInference/test/testDefaultDeconv.jl similarity index 100% rename from test/testDefaultDeconv.jl rename to IncrementalInference/test/testDefaultDeconv.jl diff --git a/test/testDistributionsGeneric.jl b/IncrementalInference/test/testDistributionsGeneric.jl similarity index 100% rename from test/testDistributionsGeneric.jl rename to IncrementalInference/test/testDistributionsGeneric.jl diff --git a/test/testEuclidDistance.jl b/IncrementalInference/test/testEuclidDistance.jl similarity index 100% rename from test/testEuclidDistance.jl rename to IncrementalInference/test/testEuclidDistance.jl diff --git a/test/testExpXstroke.jl b/IncrementalInference/test/testExpXstroke.jl similarity index 100% rename from test/testExpXstroke.jl rename to IncrementalInference/test/testExpXstroke.jl diff --git a/test/testExplicitMultihypo.jl b/IncrementalInference/test/testExplicitMultihypo.jl similarity index 100% rename from test/testExplicitMultihypo.jl rename to IncrementalInference/test/testExplicitMultihypo.jl diff --git a/test/testFactorGradients.jl b/IncrementalInference/test/testFactorGradients.jl similarity index 100% rename from test/testFactorGradients.jl rename to IncrementalInference/test/testFactorGradients.jl diff --git a/test/testFluxModelsDistribution.jl b/IncrementalInference/test/testFluxModelsDistribution.jl similarity index 100% rename from test/testFluxModelsDistribution.jl rename to IncrementalInference/test/testFluxModelsDistribution.jl diff --git a/test/testGradientUtils.jl b/IncrementalInference/test/testGradientUtils.jl similarity index 100% rename from test/testGradientUtils.jl rename to IncrementalInference/test/testGradientUtils.jl diff --git a/test/testHasPriors913.jl b/IncrementalInference/test/testHasPriors913.jl similarity index 100% rename from test/testHasPriors913.jl rename to IncrementalInference/test/testHasPriors913.jl diff --git a/test/testHeatmapGridDensity.jl b/IncrementalInference/test/testHeatmapGridDensity.jl similarity index 100% rename from test/testHeatmapGridDensity.jl rename to IncrementalInference/test/testHeatmapGridDensity.jl diff --git a/test/testInitVariableOrder.jl b/IncrementalInference/test/testInitVariableOrder.jl similarity index 100% rename from test/testInitVariableOrder.jl rename to IncrementalInference/test/testInitVariableOrder.jl diff --git a/test/testJointEnforcement.jl b/IncrementalInference/test/testJointEnforcement.jl similarity index 100% rename from test/testJointEnforcement.jl rename to IncrementalInference/test/testJointEnforcement.jl diff --git a/test/testJunctionTreeConstruction.jl b/IncrementalInference/test/testJunctionTreeConstruction.jl similarity index 100% rename from test/testJunctionTreeConstruction.jl rename to IncrementalInference/test/testJunctionTreeConstruction.jl diff --git a/test/testManualInit.jl b/IncrementalInference/test/testManualInit.jl similarity index 100% rename from test/testManualInit.jl rename to IncrementalInference/test/testManualInit.jl diff --git a/test/testMixtureLinearConditional.jl b/IncrementalInference/test/testMixtureLinearConditional.jl similarity index 100% rename from test/testMixtureLinearConditional.jl rename to IncrementalInference/test/testMixtureLinearConditional.jl diff --git a/test/testMixtureParametric.jl b/IncrementalInference/test/testMixtureParametric.jl similarity index 100% rename from test/testMixtureParametric.jl rename to IncrementalInference/test/testMixtureParametric.jl diff --git a/test/testMixturePrior.jl b/IncrementalInference/test/testMixturePrior.jl similarity index 100% rename from test/testMixturePrior.jl rename to IncrementalInference/test/testMixturePrior.jl diff --git a/test/testMultiHypo3Door.jl b/IncrementalInference/test/testMultiHypo3Door.jl similarity index 100% rename from test/testMultiHypo3Door.jl rename to IncrementalInference/test/testMultiHypo3Door.jl diff --git a/test/testMultihypoAndChain.jl b/IncrementalInference/test/testMultihypoAndChain.jl similarity index 100% rename from test/testMultihypoAndChain.jl rename to IncrementalInference/test/testMultihypoAndChain.jl diff --git a/test/testMultimodal1D.jl b/IncrementalInference/test/testMultimodal1D.jl similarity index 100% rename from test/testMultimodal1D.jl rename to IncrementalInference/test/testMultimodal1D.jl diff --git a/test/testMultiprocess.jl b/IncrementalInference/test/testMultiprocess.jl similarity index 100% rename from test/testMultiprocess.jl rename to IncrementalInference/test/testMultiprocess.jl diff --git a/test/testMultithreaded.jl b/IncrementalInference/test/testMultithreaded.jl similarity index 100% rename from test/testMultithreaded.jl rename to IncrementalInference/test/testMultithreaded.jl diff --git a/test/testPackedDistributions.jl b/IncrementalInference/test/testPackedDistributions.jl similarity index 100% rename from test/testPackedDistributions.jl rename to IncrementalInference/test/testPackedDistributions.jl diff --git a/test/testPackingMixtures.jl b/IncrementalInference/test/testPackingMixtures.jl similarity index 100% rename from test/testPackingMixtures.jl rename to IncrementalInference/test/testPackingMixtures.jl diff --git a/test/testPartialFactors.jl b/IncrementalInference/test/testPartialFactors.jl similarity index 100% rename from test/testPartialFactors.jl rename to IncrementalInference/test/testPartialFactors.jl diff --git a/test/testPartialNH.jl b/IncrementalInference/test/testPartialNH.jl similarity index 100% rename from test/testPartialNH.jl rename to IncrementalInference/test/testPartialNH.jl diff --git a/test/testPartialPrior.jl b/IncrementalInference/test/testPartialPrior.jl similarity index 100% rename from test/testPartialPrior.jl rename to IncrementalInference/test/testPartialPrior.jl diff --git a/test/testProductReproducable.jl b/IncrementalInference/test/testProductReproducable.jl similarity index 100% rename from test/testProductReproducable.jl rename to IncrementalInference/test/testProductReproducable.jl diff --git a/test/testSaveLoadDFG.jl b/IncrementalInference/test/testSaveLoadDFG.jl similarity index 100% rename from test/testSaveLoadDFG.jl rename to IncrementalInference/test/testSaveLoadDFG.jl diff --git a/test/testSkipUpDown.jl b/IncrementalInference/test/testSkipUpDown.jl similarity index 100% rename from test/testSkipUpDown.jl rename to IncrementalInference/test/testSkipUpDown.jl diff --git a/test/testSolveKey.jl b/IncrementalInference/test/testSolveKey.jl similarity index 100% rename from test/testSolveKey.jl rename to IncrementalInference/test/testSolveKey.jl diff --git a/test/testSolveOrphanedFG.jl b/IncrementalInference/test/testSolveOrphanedFG.jl similarity index 100% rename from test/testSolveOrphanedFG.jl rename to IncrementalInference/test/testSolveOrphanedFG.jl diff --git a/test/testSolveSetPPE.jl b/IncrementalInference/test/testSolveSetPPE.jl similarity index 100% rename from test/testSolveSetPPE.jl rename to IncrementalInference/test/testSolveSetPPE.jl diff --git a/test/testSpecialEuclidean2Mani.jl b/IncrementalInference/test/testSpecialEuclidean2Mani.jl similarity index 100% rename from test/testSpecialEuclidean2Mani.jl rename to IncrementalInference/test/testSpecialEuclidean2Mani.jl diff --git a/test/testSpecialOrthogonalMani.jl b/IncrementalInference/test/testSpecialOrthogonalMani.jl similarity index 100% rename from test/testSpecialOrthogonalMani.jl rename to IncrementalInference/test/testSpecialOrthogonalMani.jl diff --git a/test/testSpecialSampler.jl b/IncrementalInference/test/testSpecialSampler.jl similarity index 100% rename from test/testSpecialSampler.jl rename to IncrementalInference/test/testSpecialSampler.jl diff --git a/test/testSphereMani.jl b/IncrementalInference/test/testSphereMani.jl similarity index 100% rename from test/testSphereMani.jl rename to IncrementalInference/test/testSphereMani.jl diff --git a/test/testStateMachine.jl b/IncrementalInference/test/testStateMachine.jl similarity index 100% rename from test/testStateMachine.jl rename to IncrementalInference/test/testStateMachine.jl diff --git a/test/testTexTreeIllustration.jl b/IncrementalInference/test/testTexTreeIllustration.jl similarity index 100% rename from test/testTexTreeIllustration.jl rename to IncrementalInference/test/testTexTreeIllustration.jl diff --git a/test/testTranslationMani.jl b/IncrementalInference/test/testTranslationMani.jl similarity index 100% rename from test/testTranslationMani.jl rename to IncrementalInference/test/testTranslationMani.jl diff --git a/test/testTreeFunctions.jl b/IncrementalInference/test/testTreeFunctions.jl similarity index 100% rename from test/testTreeFunctions.jl rename to IncrementalInference/test/testTreeFunctions.jl diff --git a/test/testTreeMessageUtils.jl b/IncrementalInference/test/testTreeMessageUtils.jl similarity index 100% rename from test/testTreeMessageUtils.jl rename to IncrementalInference/test/testTreeMessageUtils.jl diff --git a/test/testTreeSaveLoad.jl b/IncrementalInference/test/testTreeSaveLoad.jl similarity index 100% rename from test/testTreeSaveLoad.jl rename to IncrementalInference/test/testTreeSaveLoad.jl diff --git a/test/testUseMsgLikelihoods.jl b/IncrementalInference/test/testUseMsgLikelihoods.jl similarity index 100% rename from test/testUseMsgLikelihoods.jl rename to IncrementalInference/test/testUseMsgLikelihoods.jl diff --git a/test/testVariousNSolveSize.jl b/IncrementalInference/test/testVariousNSolveSize.jl similarity index 100% rename from test/testVariousNSolveSize.jl rename to IncrementalInference/test/testVariousNSolveSize.jl diff --git a/test/testgraphpackingconverters.jl b/IncrementalInference/test/testgraphpackingconverters.jl similarity index 100% rename from test/testgraphpackingconverters.jl rename to IncrementalInference/test/testgraphpackingconverters.jl diff --git a/test/testlocalconstraintexamples.jl b/IncrementalInference/test/testlocalconstraintexamples.jl similarity index 100% rename from test/testlocalconstraintexamples.jl rename to IncrementalInference/test/testlocalconstraintexamples.jl diff --git a/test/testmultihypothesisapi.jl b/IncrementalInference/test/testmultihypothesisapi.jl similarity index 100% rename from test/testmultihypothesisapi.jl rename to IncrementalInference/test/testmultihypothesisapi.jl diff --git a/test/testnullhypothesis.jl b/IncrementalInference/test/testnullhypothesis.jl similarity index 100% rename from test/testnullhypothesis.jl rename to IncrementalInference/test/testnullhypothesis.jl diff --git a/test/testpartialconstraint.jl b/IncrementalInference/test/testpartialconstraint.jl similarity index 100% rename from test/testpartialconstraint.jl rename to IncrementalInference/test/testpartialconstraint.jl diff --git a/test/tmp/.gitkeep b/IncrementalInference/test/tmp/.gitkeep similarity index 100% rename from test/tmp/.gitkeep rename to IncrementalInference/test/tmp/.gitkeep diff --git a/test/typeReturnMemRef.jl b/IncrementalInference/test/typeReturnMemRef.jl similarity index 100% rename from test/typeReturnMemRef.jl rename to IncrementalInference/test/typeReturnMemRef.jl From f027f411f9ecf702a52acb9e006cd24b70f99c9d Mon Sep 17 00:00:00 2001 From: Johannes Terblanche Date: Fri, 27 Jun 2025 16:30:05 +0200 Subject: [PATCH 3/3] revert LinearRelative and update CI --- .github/workflows/ci.yml | 132 +++++------------- .../src/Factors/LinearRelative.jl | 55 ++++++++ .../src/services/EvalFactor.jl | 2 +- .../test/basicGraphsOperations.jl | 2 +- IncrementalInference/test/testSolveKey.jl | 1 - IncrementalInferenceTypes/Project.toml | 6 +- .../src/IncrementalInferenceTypes.jl | 8 +- 7 files changed, 97 insertions(+), 109 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7eabc029..cfc77050 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -9,7 +9,7 @@ on: jobs: test-stable: - name: JL${{ matrix.version }} - ${{ matrix.arch }} - ${{ matrix.group }} - ${{ matrix.os }} + name: Stable JL-${{ matrix.version }} - ${{ matrix.group }} runs-on: ${{ matrix.os }} env: JULIA_PKG_SERVER: "" @@ -17,7 +17,7 @@ jobs: fail-fast: false matrix: version: - - '1.11' + - 'lts' os: - ubuntu-latest arch: @@ -26,17 +26,24 @@ jobs: - 'basic_functional_group' - 'test_cases_group' steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - uses: julia-actions/setup-julia@v2 with: version: ${{ matrix.version }} arch: ${{ matrix.arch }} - - uses: julia-actions/cache@v1 + - uses: julia-actions/cache@v2 - uses: julia-actions/julia-buildpkg@v1 - - uses: julia-actions/julia-runtest@v1 - continue-on-error: ${{ matrix.version == 'nightly' }} + - name: Dev dependencies + shell: julia --project=monorepo {0} + run: | + using Pkg; + Pkg.develop([PackageSpec(path="IncrementalInference"), PackageSpec(path="IncrementalInferenceTypes")]); + - name: Run tests + continue-on-error: ${{ matrix.group == 'tmp_debug_group' }} env: IIF_TEST_GROUP: ${{ matrix.group }} + run: > + julia --color=yes --project=monorepo -e 'using Pkg; Pkg.test("IncrementalInference")' - uses: julia-actions/julia-processcoverage@v1 - uses: codecov/codecov-action@v2 with: @@ -44,8 +51,8 @@ jobs: fail_ci_if_error: false if: ${{ matrix.version != 'nightly' }} - upstream-dev-functional: - name: Upstr Dev Functional + upstream-dev: + name: Develop JL-${{ matrix.version }} - ${{ matrix.group }} runs-on: ubuntu-latest env: JULIA_PKG_SERVER: "" @@ -55,105 +62,32 @@ jobs: arch: - x64 version: - - '~1.12.0-0' + - '1' group: - 'basic_functional_group' - steps: - - uses: actions/checkout@v2 - - uses: julia-actions/setup-julia@v2 - with: - version: ${{ matrix.version }} - arch: ${{ matrix.arch }} - - uses: actions/cache@v4 - env: - cache-name: cache-artifacts - with: - path: ~/.julia/artifacts - key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }} - restore-keys: | - ${{ runner.os }}-test-${{ env.cache-name }}- - ${{ runner.os }}-test- - ${{ runner.os }}- - - run: | - git config --global user.name Tester - git config --global user.email te@st.er - - name: Upst Dev Functional - env: - IIF_TEST_GROUP: ${{ matrix.group }} - run: | - julia --project=@. --check-bounds=yes -e 'using Pkg; Pkg.add(PackageSpec(name="ApproxManifoldProducts",rev="develop"));' - julia --project=@. --check-bounds=yes -e 'using Pkg; Pkg.add(PackageSpec(name="DistributedFactorGraphs",rev="develop"));' - julia --project=@. --check-bounds=yes -e 'using Pkg; Pkg.test("IncrementalInference"; coverage=false)' - shell: bash - - upstream-dev-cases: - name: Upstr Dev Test Cases - runs-on: ubuntu-latest - env: - JULIA_PKG_SERVER: "" - strategy: - fail-fast: false - matrix: - arch: - - x64 - version: - - '~1.12.0-0' - group: - 'test_cases_group' - steps: - - uses: actions/checkout@v2 - - uses: julia-actions/setup-julia@v2 - with: - version: ${{ matrix.version }} - arch: ${{ matrix.arch }} - - uses: actions/cache@v4 - env: - cache-name: cache-artifacts - with: - path: ~/.julia/artifacts - key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }} - restore-keys: | - ${{ runner.os }}-test-${{ env.cache-name }}- - ${{ runner.os }}-test- - ${{ runner.os }}- - - run: | - git config --global user.name Tester - git config --global user.email te@st.er - - name: Upstr Dev Cases - env: - IIF_TEST_GROUP: ${{ matrix.group }} - run: | - julia --project=@. --check-bounds=yes -e 'using Pkg; Pkg.add(PackageSpec(name="ApproxManifoldProducts",rev="develop"));' - julia --project=@. --check-bounds=yes -e 'using Pkg; Pkg.add(PackageSpec(name="DistributedFactorGraphs",rev="develop"));' - julia --project=@. --check-bounds=yes -e 'using Pkg; Pkg.test("IncrementalInference"; coverage=false)' - shell: bash - - test-debug-group: - needs: [ upstream-dev-functional ] - name: JL${{ matrix.version }} - ${{ matrix.group }} - ${{ matrix.os }} - runs-on: ${{ matrix.os }} - env: - JULIA_PKG_SERVER: "" - strategy: - fail-fast: false - matrix: - os: - - ubuntu-latest - version: - - '~1.12.0-0' - arch: - - x64 - group: - 'tmp_debug_group' - continue-on-error: true steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - uses: julia-actions/setup-julia@v2 with: version: ${{ matrix.version }} arch: ${{ matrix.arch }} - - uses: julia-actions/cache@v1 - - uses: julia-actions/julia-buildpkg@v1 - - uses: julia-actions/julia-runtest@v1 + - uses: julia-actions/cache@v2 + # - run: | + # git config --global user.name Tester + # git config --global user.email te@st.er + - name: Dev dependencies + shell: julia --project=monorepo {0} + run: | + using Pkg; + Pkg.add(PackageSpec(name="DistributedFactorGraphs",rev="develop")) + Pkg.add(PackageSpec(name="ApproxManifoldProducts",rev="develop")); + Pkg.develop([PackageSpec(path="IncrementalInference"), PackageSpec(path="IncrementalInferenceTypes")]); + - name: Run tests + continue-on-error: ${{ matrix.group == 'tmp_debug_group' }} env: IIF_TEST_GROUP: ${{ matrix.group }} + run: > + julia --color=yes --project=monorepo -e 'using Pkg; Pkg.test("IncrementalInference")' + \ No newline at end of file diff --git a/IncrementalInference/src/Factors/LinearRelative.jl b/IncrementalInference/src/Factors/LinearRelative.jl index d48c529b..ca1a46f8 100644 --- a/IncrementalInference/src/Factors/LinearRelative.jl +++ b/IncrementalInference/src/Factors/LinearRelative.jl @@ -1,6 +1,40 @@ export LinearRelative, PackedLinearRelative +""" +$(TYPEDEF) + +Default linear offset between two scalar variables. + +```math +X_2 = X_1 + η_Z +``` +""" +struct LinearRelative{N, T <: SamplableBelief} <: AbstractManifoldMinimize # AbstractRelativeMinimize + Z::T +end + +# need several helper constructors since the dimension over which LinearRelative will be used is unknown at this point +function LinearRelative{N}( + z0::T = MvNormal(zeros(N), diagm(ones(N))), +) where {N, T <: SamplableBelief} + # + return LinearRelative{N, T}(z0) +end + +function LinearRelative(::UniformScaling = LinearAlgebra.I) + return LinearRelative{1}(MvNormal(zeros(1), diagm(ones(1)))) +end +function LinearRelative(nm::Distributions.ContinuousUnivariateDistribution) + return LinearRelative{1, typeof(nm)}(nm) +end +LinearRelative(nm::MvNormal) = LinearRelative{length(nm.μ), typeof(nm)}(nm) +function LinearRelative(nm::Union{<:BallTreeDensity, <:ManifoldKernelDensity}) + return LinearRelative{Ndim(nm), typeof(nm)}(nm) +end + +getManifold(::InstanceType{LinearRelative{N}}) where {N} = getManifold(ContinuousEuclid{N}) + # TODO standardize getDimension(::InstanceType{LinearRelative{N}}) where {N} = N @@ -21,3 +55,24 @@ function Base.convert( return Manifolds.TranslationGroup(N) end +""" +$(TYPEDEF) +Serialization type for `LinearRelative` binary factor. +""" +Base.@kwdef mutable struct PackedLinearRelative <: AbstractPackedFactor + Z::PackedSamplableBelief +end +function convert(::Type{PackedLinearRelative}, d::LinearRelative) + return PackedLinearRelative(convert(PackedSamplableBelief, d.Z)) +end +function convert(::Type{LinearRelative}, d::PackedLinearRelative) + return LinearRelative(convert(SamplableBelief, d.Z)) +end +function DFG.pack(d::LinearRelative) + return PackedLinearRelative(DFG.packDistribution(d.Z)) +end +function DFG.unpack(d::PackedLinearRelative) + return LinearRelative(DFG.unpackDistribution(d.Z)) +end + +# \ No newline at end of file diff --git a/IncrementalInference/src/services/EvalFactor.jl b/IncrementalInference/src/services/EvalFactor.jl index 97f01e09..021d2c99 100644 --- a/IncrementalInference/src/services/EvalFactor.jl +++ b/IncrementalInference/src/services/EvalFactor.jl @@ -345,7 +345,7 @@ function evalPotentialSpecific( maxlen = _beforeSolveCCW!(ccwl, variables, sfidx, N; solveKey, needFreshMeasurements, measurement) # Check which variables have been initialized - isinit = map(x -> isInitialized(x), variables) + isinit = map(x -> isInitialized(x, solveKey), variables) # assemble how hypotheses should be computed # nullSurplus see #1517 diff --git a/IncrementalInference/test/basicGraphsOperations.jl b/IncrementalInference/test/basicGraphsOperations.jl index 457989ea..de8fef49 100644 --- a/IncrementalInference/test/basicGraphsOperations.jl +++ b/IncrementalInference/test/basicGraphsOperations.jl @@ -26,7 +26,7 @@ end ## pts = [randn(1) for _ in 1:100] -varT = LinearRelative{1} +varT = LinearRelative(Normal(1.0)) manikde!(varT, pts) diff --git a/IncrementalInference/test/testSolveKey.jl b/IncrementalInference/test/testSolveKey.jl index dd921645..72c759e0 100644 --- a/IncrementalInference/test/testSolveKey.jl +++ b/IncrementalInference/test/testSolveKey.jl @@ -32,7 +32,6 @@ IIF.setDefaultNodeData!(getVariable(fg, :a), 0, 100, 1, solveKey=:testSolveKey, initVariable!(fg, :a, pts, :testSolveKey) -@test !isInitialized(fg, :a) @test isInitialized(fg, :a, :testSolveKey) ## diff --git a/IncrementalInferenceTypes/Project.toml b/IncrementalInferenceTypes/Project.toml index 025be32b..c92eec9d 100644 --- a/IncrementalInferenceTypes/Project.toml +++ b/IncrementalInferenceTypes/Project.toml @@ -15,12 +15,12 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" [compat] -Dates = "1.11.0" -Distributed = "1.11.0" +Dates = "1.10.0" +Distributed = "1.10.0" DistributedFactorGraphs = "0.27.0" Distributions = "0.25.120" DocStringExtensions = "0.9.5" -Manifolds = "=0.10.16" +Manifolds = "0.10.16" RecursiveArrayTools = "3.33.0" StaticArrays = "1.9.13" StructTypes = "1.11.0" diff --git a/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl b/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl index 143d12ea..cf9092ae 100644 --- a/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl +++ b/IncrementalInferenceTypes/src/IncrementalInferenceTypes.jl @@ -20,14 +20,14 @@ export Position4, ContinuousScalar, ContinuousEuclid, - Ciruclar + Circular #export factor types export Prior, PackedPrior, - LinearRelative, - PackedLinearRelative, + # LinearRelative, + # PackedLinearRelative, CircularCircular, PriorCircular, PackedCircularCircular, @@ -56,7 +56,7 @@ include("variables/DefaultVariableTypes.jl") # Factor Definitions include("factors/DefaultPrior.jl") #FIXME maybe upgrade linear relative to this -include("factors/LinearRelative.jl") +# include("factors/LinearRelative.jl") include("factors/Circular.jl") # Distribution Serialization