Update for version 0.4.0 (#26)

* Update documentation for new feature

* apply blue formatting using vscode plugin with JuliaFormatter.jl

* Bump version to 0.4.0

Author: vankesteren

.JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "blue"

Project.toml

@@ -4,7 +4,7 @@ authors = [
     "Erik-Jan van Kesteren <[email protected]>",
     "James Alster <[email protected]>"
 ]
-version = "0.3.1"
+version = "0.4.0"
 
 [deps]
 

README.md

@@ -3,6 +3,7 @@
 [![CI](https://github.com/vankesteren/ProportionalFitting.jl/actions/workflows/CI.yml/badge.svg)](https://github.com/vankesteren/ProportionalFitting.jl/actions/workflows/CI.yml) 
 [![devdoc](https://img.shields.io/badge/docs-dev-blue.svg)](https://vankesteren.github.io/ProportionalFitting.jl/dev)
 [![stabledoc](https://img.shields.io/badge/docs-stable-blue.svg)](https://vankesteren.github.io/ProportionalFitting.jl/stable)
+[![Code Style: Blue](https://img.shields.io/badge/code%20style-blue-4495d1.svg)](https://github.com/JuliaDiff/BlueStyle)
 
 Multidimensional iterative proportional fitting in Julia. 
 

docs/make.jl

@@ -1,32 +1,31 @@
 using ProportionalFitting
 using Documenter
 
-DocMeta.setdocmeta!(ProportionalFitting, :DocTestSetup, :(using ProportionalFitting); recursive=true)
+DocMeta.setdocmeta!(
+    ProportionalFitting, :DocTestSetup, :(using ProportionalFitting); recursive=true
+)
 
-frmt =  Documenter.HTML(;
-    prettyurls = get(ENV, "CI", "false") == "true",
-    canonical = "https://vankesteren.github.io/ProportionalFitting.jl",
-    edit_link = "main",
-    assets = String[],
+frmt = Documenter.HTML(;
+    prettyurls=get(ENV, "CI", "false") == "true",
+    canonical="https://vankesteren.github.io/ProportionalFitting.jl",
+    edit_link="main",
+    assets=String[],
 )
 
 pgs = [
     "Home" => "index.md",
     "Examples" => "examples.md",
     "Benchmarks" => "benchmarks.md",
-    "Reference" => "reference.md"
+    "Reference" => "reference.md",
 ]
 
 makedocs(;
-    modules = [ProportionalFitting],
-    authors = "Erik-Jan van Kesteren",
-    repo = "https://github.com/vankesteren/ProportionalFitting.jl",
-    sitename = "ProportionalFitting.jl",
-    format = frmt,
-    pages = pgs,
+    modules=[ProportionalFitting],
+    authors="Erik-Jan van Kesteren",
+    repo="https://github.com/vankesteren/ProportionalFitting.jl",
+    sitename="ProportionalFitting.jl",
+    format=frmt,
+    pages=pgs,
 )
 
-deploydocs(;
-    repo = "github.com/vankesteren/ProportionalFitting.jl",
-    devbranch = "main",
-)
+deploydocs(; repo="github.com/vankesteren/ProportionalFitting.jl", devbranch="main")

docs/src/index.md

@@ -116,3 +116,38 @@ We then also use `ArrayMargins` to check whether the margins of this array are i
 ```@example ex
 ArrayMargins(Z, dimid)
 ```
+
+## Repeated margins
+
+With multidimensional margins, it is also possible to enter a single margin multiple times in different target margins. This is allowed as long as the margin totals match, and as long as no two target margins are about the exact same dimensions. For example:
+
+```@example ex
+# Create a 2×3×4 array with seed value 1
+initial_array = ones(2, 3, 4)
+
+# Specify target margins for dimensions 1 and 3
+tgt_13 = [
+    10.0 15.0 20.0 25.0;
+    30.0 35.0 40.0 45.0
+]
+
+# Specify target margins for dimensions 2 and 3
+tgt_23 = [
+    12.0 16.0 20.0 24.0;
+    18.0 22.0 26.0 30.0;
+    10.0 12.0 14.0 16.0
+]
+
+# dimension 3 occurs twice!
+target_dims = [[1, 3], [2, 3]]
+target_margins = [tgt_13, tgt_23]
+
+# at this point, the margins are checked for consistency
+AM = ArrayMargins(target_margins, target_dims)
+
+# We can run ipf with these duplicated margins
+AF = ipf(initial_array, AM)
+
+# check that the margins are as specified
+ArrayMargins(Array(AF), target_dims)
+```

src/ArrayFactors.jl

@@ -55,19 +55,23 @@ struct ArrayFactors{T}
     di::DimIndices
     size::Tuple
 
-    function ArrayFactors(af::Vector{<:AbstractArray{T}}, di::DimIndices) where T
+    function ArrayFactors(af::Vector{<:AbstractArray{T}}, di::DimIndices) where {T}
         # loop over arrays then dimensions to get size, checking for mismatches
         dimension_sizes = zeros(Int, ndims(di))
         for i in 1:length(af)
             for (j, d) in enumerate(di.idx[i])
                 new_size = size(af[i], j)
-                if dimension_sizes[d] == 0 
+                if dimension_sizes[d] == 0
                     dimension_sizes[d] = new_size
                     continue
                 end
                 # check
                 if dimension_sizes[d] != new_size
-                    throw(DimensionMismatch("Dimension sizes not equal for dimension $d: $(dimension_sizes[d]) and $new_size"))
+                    throw(
+                        DimensionMismatch(
+                            "Dimension sizes not equal for dimension $d: $(dimension_sizes[d]) and $new_size",
+                        ),
+                    )
                 end
             end
         end
@@ -79,7 +83,7 @@ end
 function ArrayFactors(af::Vector{<:AbstractArray}, di::DimIndices)
     AT = eltype(af)
     PT = promote_type(eltype.(af)...)
-    ArrayFactors(Vector{AT{PT}}(af), di)
+    return ArrayFactors(Vector{AT{PT}}(af), di)
 end
 
 # Constructor promoting vector to dimindices

src/ArrayMargins.jl

@@ -54,19 +54,23 @@ struct ArrayMargins{T}
     size::Tuple
 
     # loop to check dimension sizes
-    function ArrayMargins(am::Vector{<:AbstractArray{T}}, di::DimIndices) where T
+    function ArrayMargins(am::Vector{<:AbstractArray{T}}, di::DimIndices) where {T}
         # loop over arrays then dimensions to get size, checking for mismatches
         dimension_sizes = zeros(Int, ndims(di))
         for i in 1:length(am)
             for (j, d) in enumerate(di.idx[i])
                 new_size = size(am[i], j)
-                if dimension_sizes[d] == 0 
+                if dimension_sizes[d] == 0
                     dimension_sizes[d] = new_size
                     continue
                 end
                 # check
                 if dimension_sizes[d] != new_size
-                    throw(DimensionMismatch("Dimension sizes not equal for dimension $d: $(dimension_sizes[d]) and $new_size"))
+                    throw(
+                        DimensionMismatch(
+                            "Dimension sizes not equal for dimension $d: $(dimension_sizes[d]) and $new_size",
+                        ),
+                    )
                 end
             end
         end
@@ -78,7 +82,7 @@ end
 function ArrayMargins(am::Vector{<:AbstractArray}, di::DimIndices)
     AT = eltype(am)
     PT = promote_type(eltype.(am)...)
-    ArrayMargins(Vector{AT{PT}}(am), di)
+    return ArrayMargins(Vector{AT{PT}}(am), di)
 end
 
 # Constructor promoting vector to dimindices
@@ -91,14 +95,16 @@ ArrayMargins(am::Vector{<:AbstractArray}) = ArrayMargins(am, default_dimindices(
 function ArrayMargins(X::AbstractArray, di::DimIndices)
     D = ndims(X)
     if D != ndims(di)
-        throw(DimensionMismatch("Dimensions of X ($(ndims(X))) mismatch DI ($(ndims(di)))."))
+        throw(
+            DimensionMismatch("Dimensions of X ($(ndims(X))) mismatch DI ($(ndims(di))).")
+        )
     end
 
     # create the margins
     am = Vector{AbstractArray{eltype(X)}}()
     for dim in di.idx
         notd = Tuple(setdiff(1:D, dim))
-        mar = dropdims(sum(X; dims = notd); dims = notd)
+        mar = dropdims(sum(X; dims=notd); dims=notd)
         if !issorted(dim)
             mar = permutedims(mar, sortperm(sortperm(dim)))
         end
@@ -123,8 +129,7 @@ Base.length(AM::ArrayMargins) = length(AM.am)
 Base.ndims(AM::ArrayMargins) = length(AM.size)
 
 # method to align all arrays so each has dimindices 1:ndims(AM)
-function align_margins(AM::ArrayMargins{T})::Vector{Array{T}} where T
-    
+function align_margins(AM::ArrayMargins{T})::Vector{Array{T}} where {T}
     aligned_margins = Vector{Array{T}}()
 
     for i in 1:length(AM)
@@ -145,7 +150,7 @@ function align_margins(AM::ArrayMargins{T})::Vector{Array{T}} where T
 end
 
 # methods for consistency of margins
-function isconsistent(AM::ArrayMargins; tol::Float64 = eps(Float64))
+function isconsistent(AM::ArrayMargins; tol::Float64=eps(Float64))
     marsums = sum.(AM.am)
     return (maximum(marsums) - minimum(marsums)) < tol
 end
@@ -155,13 +160,16 @@ function proportion_transform(AM::ArrayMargins)
     return ArrayMargins(mar, AM.di)
 end
 
-function margin_totals_match(AM::ArrayMargins; tol::Float64 = eps(Float64))
+function margin_totals_match(AM::ArrayMargins; tol::Float64=eps(Float64))
 
     # get all shared subsets of dimensions
-    shared_subsets = vcat(
+    shared_subsets = unique(vcat(
         [[i] for i in 1:ndims(AM)], #Single dimensions
-        collect(intersect(AM.di.idx[[i,j]]...) for i in 1:length(AM.di.idx) for j in i+1:length(AM.di.idx)) #Shared subsets
-    ) |> unique
+        collect(
+            intersect(AM.di.idx[[i, j]]...) for i in 1:length(AM.di.idx) for
+            j in (i + 1):length(AM.di.idx)
+        ), #Shared subsets
+    ))
 
     # loop over these subsets, and check marginal totals are equal in every array margin where they appear
     aligned_margins = align_margins(AM)
@@ -171,10 +179,10 @@ function margin_totals_match(AM::ArrayMargins; tol::Float64 = eps(Float64))
         for i in 1:length(AM.am)
             if issubset(dd, AM.di.idx[i])
                 complement_dims = setdiff(1:ndims(AM), dd)
-                push!(margin_totals, sum(aligned_margins[i]; dims = complement_dims))
+                push!(margin_totals, sum(aligned_margins[i]; dims=complement_dims))
             end
         end
-        if !all(x -> isapprox(x, margin_totals[1]; atol = tol), margin_totals)
+        if !all(x -> isapprox(x, margin_totals[1]; atol=tol), margin_totals)
             @warn "Margin totals do not match across array margin(s): $dd"
             check = false
         end

src/DimIndices.jl

@@ -25,24 +25,24 @@ struct DimIndices
         # uniqueness between sets of indices 
         if !allunique(sort.(idx))
             error("Some sets of dimensions were duplicated, e.g. [[1,2], [2,1]].")
-        # uniqueness within sets of indices
+            # uniqueness within sets of indices
         elseif !all(allunique, idx)
             error("Some dimensions were duplicated within a set, e.g. [[2,1,2], [3]].")
         end
         # completeness
         D = maximum(maximum.(idx))
         dmissing = setdiff(1:D, vcat(idx...))
-        if length(dmissing) > 0 
+        if length(dmissing) > 0
             error("Missing array dimensions: $dmissing.")
         end
         return new(idx)
     end
 end
 
 # convenient constructor
-DimIndices(X::Vector) = DimIndices(Vector{Union{Int, Vector{Int}}}(X))
-function DimIndices(X::Vector{Union{Int, Vector{Int}}})
-    DimIndices(broadcast((x) -> [x...], X))
+DimIndices(X::Vector) = DimIndices(Vector{Union{Int,Vector{Int}}}(X))
+function DimIndices(X::Vector{Union{Int,Vector{Int}}})
+    return DimIndices(broadcast((x) -> [x...], X))
 end
 
 """
@@ -74,7 +74,7 @@ function default_dimindices(m::Vector{<:AbstractArray})
     j = 0
     dd = []
     for i in nd
-        push!(dd, collect((j+1):(j+i)))
+        push!(dd, collect((j + 1):(j + i)))
         j += i
     end
     return DimIndices(dd)
@@ -90,7 +90,9 @@ function Base.show(io::IO, DI::DimIndices)
     print("[")
     for i in 1:length(DI)
         show(io, DI.idx[i])
-        if i != length(DI) print(", ") end
+        if i != length(DI)
+            print(", ")
+        end
     end
-    print("]")
+    return print("]")
 end

src/ProportionalFitting.jl

@@ -1,15 +1,17 @@
 module ProportionalFitting
 
-export
-    DimIndices,
-    ArrayMargins, isconsistent, proportion_transform, align_arrays, margin_totals_match,
+export DimIndices,
+    ArrayMargins,
+    isconsistent,
+    proportion_transform,
+    align_arrays,
+    margin_totals_match,
     ArrayFactors,
     ipf
 
 include("DimIndices.jl")
 include("ArrayMargins.jl")
 include("ArrayFactors.jl")
-include("utils.jl")
 include("ipf.jl")
 
 end # module