variable names

Author: ogauthe

src/contract/blockedperms.jl

@@ -33,8 +33,8 @@ function blockedperms(::typeof(contract), dimnames_dest, dimnames1, dimnames2)
 
   perm_codomain_dest = BaseExtensions.indexin(codomain, dimnames_dest)
   perm_domain_dest = BaseExtensions.indexin(domain, dimnames_dest)
-  biperm_dest_to_a12 = (perm_codomain_dest..., perm_domain_dest...)
-  biperm_a12_to_dest = biperm(invperm(biperm_dest_to_a12), length_codomain(dimnames_dest))
+  invbiperm = (perm_codomain_dest..., perm_domain_dest...)
+  biperm_dest = biperm(invperm(invbiperm), length_codomain(dimnames_dest))
 
   perm_codomain1 = BaseExtensions.indexin(codomain, dimnames1)
   perm_domain1 = BaseExtensions.indexin(contracted, dimnames1)
@@ -46,5 +46,5 @@ function blockedperms(::typeof(contract), dimnames_dest, dimnames1, dimnames2)
   biperm1 = blockedpermvcat(permblocks1...)
   permblocks2 = (perm_codomain2, perm_domain2)
   biperm2 = blockedpermvcat(permblocks2...)
-  return biperm_a12_to_dest, biperm1, biperm2
+  return biperm_dest, biperm1, biperm2
 end

src/contract/contract.jl

