Setting values of triangular matrices also sets data above/below the diagonal

[penelopeysm]

Hello! I'm not entirely sure if this is really an Accessors issue, but calling Accessors.set on an upper / lower triangular matrix causes the values below / above the diagonal to be changed. I'm currently working around this by using a mutating optic as described in https://juliaobjects.github.io/Accessors.jl/stable/examples/custom_macros/, which doesn't have this issue.

julia> using Accessors, LinearAlgebra

julia> x = LowerTriangular(zeros(2, 2))
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 0.0   ⋅
 0.0  0.0

julia> x.data
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> x = Accessors.set(x, (@o _[1, 1]), 1.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 0.0  0.0

julia> x = Accessors.set(x, (@o _[2, 1]), 2.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 2.0  0.0

julia> x = Accessors.set(x, (@o _[2, 2]), 3.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 2.0  3.0

julia> x.data
2×2 Matrix{Float64}:
 1.0  5.129e160
 2.0  3.0

Even trying to manually set the value to zero doesn't work:

julia> x = Accessors.set(x, (@o _[1, 2]), 0.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 2.0  3.0

julia> x.data
2×2 Matrix{Float64}:
 1.0  2.17757e-314
 2.0  3.0

Version info:

(ppl) pkg> st
Status `~/ppl/Project.toml`
  [7d9f7c33] Accessors v0.1.42
  [37e2e46d] LinearAlgebra v1.11.0

julia> versioninfo()
Julia Version 1.11.5
Commit 760b2e5b739 (2025-04-14 06:53 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: macOS (arm64-apple-darwin24.0.0)
  CPU: 10 × Apple M1 Pro
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, apple-m1)
Threads: 1 default, 0 interactive, 1 GC (on 8 virtual cores)

[penelopeysm]

Oh, I can just set on the underlying data and that works fine. As it turns out, for my usecase (TuringLang/AbstractPPL.jl#125) I think it's easier to stick to the mutating optic (inserting an extra _.data would muddle the code) but feel free to close if this is 'intended' behaviour.

julia> x = LowerTriangular(zeros(2, 2))
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 0.0   ⋅
 0.0  0.0

julia> x = Accessors.set(x, (@o _.data[1, 1]), 1.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 0.0  0.0

julia> x.data
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  0.0

julia> x = Accessors.set(x, (@o _.data[2, 1]), 2.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 2.0  0.0

julia> x = Accessors.set(x, (@o _.data[2, 2]), 3.0)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅
 2.0  3.0

julia> x.data
2×2 Matrix{Float64}:
 1.0  0.0
 2.0  3.0

[aplavin]

Just to clarify: the issue is that the data field gets garbage in some cells, right? Even though this garbage doesn't affect actual behavior of the triangular matrix.

This is basically what Accessors does:

julia> using LinearAlgebra

julia> x = LowerTriangular(zeros(2, 2))
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 0.0   ⋅ 
 0.0  0.0

julia> y = similar(x)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
   1.7e-322   ⋅ 
 NaN         0.0

julia> copy!(y, x)
2×2 LowerTriangular{Float64, Matrix{Float64}}:
 0.0   ⋅ 
 0.0  0.0

julia> y.data
2×2 Matrix{Float64}:
 0.0  1.73e-322
 0.0  0.0

As you see, calling similar + copy results in garbage in data. I think this can be resolved either (a) by opening an issue/PR in Julia itself so that copy! between triangular matrices copied data completely, or (b) by proposing a better way to setindex an array in Accessors, to improve this function:

Accessors.jl/src/setindex.jl

Lines 7 to 16 in 18e9ddb

	Base.@propagate_inbounds function setindex(xs::AbstractArray, v, I_raw...)
	I = to_indices(xs, I_raw)
	T = promote_type(eltype(xs), I isa Tuple{Vararg{Integer}} ? typeof(v) : eltype(v))
	ys = similar(xs, T)
	if eltype(xs) !== Union{}
	copy!(ys, xs)
	end
	ys[I...] = v
	return ys
	end

[penelopeysm]

the issue is that the data field gets garbage in some cells, right?

Indeed.

Even though this garbage doesn't affect actual behavior of the triangular matrix.

Unfortunately the default equality comparison takes it into account. I could write a custom equality function of course.

calling similar + copy results in garbage in data

Thank you for the explanation! In this case my inclination is that it's a LinearAlgebra issue rather than Accessors. The core problem is that for triangular matrices copy!(y, similar(y)) != y. I don't know if that should always be equal, but it doesn't seem like an unreasonable thing to expect. That could be fixed either by changing the behaviour of copy!, or the behaviour of ==. What do you think?

[aplavin]

Oh, that's very weird behavior of equality ==! I'm pretty sure that == for triangular matrices should only take accessible elements into account.

[penelopeysm]

Yeah, that's what I thought. I'll file an issue on LinearAlgebra, feel free to close this one if you want 😊