From 3fad29b337a2ed006e07bf486fe35c0fa581218b Mon Sep 17 00:00:00 2001 From: mtfishman Date: Fri, 16 Jan 2026 13:11:24 -0500 Subject: [PATCH 1/3] Fix namespacing in derive macros --- Project.toml | 2 +- src/lazyarrays.jl | 260 +++++++++++++++++++++++----------------------- 2 files changed, 131 insertions(+), 131 deletions(-) diff --git a/Project.toml b/Project.toml index 76e0c66..427e6fa 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "TensorAlgebra" uuid = "68bd88dc-f39d-4e12-b2ca-f046b68fcc6a" authors = ["ITensor developers and contributors"] -version = "0.6.8" +version = "0.6.9" [deps] ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" diff --git a/src/lazyarrays.jl b/src/lazyarrays.jl index 7871c2a..68e7878 100644 --- a/src/lazyarrays.jl +++ b/src/lazyarrays.jl @@ -170,15 +170,15 @@ macro scaledarray_type(ScaledArray, AbstractArray = :AbstractArray) coeff::C parent::P function $ScaledArray(coeff::Number, a::AbstractArray) - T = TensorAlgebra.scaled_eltype(coeff, a) + T = $TensorAlgebra.scaled_eltype(coeff, a) return new{T, ndims(a), typeof(a), typeof(coeff)}(coeff, a) end end - TensorAlgebra.unscaled(a::$ScaledArray) = a.parent - TensorAlgebra.unscaled_type(arrayt::Type{<:$ScaledArray}) = + $TensorAlgebra.unscaled(a::$ScaledArray) = a.parent + $TensorAlgebra.unscaled_type(arrayt::Type{<:$ScaledArray}) = fieldtype(arrayt, :parent) - TensorAlgebra.coeff(a::$ScaledArray) = a.coeff - TensorAlgebra.coeff_type(arrayt::Type{<:$ScaledArray}) = + $TensorAlgebra.coeff(a::$ScaledArray) = a.coeff + $TensorAlgebra.coeff_type(arrayt::Type{<:$ScaledArray}) = fieldtype(arrayt, :coeff) end ) @@ -188,25 +188,25 @@ macro scaledarray_base(ScaledArray, AbstractArray = :AbstractArray) return esc( quote Base.axes(a::$ScaledArray) = - TensorAlgebra.axes_scaled(a) + $TensorAlgebra.axes_scaled(a) Base.size(a::$ScaledArray) = - TensorAlgebra.size_scaled(a) + $TensorAlgebra.size_scaled(a) Base.similar(a::$ScaledArray) = - TensorAlgebra.similar_scaled(a) + $TensorAlgebra.similar_scaled(a) Base.similar(a::$ScaledArray, elt::Type) = - TensorAlgebra.similar_scaled(a, elt) + $TensorAlgebra.similar_scaled(a, elt) Base.similar(a::$ScaledArray, ax) = - TensorAlgebra.similar_scaled(a, ax) + $TensorAlgebra.similar_scaled(a, ax) Base.similar(a::$ScaledArray, elt::Type, ax) = - TensorAlgebra.similar_scaled(a, elt, ax) + $TensorAlgebra.similar_scaled(a, elt, ax) Base.similar(a::$ScaledArray, elt::Type, ax::Dims) = - TensorAlgebra.similar_scaled(a, elt, ax) + $TensorAlgebra.similar_scaled(a, elt, ax) Base.copyto!(dest::$AbstractArray, src::$ScaledArray) = - TensorAlgebra.copyto!_scaled(dest, src) + $TensorAlgebra.copyto!_scaled(dest, src) Base.show(io::IO, a::$ScaledArray) = - TensorAlgebra.show_scaled(io, a) + $TensorAlgebra.show_scaled(io, a) Base.show(io::IO, mime::MIME"text/plain", a::$ScaledArray) = - TensorAlgebra.show_scaled(io, mime, a) + $TensorAlgebra.show_scaled(io, mime, a) end ) end @@ -215,9 +215,9 @@ macro scaledarray_broadcast(ScaledArray, AbstractArray = :AbstractArray) return esc( quote Base.Broadcast.materialize(a::$ScaledArray) = - TensorAlgebra.materialize_scaled(a) + $TensorAlgebra.materialize_scaled(a) Base.Broadcast.BroadcastStyle(arrayt::Type{<:$ScaledArray}) = - TensorAlgebra.BroadcastStyle_scaled(arrayt) + $TensorAlgebra.BroadcastStyle_scaled(arrayt) end ) end @@ -225,29 +225,29 @@ end macro scaledarray_linearalgebra(ScaledArray, AbstractArray = :AbstractArray) return esc( quote - function TensorAlgebra.LA.mul!( + function $TensorAlgebra.LA.mul!( dest::$AbstractArray{<:Any, 2}, a::$ScaledArray{<:Any, 2}, b::$ScaledArray{<:Any, 2}, α::Number, β::Number, ) - return TensorAlgebra.mul!_scaled(dest, a, b, α, β) + return $TensorAlgebra.mul!_scaled(dest, a, b, α, β) end - function TensorAlgebra.LA.mul!( + function $TensorAlgebra.LA.mul!( dest::$AbstractArray{<:Any, 2}, a::$AbstractArray{<:Any, 2}, b::$ScaledArray{<:Any, 2}, α::Number, β::Number, ) - return TensorAlgebra.mul!_scaled(dest, a, b, α, β) + return $TensorAlgebra.mul!_scaled(dest, a, b, α, β) end - function TensorAlgebra.LA.mul!( + function $TensorAlgebra.LA.mul!( dest::$AbstractArray{<:Any, 2}, a::$ScaledArray{<:Any, 2}, b::$AbstractArray{<:Any, 2}, α::Number, β::Number, ) - return TensorAlgebra.mul!_scaled(dest, a, b, α, β) + return $TensorAlgebra.mul!_scaled(dest, a, b, α, β) end end ) @@ -256,16 +256,16 @@ end macro scaledarray_lazy(ScaledArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.:(*ₗ)(α::Number, a::$ScaledArray) = - TensorAlgebra.mulled_scaled(α, a) - TensorAlgebra.:(*ₗ)(a::$ScaledArray, b::$ScaledArray) = - TensorAlgebra.mulled_scaled(a, b) - TensorAlgebra.:(*ₗ)(a::$AbstractArray, b::$ScaledArray) = - TensorAlgebra.mulled_scaled(a, b) - TensorAlgebra.:(*ₗ)(a::$ScaledArray, b::$AbstractArray) = - TensorAlgebra.mulled_scaled(a, b) - TensorAlgebra.conjed(a::$ScaledArray) = - TensorAlgebra.conjed_scaled(a) + $TensorAlgebra.:*ₗ(α::Number, a::$ScaledArray) = + $TensorAlgebra.mulled_scaled(α, a) + $TensorAlgebra.:*ₗ(a::$ScaledArray, b::$ScaledArray) = + $TensorAlgebra.mulled_scaled(a, b) + $TensorAlgebra.:*ₗ(a::$AbstractArray, b::$ScaledArray) = + $TensorAlgebra.mulled_scaled(a, b) + $TensorAlgebra.:*ₗ(a::$ScaledArray, b::$AbstractArray) = + $TensorAlgebra.mulled_scaled(a, b) + $TensorAlgebra.conjed(a::$ScaledArray) = + $TensorAlgebra.conjed_scaled(a) end ) end @@ -273,10 +273,10 @@ end macro scaledarray_tensoralgebra(ScaledArray, AbstractArray = :AbstractArray) return esc( quote - function TensorAlgebra.add!( + function $TensorAlgebra.add!( dest::$AbstractArray, src::$ScaledArray, α::Number, β::Number ) - return TensorAlgebra.add!_scaled(dest, src, α, β) + return $TensorAlgebra.add!_scaled(dest, src, α, β) end end ) @@ -285,9 +285,9 @@ end macro scaledarray_terminterface(ScaledArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.iscall(a::$ScaledArray) = TensorAlgebra.iscall_scaled(a) - TensorAlgebra.operation(a::$ScaledArray) = TensorAlgebra.operation_scaled(a) - TensorAlgebra.arguments(a::$ScaledArray) = TensorAlgebra.arguments_scaled(a) + $TensorAlgebra.iscall(a::$ScaledArray) = $TensorAlgebra.iscall_scaled(a) + $TensorAlgebra.operation(a::$ScaledArray) = $TensorAlgebra.operation_scaled(a) + $TensorAlgebra.arguments(a::$ScaledArray) = $TensorAlgebra.arguments_scaled(a) end ) end @@ -295,12 +295,12 @@ end macro scaledarray(ScaledArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.@scaledarray_base $ScaledArray $AbstractArray - TensorAlgebra.@scaledarray_broadcast $ScaledArray $AbstractArray - TensorAlgebra.@scaledarray_lazy $ScaledArray $AbstractArray - TensorAlgebra.@scaledarray_linearalgebra $ScaledArray $AbstractArray - TensorAlgebra.@scaledarray_tensoralgebra $ScaledArray $AbstractArray - TensorAlgebra.@scaledarray_terminterface $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_base $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_broadcast $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_lazy $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_linearalgebra $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_tensoralgebra $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_terminterface $ScaledArray $AbstractArray end ) end @@ -339,7 +339,7 @@ macro conjarray_type(ConjArray, AbstractArray = :AbstractArray) struct $ConjArray{T, N, P <: AbstractArray{T, N}} <: $AbstractArray{T, N} parent::P end - TensorAlgebra.conjed(a::$ConjArray) = a.parent + $TensorAlgebra.conjed(a::$ConjArray) = a.parent end ) end @@ -373,10 +373,10 @@ end macro conjarray_stridedviews(ConjArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.SV.isstrided(a::$ConjArray) = - TensorAlgebra.isstrided_conj(a) - TensorAlgebra.SV.StridedView(a::$ConjArray) = - TensorAlgebra.StridedView_conj(a) + $TensorAlgebra.SV.isstrided(a::$ConjArray) = + $TensorAlgebra.isstrided_conj(a) + $TensorAlgebra.SV.StridedView(a::$ConjArray) = + $TensorAlgebra.StridedView_conj(a) end ) end @@ -384,9 +384,9 @@ end macro conjarray_terminterface(ConjArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.iscall(a::$ConjArray) = TensorAlgebra.iscall_conj(a) - TensorAlgebra.operation(a::$ConjArray) = TensorAlgebra.operation_conj(a) - TensorAlgebra.arguments(a::$ConjArray) = TensorAlgebra.arguments_conj(a) + $TensorAlgebra.iscall(a::$ConjArray) = $TensorAlgebra.iscall_conj(a) + $TensorAlgebra.operation(a::$ConjArray) = $TensorAlgebra.operation_conj(a) + $TensorAlgebra.arguments(a::$ConjArray) = $TensorAlgebra.arguments_conj(a) end ) end @@ -394,10 +394,10 @@ end macro conjarray(ConjArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.@conjarray_base $ConjArray $AbstractArray - TensorAlgebra.@conjarray_broadcast $ConjArray $AbstractArray - TensorAlgebra.@conjarray_stridedviews $ConjArray $AbstractArray - TensorAlgebra.@conjarray_terminterface $ConjArray $AbstractArray + $TensorAlgebra.@conjarray_base $ConjArray $AbstractArray + $TensorAlgebra.@conjarray_broadcast $ConjArray $AbstractArray + $TensorAlgebra.@conjarray_stridedviews $ConjArray $AbstractArray + $TensorAlgebra.@conjarray_terminterface $ConjArray $AbstractArray end ) end @@ -462,13 +462,13 @@ macro addarray_type(AddArray, AbstractArray = :AbstractArray) $AbstractArray{T, N} args::Args function $AddArray(args::AbstractArray...) - T = TensorAlgebra.add_eltype(args...) - N = TensorAlgebra.add_ndims(args...) + T = $TensorAlgebra.add_eltype(args...) + N = $TensorAlgebra.add_ndims(args...) return new{T, N, typeof(args)}(args) end end - TensorAlgebra.addends(a::$AddArray) = a.args - TensorAlgebra.addends_type(arrayt::Type{<:$AddArray}) = + $TensorAlgebra.addends(a::$AddArray) = a.args + $TensorAlgebra.addends_type(arrayt::Type{<:$AddArray}) = fieldtype(arrayt, :args) end ) @@ -477,27 +477,27 @@ end macro addarray_base(AddArray, AbstractArray = :AbstractArray) return esc( quote - Base.axes(a::$AddArray) = TensorAlgebra.axes_add(a) - Base.size(a::$AddArray) = TensorAlgebra.size_add(a) - Base.similar(a::$AddArray) = TensorAlgebra.similar_add(a) - Base.similar(a::$AddArray, ax::Tuple) = TensorAlgebra.similar_add(a, ax) - Base.similar(a::$AddArray, elt::Type) = TensorAlgebra.similar_add(a, elt) + Base.axes(a::$AddArray) = $TensorAlgebra.axes_add(a) + Base.size(a::$AddArray) = $TensorAlgebra.size_add(a) + Base.similar(a::$AddArray) = $TensorAlgebra.similar_add(a) + Base.similar(a::$AddArray, ax::Tuple) = $TensorAlgebra.similar_add(a, ax) + Base.similar(a::$AddArray, elt::Type) = $TensorAlgebra.similar_add(a, elt) function Base.similar( a::$AddArray, elt::Type, ax::Tuple{Union{Integer, Base.OneTo}, Vararg{Union{Integer, Base.OneTo}}}, ) - return TensorAlgebra.similar_add(a, elt, ax) + return $TensorAlgebra.similar_add(a, elt, ax) end Base.similar(a::$AddArray, elt::Type, ax::Dims) = - TensorAlgebra.similar_add(a, elt, ax) + $TensorAlgebra.similar_add(a, elt, ax) Base.similar(a::$AddArray, elt::Type, ax) = - TensorAlgebra.similar_add(a, elt, ax) + $TensorAlgebra.similar_add(a, elt, ax) Base.copyto!(dest::$AbstractArray, src::$AddArray) = - TensorAlgebra.copyto!_add(dest, src) + $TensorAlgebra.copyto!_add(dest, src) Base.show(io::IO, a::$AddArray) = - TensorAlgebra.show_add(io, a) + $TensorAlgebra.show_add(io, a) Base.show(io::IO, mime::MIME"text/plain", a::$AddArray) = - TensorAlgebra.show_add(io, mime, a) + $TensorAlgebra.show_add(io, mime, a) end ) end @@ -505,9 +505,9 @@ end macro addarray_broadcast(AddArray, AbstractArray = :AbstractArray) return esc( quote - Base.Broadcast.materialize(a::$AddArray) = TensorAlgebra.materialize_add(a) + Base.Broadcast.materialize(a::$AddArray) = $TensorAlgebra.materialize_add(a) Base.Broadcast.BroadcastStyle(arrayt::Type{<:$AddArray}) = - TensorAlgebra.BroadcastStyle_add(arrayt) + $TensorAlgebra.BroadcastStyle_add(arrayt) end ) end @@ -515,22 +515,22 @@ end macro addarray_lazy(AddArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.:(+ₗ)(a::$AbstractArray, b::$AddArray) = - TensorAlgebra.added_add(a, b) - TensorAlgebra.:(+ₗ)(a::$AddArray, b::$AbstractArray) = - TensorAlgebra.added_add(a, b) - TensorAlgebra.:(+ₗ)(a::$AddArray, b::$AddArray) = - TensorAlgebra.added_add(a, b) - TensorAlgebra.:(*ₗ)(α::Number, a::$AddArray) = - TensorAlgebra.mulled_add(α, a) - TensorAlgebra.:(*ₗ)(a::$AbstractArray, b::$AddArray) = - TensorAlgebra.mulled_add(a, b) - TensorAlgebra.:(*ₗ)(a::$AddArray, b::$AbstractArray) = - TensorAlgebra.mulled_add(a, b) - TensorAlgebra.:(*ₗ)(a::$AddArray, b::$AddArray) = - TensorAlgebra.mulled_add(a, b) - TensorAlgebra.conjed(a::$AddArray) = - TensorAlgebra.conjed_add(a) + $TensorAlgebra.:+ₗ(a::$AbstractArray, b::$AddArray) = + $TensorAlgebra.added_add(a, b) + $TensorAlgebra.:+ₗ(a::$AddArray, b::$AbstractArray) = + $TensorAlgebra.added_add(a, b) + $TensorAlgebra.:+ₗ(a::$AddArray, b::$AddArray) = + $TensorAlgebra.added_add(a, b) + $TensorAlgebra.:*ₗ(α::Number, a::$AddArray) = + $TensorAlgebra.mulled_add(α, a) + $TensorAlgebra.:*ₗ(a::$AbstractArray, b::$AddArray) = + $TensorAlgebra.mulled_add(a, b) + $TensorAlgebra.:*ₗ(a::$AddArray, b::$AbstractArray) = + $TensorAlgebra.mulled_add(a, b) + $TensorAlgebra.:*ₗ(a::$AddArray, b::$AddArray) = + $TensorAlgebra.mulled_add(a, b) + $TensorAlgebra.conjed(a::$AddArray) = + $TensorAlgebra.conjed_add(a) end ) end @@ -538,10 +538,10 @@ end macro addarray_tensoralgebra(AddArray, AbstractArray = :AbstractArray) return esc( quote - function TensorAlgebra.add!( + function $TensorAlgebra.add!( dest::$AbstractArray, src::$AddArray, α::Number, β::Number ) - return TensorAlgebra.add!_add(dest, src, α, β) + return $TensorAlgebra.add!_add(dest, src, α, β) end end ) @@ -550,9 +550,9 @@ end macro addarray_terminterface(AddArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.iscall(a::$AddArray) = TensorAlgebra.iscall_add(a) - TensorAlgebra.operation(a::$AddArray) = TensorAlgebra.operation_add(a) - TensorAlgebra.arguments(a::$AddArray) = TensorAlgebra.arguments_add(a) + $TensorAlgebra.iscall(a::$AddArray) = $TensorAlgebra.iscall_add(a) + $TensorAlgebra.operation(a::$AddArray) = $TensorAlgebra.operation_add(a) + $TensorAlgebra.arguments(a::$AddArray) = $TensorAlgebra.arguments_add(a) end ) end @@ -560,11 +560,11 @@ end macro addarray(AddArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.@addarray_base $AddArray $AbstractArray - TensorAlgebra.@addarray_broadcast $AddArray $AbstractArray - TensorAlgebra.@addarray_lazy $AddArray $AbstractArray - TensorAlgebra.@addarray_tensoralgebra $AddArray $AbstractArray - TensorAlgebra.@addarray_terminterface $AddArray $AbstractArray + $TensorAlgebra.@addarray_base $AddArray $AbstractArray + $TensorAlgebra.@addarray_broadcast $AddArray $AbstractArray + $TensorAlgebra.@addarray_lazy $AddArray $AbstractArray + $TensorAlgebra.@addarray_tensoralgebra $AddArray $AbstractArray + $TensorAlgebra.@addarray_terminterface $AddArray $AbstractArray end ) end @@ -628,13 +628,13 @@ macro mularray_type(MulArray, AbstractArray = :AbstractArray) a::A b::B function $MulArray(a::AbstractArray, b::AbstractArray) - T = TensorAlgebra.mul_eltype(a, b) - N = TensorAlgebra.mul_ndims(a, b) + T = $TensorAlgebra.mul_eltype(a, b) + N = $TensorAlgebra.mul_ndims(a, b) return new{T, N, typeof(a), typeof(b)}(a, b) end end - TensorAlgebra.factors(a::$MulArray) = (a.a, a.b) - TensorAlgebra.factor_types(arrayt::Type{<:$MulArray}) = + $TensorAlgebra.factors(a::$MulArray) = (a.a, a.b) + $TensorAlgebra.factor_types(arrayt::Type{<:$MulArray}) = (fieldtype(arrayt, :a), fieldtype(arrayt, :b)) end ) @@ -643,25 +643,25 @@ end macro mularray_base(MulArray, AbstractArray = :AbstractArray) return esc( quote - Base.eltype(a::$MulArray) = TensorAlgebra.eltype_mul(a) - Base.axes(a::$MulArray) = TensorAlgebra.axes_mul(a) - Base.size(a::$MulArray) = TensorAlgebra.size_mul(a) - Base.similar(a::$MulArray) = TensorAlgebra.similar_mul(a) - Base.similar(a::$MulArray, ax::Tuple) = TensorAlgebra.similar_mul(a, ax) - Base.similar(a::$MulArray, elt::Type) = TensorAlgebra.similar_mul(a, elt) + Base.eltype(a::$MulArray) = $TensorAlgebra.eltype_mul(a) + Base.axes(a::$MulArray) = $TensorAlgebra.axes_mul(a) + Base.size(a::$MulArray) = $TensorAlgebra.size_mul(a) + Base.similar(a::$MulArray) = $TensorAlgebra.similar_mul(a) + Base.similar(a::$MulArray, ax::Tuple) = $TensorAlgebra.similar_mul(a, ax) + Base.similar(a::$MulArray, elt::Type) = $TensorAlgebra.similar_mul(a, elt) Base.similar( a::$MulArray, elt::Type, ax::Tuple{Union{Integer, Base.OneTo}, Vararg{Union{Integer, Base.OneTo}}}, - ) = TensorAlgebra.similar_mul(a, elt, ax) + ) = $TensorAlgebra.similar_mul(a, elt, ax) Base.similar(a::$MulArray, elt::Type, ax) = - TensorAlgebra.similar_mul(a, elt, ax) + $TensorAlgebra.similar_mul(a, elt, ax) Base.similar(a::$MulArray, elt::Type, ax::Dims) = - TensorAlgebra.similar_mul(a, elt, ax) + $TensorAlgebra.similar_mul(a, elt, ax) Base.copyto!(dest::$AbstractArray, src::$MulArray) = - TensorAlgebra.copyto!_mul(dest, src) - Base.show(io::IO, a::$MulArray) = TensorAlgebra.show_mul(io, a) + $TensorAlgebra.copyto!_mul(dest, src) + Base.show(io::IO, a::$MulArray) = $TensorAlgebra.show_mul(io, a) Base.show(io::IO, mime::MIME"text/plain", a::$MulArray) = - TensorAlgebra.show_mul(io, mime, a) + $TensorAlgebra.show_mul(io, mime, a) end ) end @@ -669,9 +669,9 @@ end macro mularray_broadcast(MulArray, AbstractArray = :AbstractArray) return esc( quote - Base.Broadcast.materialize(a::$MulArray) = TensorAlgebra.materialize_mul(a) + Base.Broadcast.materialize(a::$MulArray) = $TensorAlgebra.materialize_mul(a) Base.Broadcast.BroadcastStyle(arrayt::Type{<:$MulArray}) = - TensorAlgebra.BroadcastStyle_mul(arrayt) + $TensorAlgebra.BroadcastStyle_mul(arrayt) end ) end @@ -679,9 +679,9 @@ end macro mularray_lazy(MulArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.conjed(a::$MulArray) = TensorAlgebra.conjed_mul(a) - TensorAlgebra.to_broadcasted(a::$MulArray) = - TensorAlgebra.to_broadcasted_mul(a) + $TensorAlgebra.conjed(a::$MulArray) = $TensorAlgebra.conjed_mul(a) + $TensorAlgebra.to_broadcasted(a::$MulArray) = + $TensorAlgebra.to_broadcasted_mul(a) end ) end @@ -689,10 +689,10 @@ end macro mularray_tensoralgebra(MulArray, AbstractArray = :AbstractArray) return esc( quote - function TensorAlgebra.add!( + function $TensorAlgebra.add!( dest::$AbstractArray, src::$MulArray, α::Number, β::Number ) - return TensorAlgebra.add!_mul(dest, src, α, β) + return $TensorAlgebra.add!_mul(dest, src, α, β) end end ) @@ -701,9 +701,9 @@ end macro mularray_terminterface(MulArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.iscall(a::$MulArray) = TensorAlgebra.iscall_mul(a) - TensorAlgebra.operation(a::$MulArray) = TensorAlgebra.operation_mul(a) - TensorAlgebra.arguments(a::$MulArray) = TensorAlgebra.arguments_mul(a) + $TensorAlgebra.iscall(a::$MulArray) = $TensorAlgebra.iscall_mul(a) + $TensorAlgebra.operation(a::$MulArray) = $TensorAlgebra.operation_mul(a) + $TensorAlgebra.arguments(a::$MulArray) = $TensorAlgebra.arguments_mul(a) end ) end @@ -711,11 +711,11 @@ end macro mularray(MulArray, AbstractArray = :AbstractArray) return esc( quote - TensorAlgebra.@mularray_base $MulArray $AbstractArray - TensorAlgebra.@mularray_broadcast $MulArray $AbstractArray - TensorAlgebra.@mularray_lazy $MulArray $AbstractArray - TensorAlgebra.@mularray_tensoralgebra $MulArray $AbstractArray - TensorAlgebra.@mularray_terminterface $MulArray $AbstractArray + $TensorAlgebra.@mularray_base $MulArray $AbstractArray + $TensorAlgebra.@mularray_broadcast $MulArray $AbstractArray + $TensorAlgebra.@mularray_lazy $MulArray $AbstractArray + $TensorAlgebra.@mularray_tensoralgebra $MulArray $AbstractArray + $TensorAlgebra.@mularray_terminterface $MulArray $AbstractArray end ) end From b5f77496f332af38db36a35e2f3c16b5f1bdbd03 Mon Sep 17 00:00:00 2001 From: mtfishman Date: Fri, 16 Jan 2026 14:06:24 -0500 Subject: [PATCH 2/3] Macro hygiene --- src/lazyarrays.jl | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/src/lazyarrays.jl b/src/lazyarrays.jl index 68e7878..29cb405 100644 --- a/src/lazyarrays.jl +++ b/src/lazyarrays.jl @@ -347,15 +347,21 @@ end macro conjarray_base(ConjArray, AbstractArray = :AbstractArray) return esc( quote - Base.axes(a::$ConjArray) = axes_conj(a) - Base.size(a::$ConjArray) = size_conj(a) - Base.similar(a::$ConjArray, elt::Type) = similar_conj(a, elt) - Base.similar(a::$ConjArray, elt::Type, ax) = similar_conj(a, elt, ax) - Base.similar(a::$ConjArray, elt::Type, ax::Dims) = similar_conj(a, elt, ax) - Base.copyto!(dest::$AbstractArray, src::$ConjArray) = copyto!_conj(dest, src) - Base.show(io::IO, a::$ConjArray) = show_conj(io, a) + Base.axes(a::$ConjArray) = + $TensorAlgebra.axes_conj(a) + Base.size(a::$ConjArray) = + $TensorAlgebra.size_conj(a) + Base.similar(a::$ConjArray, elt::Type) = + $TensorAlgebra.similar_conj(a, elt) + Base.similar(a::$ConjArray, elt::Type, ax) = + $TensorAlgebra.similar_conj(a, elt, ax) + Base.similar(a::$ConjArray, elt::Type, ax::Dims) = + $TensorAlgebra.similar_conj(a, elt, ax) + Base.copyto!(dest::$AbstractArray, src::$ConjArray) = + $TensorAlgebra.copyto!_conj(dest, src) + Base.show(io::IO, a::$ConjArray) = $TensorAlgebra.show_conj(io, a) Base.show(io::IO, mime::MIME"text/plain", a::$ConjArray) = - show_conj(io, mime, a) + $TensorAlgebra.show_conj(io, mime, a) end ) end @@ -363,9 +369,9 @@ end macro conjarray_broadcast(ConjArray, AbstractArray = :AbstractArray) return esc( quote - Base.Broadcast.materialize(a::$ConjArray) = materialize_conj(a) + Base.Broadcast.materialize(a::$ConjArray) = $TensorAlgebra.materialize_conj(a) Base.Broadcast.BroadcastStyle(arrayt::Type{<:$ConjArray}) = - BroadcastStyle_conj(arrayt) + $TensorAlgebra.BroadcastStyle_conj(arrayt) end ) end From c1d24f4b5db347698d6e1b684d3aff31c361dfe2 Mon Sep 17 00:00:00 2001 From: mtfishman Date: Fri, 16 Jan 2026 15:57:46 -0500 Subject: [PATCH 3/3] permuteddims, adjoint, transpose --- src/lazyarrays.jl | 112 +++++++++++++++++++++++++++++++++++++++++++++- test/Project.toml | 2 + test/test_lazy.jl | 111 +++++++++++++++++++++++++++++++++++---------- 3 files changed, 200 insertions(+), 25 deletions(-) diff --git a/src/lazyarrays.jl b/src/lazyarrays.jl index 29cb405..5bdc6d8 100644 --- a/src/lazyarrays.jl +++ b/src/lazyarrays.jl @@ -1,4 +1,5 @@ import Base.Broadcast as BC +import FunctionImplementations as FI import LinearAlgebra as LA import StridedViews as SV @@ -138,6 +139,10 @@ copyto!_scaled(dest::AbstractArray, src::AbstractArray) = add!(dest, src, true, show_scaled(io::IO, a::AbstractArray) = show_lazy(io, a) show_scaled(io::IO, mime::MIME"text/plain", a::AbstractArray) = show_lazy(io, mime, a) +# Base overloads of adjoint and transpose for ScaledArrays. +adjoint_scaled(a::AbstractArray) = coeff(a) *ₗ adjoint(unscaled(a)) +transpose_scaled(a::AbstractArray) = coeff(a) *ₗ transpose(unscaled(a)) + # Base.Broadcast overloads for ScaledArrays. materialize_scaled(a::AbstractArray) = copy(a) BroadcastStyle_scaled(arrayt::Type{<:AbstractArray}) = @@ -162,6 +167,9 @@ iscall_scaled(::AbstractArray) = true operation_scaled(::AbstractArray) = * arguments_scaled(a::AbstractArray) = (coeff(a), unscaled(a)) +# FunctionImplementations overloads for ScaledArrays. +permuteddims_scaled(a::AbstractArray, perm) = coeff(a) *ₗ FI.permuteddims(unscaled(a), perm) + macro scaledarray_type(ScaledArray, AbstractArray = :AbstractArray) return esc( quote @@ -197,6 +205,8 @@ macro scaledarray_base(ScaledArray, AbstractArray = :AbstractArray) $TensorAlgebra.similar_scaled(a, elt) Base.similar(a::$ScaledArray, ax) = $TensorAlgebra.similar_scaled(a, ax) + Base.similar(a::$ScaledArray, ax::Tuple) = + $TensorAlgebra.similar_scaled(a, ax) Base.similar(a::$ScaledArray, elt::Type, ax) = $TensorAlgebra.similar_scaled(a, elt, ax) Base.similar(a::$ScaledArray, elt::Type, ax::Dims) = @@ -211,6 +221,17 @@ macro scaledarray_base(ScaledArray, AbstractArray = :AbstractArray) ) end +macro scaledarray_adjtrans(ScaledArray, AbstractArray = :AbstractArray) + return esc( + quote + Base.adjoint(a::$ScaledArray) = + $TensorAlgebra.adjoint_scaled(a) + Base.transpose(a::$ScaledArray) = + $TensorAlgebra.transpose_scaled(a) + end + ) +end + macro scaledarray_broadcast(ScaledArray, AbstractArray = :AbstractArray) return esc( quote @@ -292,22 +313,33 @@ macro scaledarray_terminterface(ScaledArray, AbstractArray = :AbstractArray) ) end +macro scaledarray_functionimplementations(ScaledArray, AbstractArray = :AbstractArray) + return esc( + quote + $TensorAlgebra.FI.permuteddims(a::$ScaledArray, perm) = + $TensorAlgebra.permuteddims_scaled(a, perm) + end + ) +end + macro scaledarray(ScaledArray, AbstractArray = :AbstractArray) return esc( quote $TensorAlgebra.@scaledarray_base $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_adjtrans $ScaledArray $AbstractArray $TensorAlgebra.@scaledarray_broadcast $ScaledArray $AbstractArray $TensorAlgebra.@scaledarray_lazy $ScaledArray $AbstractArray $TensorAlgebra.@scaledarray_linearalgebra $ScaledArray $AbstractArray $TensorAlgebra.@scaledarray_tensoralgebra $ScaledArray $AbstractArray $TensorAlgebra.@scaledarray_terminterface $ScaledArray $AbstractArray + $TensorAlgebra.@scaledarray_functionimplementations $ScaledArray $AbstractArray end ) end # Generic constructors for ConjArrays. conjed(a::AbstractArray) = ConjArray(a) -conjed_type(arrayt::Type{<:AbstractArray}) = Base.promote_op(conj, arrayt) +conjed_type(arrayt::Type{<:AbstractArray}) = Base.promote_op(conjed, arrayt) # Base overloads for ConjArrays. axes_conj(a::AbstractArray) = axes(conjed(a)) @@ -319,6 +351,10 @@ copyto!_conj(dest::AbstractArray, src::AbstractArray) = add!(dest, src, true, fa show_conj(io::IO, a::AbstractArray) = show_lazy(io, a) show_conj(io::IO, mime::MIME"text/plain", a::AbstractArray) = show_lazy(io, mime, a) +# Base overloads of adjoint and transpose for ConjArrays. +adjoint_conj(a::AbstractArray) = transpose(conjed(a)) +transpose_conj(a::AbstractArray) = adjoint(conjed(a)) + # Base.Broadcast overloads for ConjArrays. materialize_conj(a::AbstractArray) = copy(a) BroadcastStyle_conj(arrayt::Type{<:AbstractArray}) = @@ -333,6 +369,9 @@ iscall_conj(::AbstractArray) = true operation_conj(::AbstractArray) = conj arguments_conj(a::AbstractArray) = (conjed(a),) +# FunctionImplementations overloads for ConjArrays. +permuteddims_conj(a::AbstractArray, perm) = conjed(FI.permuteddims(conjed(a), perm)) + macro conjarray_type(ConjArray, AbstractArray = :AbstractArray) return esc( quote @@ -366,6 +405,17 @@ macro conjarray_base(ConjArray, AbstractArray = :AbstractArray) ) end +macro conjarray_adjtrans(ConjArray, AbstractArray = :AbstractArray) + return esc( + quote + Base.adjoint(a::$ConjArray) = + $TensorAlgebra.adjoint_conj(a) + Base.transpose(a::$ConjArray) = + $TensorAlgebra.transpose_conj(a) + end + ) +end + macro conjarray_broadcast(ConjArray, AbstractArray = :AbstractArray) return esc( quote @@ -397,13 +447,24 @@ macro conjarray_terminterface(ConjArray, AbstractArray = :AbstractArray) ) end +macro conjarray_functionimplementations(ConjArray, AbstractArray = :AbstractArray) + return esc( + quote + $TensorAlgebra.FI.permuteddims(a::$ConjArray, perm) = + $TensorAlgebra.permuteddims_conj(a, perm) + end + ) +end + macro conjarray(ConjArray, AbstractArray = :AbstractArray) return esc( quote $TensorAlgebra.@conjarray_base $ConjArray $AbstractArray + $TensorAlgebra.@conjarray_adjtrans $ConjArray $AbstractArray $TensorAlgebra.@conjarray_broadcast $ConjArray $AbstractArray $TensorAlgebra.@conjarray_stridedviews $ConjArray $AbstractArray $TensorAlgebra.@conjarray_terminterface $ConjArray $AbstractArray + $TensorAlgebra.@conjarray_functionimplementations $ConjArray $AbstractArray end ) end @@ -429,6 +490,10 @@ copyto!_add(dest::AbstractArray, src::AbstractArray) = add!(dest, src, true, fal show_add(io::IO, a::AbstractArray) = show_lazy(io, a) show_add(io::IO, mime::MIME"text/plain", a::AbstractArray) = show_lazy(io, mime, a) +# Base overloads of adjoint and transpose for AddArrays. +adjoint_add(a::AbstractArray) = +ₗ(adjoint.(addends(a))...) +transpose_add(a::AbstractArray) = +ₗ(transpose.(addends(a))...) + # Base.Broadcast overloads for AddArrays. materialize_add(a::AbstractArray) = copy(a) function BroadcastStyle_add(arrayt::Type{<:AbstractArray}) @@ -450,7 +515,8 @@ end # Lazy operations for AddArrays. added_add(a::AbstractArray, b::AbstractArray) = AddArray((addends(a)..., addends(b)...)...) mulled_add(α::Number, a::AbstractArray) = +ₗ((α .*ₗ addends(a))...) -## TODO: Define these by expanding all combinations treating both inputs as AddArrays. +## TODO: Define multiplication of added arrays by expanding all combinations, treating +## both inputs as AddArrays. ## mulled_add(a::AbstractArray, b::AbstractArray) = +ₗ((Ref(a) .*ₗ addends(b))...) ## mulled_add(a::AddArray, b::AbstractArray) = +ₗ((addends(a) .*ₗ Ref(b))...) ## mulled_add(a::AddArray, b::AddArray) = +ₗ((Ref(a) .*ₗ addends(b))...) @@ -461,6 +527,10 @@ iscall_add(::AbstractArray) = true operation_add(::AbstractArray) = + arguments_add(a::AbstractArray) = addends(a) +# FunctionImplementations overloads for AddArrays. +permuteddims_add(a::AbstractArray, perm) = + +ₗ(Base.Fix2(FI.permuteddims, perm).(addends(a))...) + macro addarray_type(AddArray, AbstractArray = :AbstractArray) return esc( quote @@ -508,6 +578,17 @@ macro addarray_base(AddArray, AbstractArray = :AbstractArray) ) end +macro addarray_adjtrans(AddArray, AbstractArray = :AbstractArray) + return esc( + quote + Base.adjoint(a::$AddArray) = + $TensorAlgebra.adjoint_add(a) + Base.transpose(a::$AddArray) = + $TensorAlgebra.transpose_add(a) + end + ) +end + macro addarray_broadcast(AddArray, AbstractArray = :AbstractArray) return esc( quote @@ -563,14 +644,25 @@ macro addarray_terminterface(AddArray, AbstractArray = :AbstractArray) ) end +macro addarray_functionimplementations(AddArray, AbstractArray = :AbstractArray) + return esc( + quote + $TensorAlgebra.FI.permuteddims(a::$AddArray, perm) = + $TensorAlgebra.permuteddims_add(a, perm) + end + ) +end + macro addarray(AddArray, AbstractArray = :AbstractArray) return esc( quote $TensorAlgebra.@addarray_base $AddArray $AbstractArray + $TensorAlgebra.@addarray_adjtrans $AddArray $AbstractArray $TensorAlgebra.@addarray_broadcast $AddArray $AbstractArray $TensorAlgebra.@addarray_lazy $AddArray $AbstractArray $TensorAlgebra.@addarray_tensoralgebra $AddArray $AbstractArray $TensorAlgebra.@addarray_terminterface $AddArray $AbstractArray + $TensorAlgebra.@addarray_functionimplementations $AddArray $AbstractArray end ) end @@ -599,6 +691,10 @@ copyto!_mul(dest::AbstractArray, src::AbstractArray) = add!(dest, src, true, fal show_mul(io::IO, a::AbstractArray) = show_lazy(io, a) show_mul(io::IO, mime::MIME"text/plain", a::AbstractArray) = show_lazy(io, mime, a) +# Base overloads of adjoint and transpose for MulArrays. +adjoint_mul(a::AbstractArray) = *ₗ(reverse(adjoint.(factors(a)))...) +transpose_mul(a::AbstractArray) = *ₗ(reverse(transpose.(factors(a)))...) + # Base.Broadcast overloads for MulArrays. materialize_mul(a::AbstractArray) = copy(a) function BroadcastStyle_mul(arrayt::Type{<:AbstractArray}) @@ -672,6 +768,17 @@ macro mularray_base(MulArray, AbstractArray = :AbstractArray) ) end +macro mularray_adjtrans(MulArray, AbstractArray = :AbstractArray) + return esc( + quote + Base.adjoint(a::$MulArray) = + $TensorAlgebra.adjoint_mul(a) + Base.transpose(a::$MulArray) = + $TensorAlgebra.transpose_mul(a) + end + ) +end + macro mularray_broadcast(MulArray, AbstractArray = :AbstractArray) return esc( quote @@ -718,6 +825,7 @@ macro mularray(MulArray, AbstractArray = :AbstractArray) return esc( quote $TensorAlgebra.@mularray_base $MulArray $AbstractArray + $TensorAlgebra.@mularray_adjtrans $MulArray $AbstractArray $TensorAlgebra.@mularray_broadcast $MulArray $AbstractArray $TensorAlgebra.@mularray_lazy $MulArray $AbstractArray $TensorAlgebra.@mularray_tensoralgebra $MulArray $AbstractArray diff --git a/test/Project.toml b/test/Project.toml index 3c6bf93..6c45668 100644 --- a/test/Project.toml +++ b/test/Project.toml @@ -3,6 +3,7 @@ Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595" BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" EllipsisNotation = "da5c29d0-fa7d-589e-88eb-ea29b0a81949" +FunctionImplementations = "7c7cc465-9c6a-495f-bdd1-f42428e86d0c" JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" MatrixAlgebraKit = "6c742aac-3347-4629-af66-fc926824e5e4" @@ -23,6 +24,7 @@ Adapt = "4" Aqua = "0.8.9" BlockArrays = "1.6.1" EllipsisNotation = "1.8" +FunctionImplementations = "0.3" JLArrays = "0.3" LinearAlgebra = "<0.0.1, 1" MatrixAlgebraKit = "0.2, 0.3, 0.4, 0.5, 0.6" diff --git a/test/test_lazy.jl b/test/test_lazy.jl index b9a9116..1362c52 100644 --- a/test/test_lazy.jl +++ b/test/test_lazy.jl @@ -1,32 +1,97 @@ +import FunctionImplementations as FI using TensorAlgebra: TensorAlgebra as TA, +ₗ, *ₗ, conjed -using Test: @test, @testset +using Test: @test, @test_broken, @testset -@testset "lazy array operations" begin - a = randn(ComplexF64, 3, 3) - b = randn(ComplexF64, 3, 3) - c = randn(ComplexF64, 3, 3) +@testset "lazy arrays" begin + @testset "lazy array operations" begin + a = randn(ComplexF64, 3, 3) + b = randn(ComplexF64, 3, 3) + c = randn(ComplexF64, 3, 3) - x = 2 *ₗ a - @test x ≡ TA.ScaledArray(2, a) - @test copy(x) ≈ 2a + x = 2 *ₗ a + @test x ≡ TA.ScaledArray(2, a) + @test copy(x) ≈ 2a - x = conjed(a) - @test x ≡ TA.ConjArray(a) - @test copy(x) ≈ conj(a) + x = conjed(a) + @test x ≡ TA.ConjArray(a) + @test copy(x) ≈ conj(a) + @test conj(x) ≈ a - x = a +ₗ b - @test x ≡ TA.AddArray(a, b) - @test copy(x) ≈ a + b + x = a +ₗ b + @test x ≡ TA.AddArray(a, b) + @test copy(x) ≈ a + b - x = a *ₗ b - @test x ≡ TA.MulArray(a, b) - @test copy(x) ≈ a * b + x = a *ₗ b + @test x ≡ TA.MulArray(a, b) + @test copy(x) ≈ a * b - x = a *ₗ b +ₗ c - @test x ≡ TA.AddArray(TA.MulArray(a, b), c) - @test copy(x) ≈ a *ₗ b .+ c ≈ a * b + c + x = a *ₗ b +ₗ c + @test x ≡ TA.AddArray(TA.MulArray(a, b), c) + @test copy(x) ≈ a *ₗ b .+ c ≈ a * b + c - x = 2 *ₗ a *ₗ b +ₗ 3 *ₗ c - @test x ≡ TA.AddArray(TA.ScaledArray(2, TA.MulArray(a, b)), TA.ScaledArray(3, c)) - @test copy(x) ≈ 2 .* a *ₗ b .+ 3 .* c ≈ 2 * a * b + 3 * c + x = 2 *ₗ a *ₗ b +ₗ 3 *ₗ c + @test x ≡ TA.AddArray(TA.ScaledArray(2, TA.MulArray(a, b)), TA.ScaledArray(3, c)) + @test copy(x) ≈ 2 .* a *ₗ b .+ 3 .* c ≈ 2 * a * b + 3 * c + end + @testset "adjoint" begin + a = randn(ComplexF64, 2, 2) + b = randn(ComplexF64, 2, 2) + + x = (2 *ₗ a)' + @test x ≡ 2 *ₗ a' + @test copy(x) ≈ 2a' + + x = conjed(a)' + @test x ≡ transpose(a) + @test copy(x) ≈ permutedims(a) + + x = (a +ₗ b)' + @test x ≡ a' +ₗ b' + @test copy(x) ≈ a' + b' + + x = (a *ₗ b)' + @test x ≡ b' *ₗ a' + @test copy(x) ≈ b' * a' + end + @testset "transpose" begin + a = randn(ComplexF64, 2, 2) + b = randn(ComplexF64, 2, 2) + + x = transpose(2 *ₗ a) + @test x ≡ 2 *ₗ transpose(a) + @test copy(x) ≈ 2transpose(a) + + x = transpose(conjed(a)) + @test x ≡ adjoint(a) + @test copy(x) ≈ permutedims(conj(a)) + + x = transpose(a +ₗ b) + @test x ≡ transpose(a) +ₗ transpose(b) + @test copy(x) ≈ transpose(a) + transpose(b) + + x = transpose(a *ₗ b) + @test x ≡ transpose(b) *ₗ transpose(a) + @test copy(x) ≈ transpose(b) * transpose(a) + end + @testset "permuteddims" begin + a = randn(ComplexF64, 2, 2) + b = randn(ComplexF64, 2, 2) + perm = (2, 1) + + x = FI.permuteddims(2 *ₗ a, perm) + @test x ≡ 2 *ₗ FI.permuteddims(a, perm) + @test copy(x) ≈ 2permutedims(a, perm) + + x = FI.permuteddims(conjed(a), perm) + @test x ≡ conjed(FI.permuteddims(a, perm)) + @test copy(x) ≈ conj(permutedims(a, perm)) + + x = FI.permuteddims(a +ₗ b, perm) + @test x ≡ FI.permuteddims(a, perm) +ₗ FI.permuteddims(b, perm) + @test copy(x) ≈ permutedims(a, perm) + permutedims(b, perm) + + x = FI.permuteddims(a *ₗ b, perm) + @test x ≡ PermutedDimsArray(a *ₗ b, perm) + @test_broken copy(x) ≈ permutedims(a * b, perm) + end end