@@ -13,7 +13,7 @@ default_contract_alg() = Matricize()
 function contract!(
   alg::Algorithm,
   a_dest::AbstractArray,
-  biperm_a12_to_dest::AbstractBlockPermutation,
+  biperm_dest::AbstractBlockPermutation,
   a1::AbstractArray,
   biperm1::AbstractBlockPermutation,
   a2::AbstractArray,
@@ -89,10 +89,8 @@ function contract(
   kwargs...,
 )
   check_input(contract, a1, labels1, a2, labels2)
-  biperm_a12_to_dest, biperm1, biperm2 = blockedperms(
-    contract, labels_dest, labels1, labels2
-  )
-  return contract(alg, biperm_a12_to_dest, a1, biperm1, a2, biperm2, α; kwargs...)
+  biperm_dest, biperm1, biperm2 = blockedperms(contract, labels_dest, labels1, labels2)
+  return contract(alg, biperm_dest, a1, biperm1, a2, biperm2, α; kwargs...)
 end
 
 function contract!(
@@ -108,17 +106,13 @@ function contract!(
   kwargs...,
 )
   check_input(contract, a_dest, labels_dest, a1, labels1, a2, labels2)
-  biperm_a12_to_dest, biperm1, biperm2 = blockedperms(
-    contract, labels_dest, labels1, labels2
-  )
-  return contract!(
-    alg, a_dest, biperm_a12_to_dest, a1, biperm1, a2, biperm2, α, β; kwargs...
-  )
+  biperm_dest, biperm1, biperm2 = blockedperms(contract, labels_dest, labels1, labels2)
+  return contract!(alg, a_dest, biperm_dest, a1, biperm1, a2, biperm2, α, β; kwargs...)
 end
 
 function contract(
   alg::Algorithm,
-  biperm_a12_to_dest::AbstractBlockPermutation,
+  biperm_dest::AbstractBlockPermutation,
   a1::AbstractArray,
   biperm1::AbstractBlockPermutation,
   a2::AbstractArray,
@@ -127,9 +121,7 @@ function contract(
   kwargs...,
 )
   check_input(contract, a1, biperm1, a2, biperm2)
-  a_dest = allocate_output(contract, biperm_a12_to_dest, a1, biperm1, a2, biperm2, α)
-  contract!(
-    alg, a_dest, biperm_a12_to_dest, a1, biperm1, a2, biperm2, α, zero(Bool); kwargs...
-  )
+  a_dest = allocate_output(contract, biperm_dest, a1, biperm1, a2, biperm2, α)
+  contract!(alg, a_dest, biperm_dest, a1, biperm1, a2, biperm2, α, zero(Bool); kwargs...)
   return a_dest
 end

src/contract/contract_matricize/contract.jl

@@ -3,20 +3,20 @@ using LinearAlgebra: mul!
 function contract!(
   ::Matricize,
   a_dest::AbstractArray,
-  biperm_a12_to_dest::AbstractBlockPermutation{2},
+  biperm_dest::AbstractBlockPermutation{2},
   a1::AbstractArray,
   biperm1::AbstractBlockPermutation{2},
   a2::AbstractArray,
   biperm2::AbstractBlockPermutation{2},
   α::Number,
   β::Number,
 )
-  biperm_dest_to_a12 = biperm(invperm(biperm_a12_to_dest), length_codomain(biperm1))
+  invbiperm = biperm(invperm(biperm_dest), length_codomain(biperm1))
 
-  check_input(contract, a_dest, biperm_dest_to_a12, a1, biperm1, a2, biperm2)
+  check_input(contract, a_dest, invbiperm, a1, biperm1, a2, biperm2)
   a1_mat = matricize(a1, biperm1)
   a2_mat = matricize(a2, biperm2)
   a_dest_mat = a1_mat * a2_mat
-  unmatricize_add!(a_dest, a_dest_mat, biperm_dest_to_a12, α, β)
+  unmatricize_add!(a_dest, a_dest_mat, invbiperm, α, β)
   return a_dest
 end

src/matricize.jl

@@ -45,27 +45,29 @@ end
 # matrix factorizations assume copy
 # maybe: copy=false kwarg
 
-function matricize(a::AbstractArray, biperm::AbstractBlockPermutation{2})
-  ndims(a) == length(biperm) || throw(ArgumentError("Invalid bipermutation"))
-  return matricize(FusionStyle(a), a, biperm)
+function matricize(a::AbstractArray, biperm_dest::AbstractBlockPermutation{2})
+  ndims(a) == length(biperm_dest) || throw(ArgumentError("Invalid bipermutation"))
+  return matricize(FusionStyle(a), a, biperm_dest)
 end
 
 function matricize(
-  style::FusionStyle, a::AbstractArray, biperm::AbstractBlockPermutation{2}
+  style::FusionStyle, a::AbstractArray, biperm_dest::AbstractBlockPermutation{2}
 )
-  a_perm = permuteblockeddims(a, biperm)
-  return matricize(style, a_perm, trivialperm(biperm))
+  a_perm = permuteblockeddims(a, biperm_dest)
+  return matricize(style, a_perm, trivialperm(biperm_dest))
 end
 
 function matricize(
-  style::FusionStyle, a::AbstractArray, biperm::BlockedTrivialPermutation{2}
+  style::FusionStyle, a::AbstractArray, biperm_dest::BlockedTrivialPermutation{2}
 )
-  return throw(MethodError(matricize, Tuple{typeof(style),typeof(a),typeof(biperm)}))
+  return throw(MethodError(matricize, Tuple{typeof(style),typeof(a),typeof(biperm_dest)}))
 end
 
 # default is reshape
-function matricize(::ReshapeFusion, a::AbstractArray, biperm::BlockedTrivialPermutation{2})
-  new_axes = fuseaxes(axes(a), biperm)
+function matricize(
+  ::ReshapeFusion, a::AbstractArray, biperm_dest::BlockedTrivialPermutation{2}
+)
+  new_axes = fuseaxes(axes(a), biperm_dest)
   return reshape(a, new_axes...)
 end
 
@@ -74,20 +76,20 @@ function matricize(a::AbstractArray, permblock1::Tuple, permblock2::Tuple)
 end
 
 # ====================================  unmatricize  =======================================
-function unmatricize(m::AbstractMatrix, axes, biperm_dest::AbstractBlockPermutation{2})
-  length(axes) == length(biperm_dest) ||
+function unmatricize(m::AbstractMatrix, axes_dest, invbiperm::AbstractBlockPermutation{2})
+  length(axes_dest) == length(invbiperm) ||
     throw(ArgumentError("axes do not match permutation"))
-  return unmatricize(FusionStyle(m), m, axes, biperm_dest)
+  return unmatricize(FusionStyle(m), m, axes_dest, invbiperm)
 end
 
 function unmatricize(
-  ::FusionStyle, m::AbstractMatrix, axes, biperm_dest_to_a12::AbstractBlockPermutation{2}
+  ::FusionStyle, m::AbstractMatrix, axes_dest, invbiperm::AbstractBlockPermutation{2}
 )
-  blocked_axes = axes[biperm_dest_to_a12]
+  blocked_axes = axes_dest[invbiperm]
   a12 = unmatricize(m, blocked_axes)
-  biperm_a12_to_dest = biperm(invperm(biperm_dest_to_a12), length_codomain(axes))
+  biperm_dest = biperm(invperm(invbiperm), length_codomain(axes_dest))
 
-  return permuteblockeddims(a12, biperm_a12_to_dest)
+  return permuteblockeddims(a12, biperm_dest)
 end
 
 function unmatricize(
@@ -111,20 +113,18 @@ function unmatricize(
   return unmatricize(m, blocked_axes)
 end
 
-function unmatricize!(
-  a_dest, m::AbstractMatrix, biperm_dest_to_a12::AbstractBlockPermutation{2}
-)
-  ndims(a_dest) == length(biperm_dest_to_a12) ||
+function unmatricize!(a_dest, m::AbstractMatrix, invbiperm::AbstractBlockPermutation{2})
+  ndims(a_dest) == length(invbiperm) ||
     throw(ArgumentError("destination does not match permutation"))
-  blocked_axes = axes(a_dest)[biperm_dest_to_a12]
+  blocked_axes = axes(a_dest)[invbiperm]
   a_perm = unmatricize(m, blocked_axes)
-  biperm_a12_to_dest = biperm(invperm(biperm_dest_to_a12), length_codomain(axes(a_dest)))
+  biperm_dest = biperm(invperm(invbiperm), length_codomain(axes(a_dest)))
 
-  return permuteblockeddims!(a_dest, a_perm, biperm_a12_to_dest)
+  return permuteblockeddims!(a_dest, a_perm, biperm_dest)
 end
 
-function unmatricize_add!(a_dest, a_dest_mat, biperm_dest_to_a12, α, β)
-  a12 = unmatricize(a_dest_mat, axes(a_dest), biperm_dest_to_a12)
+function unmatricize_add!(a_dest, a_dest_mat, invbiperm, α, β)
+  a12 = unmatricize(a_dest_mat, axes(a_dest), invbiperm)
   a_dest .= α .* a12 .+ β .* a_dest
   return a_dest
 end