update params and paramnames

Author: cscherrer

src/combinators/affine.jl

@@ -27,10 +27,17 @@ struct Affine{N,M,T} <: AbstractMeasure
     parent::M
 end
 
-params(::Type{A}, nt::NamedTuple{C}) where {A<:Affine{N,M}} where {N,M,C} = tuple(setdiff(union(N, params(M)),C)...)
+parent(d::Affine) = getfield(d, :parent)
 
+function params(μ::Affine)
+    nt1 = getfield(getfield(μ, :f), :par)
+    nt2 = params(parent(μ))
+    return merge(nt1, nt2)
+end
 
-parent(d::Affine) = getfield(d, :parent)
+function paramnames(::Type{A}) where {N,M, A<:Affine{N,M}}
+    tuple(union(N, paramnames(M))...)
+end
 
 Affine(nt::NamedTuple, μ::AbstractMeasure) = Affine(AffineTransform(nt), μ)
 

src/parameterized.jl

@@ -36,18 +36,36 @@ end
 
 (::Type{P})(;kwargs...) where {P <: ParameterizedMeasure} = P(NamedTuple(kwargs))
 
+function ConstructionBase.setproperties(d::P, nt::NamedTuple) where {P<:ParameterizedMeasure}
+    return constructorof(P)(merge(params(d), nt)) 
+end
+
+###############################################################################
+# params
+
 export params
 
-params(::Type{PM}) where {N, PM<:ParameterizedMeasure{N}} = N
+params(μ::ParameterizedMeasure) = getfield(μ, :par)
 
-function params(::Type{M}, constraints::NamedTuple{N2}) where {N1, N2, M<: ParameterizedMeasure{N1}} 
-    tuple((k for k in N1 if k ∉ N2)...)
+function params(μ::AbstractMeasure, constraints::NamedTuple{C}) where {N1, N2, M<: ParameterizedMeasure{N1}} 
+    NamedTuple{paramnames(μ, constraints)}(params(μ))
 end
 
+params(μ::AbstractMeasure) = NamedTuple()
 
-params(μ) = ()
+###############################################################################
+# paramnames
 
+export paramnames
 
-function ConstructionBase.setproperties(d::P, nt::NamedTuple) where {P<:ParameterizedMeasure}
-    return constructorof(P)(merge(params(d), nt)) 
+paramnames(μ) = paramnames(typeof(μ))
+
+paramnames(::Type{PM}) where {N, PM<:ParameterizedMeasure{N}} = N
+
+paramnames(μ::AbstractMeasure) = propertynames(μ)
+
+params(::Type{PM}) where {N, PM<:ParameterizedMeasure{N}} = N
+
+function paramnames(μ, constraints::NamedTuple{N}) where {N}
+    tuple((k for k in paramnames(μ) if k ∉ N)...)
 end