[WIP][SetParameters] Generalize to work for any type, rename to TypeParameterAccessors

NDTensors/ext/NDTensorsCUDAExt/NDTensorsCUDAExt.jl

@@ -1,7 +1,7 @@
 module NDTensorsCUDAExt
 
 using NDTensors
-using NDTensors.SetParameters
+using NDTensors.TypeParameterAccessor
 using NDTensors.Unwrap
 using Adapt
 using Functors
@@ -13,7 +13,6 @@ using CUDA.CUSOLVER
 include("imports.jl")
 include("default_kwargs.jl")
 include("copyto.jl")
-include("set_types.jl")
 include("iscu.jl")
 include("adapt.jl")
 include("indexing.jl")

NDTensors/ext/NDTensorsCUDAExt/imports.jl

@@ -1,4 +1,5 @@
 import NDTensors: cu, similartype
 import NDTensors:
   ContractionProperties, _contract!, GemmBackend, auto_select_backend, _gemm!, iscu
-import NDTensors.SetParameters: nparameters, get_parameter, set_parameter, default_parameter
+import NDTensors.TypeParameterAccessor:
+  nparameters, get_parameter, set_parameter, default_parameter

NDTensors/ext/NDTensorsCUDAExt/set_types.jl

@@ -1,40 +1,40 @@
-# `SetParameters.jl` overloads.
-get_parameter(::Type{<:CuArray{P1}}, ::Position{1}) where {P1} = P1
-get_parameter(::Type{<:CuArray{<:Any,P2}}, ::Position{2}) where {P2} = P2
-get_parameter(::Type{<:CuArray{<:Any,<:Any,P3}}, ::Position{3}) where {P3} = P3
+# # `TypeParameterAccessor.jl` overloads.
+# get_parameter(::Type{<:CuArray{P1}}, ::Position{1}) where {P1} = P1
+# get_parameter(::Type{<:CuArray{<:Any,P2}}, ::Position{2}) where {P2} = P2
+# get_parameter(::Type{<:CuArray{<:Any,<:Any,P3}}, ::Position{3}) where {P3} = P3
 
-# Set parameter 1
-set_parameter(::Type{<:CuArray}, ::Position{1}, P1) = CuArray{P1}
-set_parameter(::Type{<:CuArray{<:Any,P2}}, ::Position{1}, P1) where {P2} = CuArray{P1,P2}
-function set_parameter(::Type{<:CuArray{<:Any,<:Any,P3}}, ::Position{1}, P1) where {P3}
-  return CuArray{P1,<:Any,P3}
-end
-function set_parameter(::Type{<:CuArray{<:Any,P2,P3}}, ::Position{1}, P1) where {P2,P3}
-  return CuArray{P1,P2,P3}
-end
+# # Set parameter 1
+# set_parameter(::Type{<:CuArray}, ::Position{1}, P1) = CuArray{P1}
+# set_parameter(::Type{<:CuArray{<:Any,P2}}, ::Position{1}, P1) where {P2} = CuArray{P1,P2}
+# function set_parameter(::Type{<:CuArray{<:Any,<:Any,P3}}, ::Position{1}, P1) where {P3}
+#   return CuArray{P1,<:Any,P3}
+# end
+# function set_parameter(::Type{<:CuArray{<:Any,P2,P3}}, ::Position{1}, P1) where {P2,P3}
+#   return CuArray{P1,P2,P3}
+# end
 
-# Set parameter 2
-set_parameter(::Type{<:CuArray}, ::Position{2}, P2) = CuArray{<:Any,P2}
-set_parameter(::Type{<:CuArray{P1}}, ::Position{2}, P2) where {P1} = CuArray{P1,P2}
-function set_parameter(::Type{<:CuArray{<:Any,<:Any,P3}}, ::Position{2}, P2) where {P3}
-  return CuArray{<:Any,P2,P3}
-end
-function set_parameter(::Type{<:CuArray{P1,<:Any,P3}}, ::Position{2}, P2) where {P1,P3}
-  return CuArray{P1,P2,P3}
-end
+# # Set parameter 2
+# set_parameter(::Type{<:CuArray}, ::Position{2}, P2) = CuArray{<:Any,P2}
+# set_parameter(::Type{<:CuArray{P1}}, ::Position{2}, P2) where {P1} = CuArray{P1,P2}
+# function set_parameter(::Type{<:CuArray{<:Any,<:Any,P3}}, ::Position{2}, P2) where {P3}
+#   return CuArray{<:Any,P2,P3}
+# end
+# function set_parameter(::Type{<:CuArray{P1,<:Any,P3}}, ::Position{2}, P2) where {P1,P3}
+#   return CuArray{P1,P2,P3}
+# end
 
-# Set parameter 3
-set_parameter(::Type{<:CuArray}, ::Position{3}, P3) = CuArray{<:Any,<:Any,P3}
-set_parameter(::Type{<:CuArray{P1}}, ::Position{3}, P3) where {P1} = CuArray{P1,<:Any,P3}
-function set_parameter(::Type{<:CuArray{<:Any,P2}}, ::Position{3}, P3) where {P2}
-  return CuArray{<:Any,P2,P3}
-end
-set_parameter(::Type{<:CuArray{P1,P2}}, ::Position{3}, P3) where {P1,P2} = CuArray{P1,P2,P3}
+# # Set parameter 3
+# set_parameter(::Type{<:CuArray}, ::Position{3}, P3) = CuArray{<:Any,<:Any,P3}
+# set_parameter(::Type{<:CuArray{P1}}, ::Position{3}, P3) where {P1} = CuArray{P1,<:Any,P3}
+# function set_parameter(::Type{<:CuArray{<:Any,P2}}, ::Position{3}, P3) where {P2}
+#   return CuArray{<:Any,P2,P3}
+# end
+# set_parameter(::Type{<:CuArray{P1,P2}}, ::Position{3}, P3) where {P1,P2} = CuArray{P1,P2,P3}
 
-default_parameter(::Type{<:CuArray}, ::Position{1}) = Float64
-default_parameter(::Type{<:CuArray}, ::Position{2}) = 1
-default_parameter(::Type{<:CuArray}, ::Position{3}) = Mem.DeviceBuffer
+# default_parameter(::Type{<:CuArray}, ::Position{1}) = Float64
+# default_parameter(::Type{<:CuArray}, ::Position{2}) = 1
+# default_parameter(::Type{<:CuArray}, ::Position{3}) = Mem.DeviceBuffer
 
-nparameters(::Type{<:CuArray}) = Val(3)
+# nparameters(::Type{<:CuArray}) = Val(3)
 
-SetParameters.unspecify_parameters(::Type{<:CuArray}) = CuArray
+# TypeParameterAccessor.unspecify_parameters(::Type{<:CuArray}) = CuArray

NDTensors/ext/NDTensorsMetalExt/NDTensorsMetalExt.jl

@@ -4,14 +4,14 @@ using Adapt
 using Functors
 using LinearAlgebra: LinearAlgebra, Adjoint, Transpose, mul!, qr, eigen, svd
 using NDTensors
-using NDTensors.SetParameters
+using NDTensors.TypeParameterAccessor
 using NDTensors.Unwrap: qr_positive, ql_positive, ql
 
 using Metal
 
 include("imports.jl")
 include("adapt.jl")
-include("set_types.jl")
+# include("set_types.jl")
 include("indexing.jl")
 include("linearalgebra.jl")
 include("copyto.jl")

NDTensors/ext/NDTensorsMetalExt/adapt.jl

@@ -6,6 +6,6 @@ end
 
 # More general than the version in Metal.jl
 function Adapt.adapt_storage(arraytype::Type{<:MtlArray}, xs::AbstractArray)
-  arraytype_specified = specify_parameters(arraytype, get_parameters(xs))
+  arraytype_specified = specify_parameters(arraytype, parameters(xs))
   return isbitstype(typeof(xs)) ? xs : convert(arraytype_specified, xs)
 end

NDTensors/ext/NDTensorsMetalExt/imports.jl

@@ -1,5 +1,6 @@
 import NDTensors: mtl
-import NDTensors.SetParameters: nparameters, get_parameter, set_parameter, default_parameter
+import NDTensors.TypeParameterAccessor:
+  nparameters, get_parameter, set_parameter, default_parameter
 
 using NDTensors.Unwrap: Exposed, unwrap_type, unexpose, expose
 using Metal: DefaultStorageMode

NDTensors/ext/NDTensorsMetalExt/set_types.jl

@@ -1,47 +1,47 @@
-# `SetParameters.jl` overloads.
-get_parameter(::Type{<:MtlArray{P1}}, ::Position{1}) where {P1} = P1
-get_parameter(::Type{<:MtlArray{<:Any,P2}}, ::Position{2}) where {P2} = P2
-get_parameter(::Type{<:MtlArray{<:Any,<:Any,P3}}, ::Position{3}) where {P3} = P3
+# # `TypeParameterAccessor.jl` overloads.
+# get_parameter(::Type{<:MtlArray{P1}}, ::Position{1}) where {P1} = P1
+# get_parameter(::Type{<:MtlArray{<:Any,P2}}, ::Position{2}) where {P2} = P2
+# get_parameter(::Type{<:MtlArray{<:Any,<:Any,P3}}, ::Position{3}) where {P3} = P3
 
-# Set parameter 1
-set_parameter(::Type{<:MtlArray}, ::Position{1}, P1) = MtlArray{P1}
-set_parameter(::Type{<:MtlArray{<:Any,P2}}, ::Position{1}, P1) where {P2} = MtlArray{P1,P2}
-function set_parameter(::Type{<:MtlArray{<:Any,<:Any,P3}}, ::Position{1}, P1) where {P3}
-  return MtlArray{P1,<:Any,P3}
-end
-function set_parameter(::Type{<:MtlArray{<:Any,P2,P3}}, ::Position{1}, P1) where {P2,P3}
-  return MtlArray{P1,P2,P3}
-end
+# # Set parameter 1
+# set_parameter(::Type{<:MtlArray}, ::Position{1}, P1) = MtlArray{P1}
+# set_parameter(::Type{<:MtlArray{<:Any,P2}}, ::Position{1}, P1) where {P2} = MtlArray{P1,P2}
+# function set_parameter(::Type{<:MtlArray{<:Any,<:Any,P3}}, ::Position{1}, P1) where {P3}
+#   return MtlArray{P1,<:Any,P3}
+# end
+# function set_parameter(::Type{<:MtlArray{<:Any,P2,P3}}, ::Position{1}, P1) where {P2,P3}
+#   return MtlArray{P1,P2,P3}
+# end
 
-# Set parameter 2
-set_parameter(::Type{<:MtlArray}, ::Position{2}, P2) = MtlArray{<:Any,P2}
-set_parameter(::Type{<:MtlArray{P1}}, ::Position{2}, P2) where {P1} = MtlArray{P1,P2}
-function set_parameter(::Type{<:MtlArray{<:Any,<:Any,P3}}, ::Position{2}, P2) where {P3}
-  return MtlArray{<:Any,P2,P3}
-end
-function set_parameter(::Type{<:MtlArray{P1,<:Any,P3}}, ::Position{2}, P2) where {P1,P3}
-  return MtlArray{P1,P2,P3}
-end
+# # Set parameter 2
+# set_parameter(::Type{<:MtlArray}, ::Position{2}, P2) = MtlArray{<:Any,P2}
+# set_parameter(::Type{<:MtlArray{P1}}, ::Position{2}, P2) where {P1} = MtlArray{P1,P2}
+# function set_parameter(::Type{<:MtlArray{<:Any,<:Any,P3}}, ::Position{2}, P2) where {P3}
+#   return MtlArray{<:Any,P2,P3}
+# end
+# function set_parameter(::Type{<:MtlArray{P1,<:Any,P3}}, ::Position{2}, P2) where {P1,P3}
+#   return MtlArray{P1,P2,P3}
+# end
 
-# Set parameter 3
-set_parameter(::Type{<:MtlArray}, ::Position{3}, P3) = MtlArray{<:Any,<:Any,P3}
-set_parameter(::Type{<:MtlArray{P1}}, ::Position{3}, P3) where {P1} = MtlArray{P1,<:Any,P3}
-function set_parameter(::Type{<:MtlArray{<:Any,P2}}, ::Position{3}, P3) where {P2}
-  return MtlArray{<:Any,P2,P3}
-end
-function set_parameter(::Type{<:MtlArray{P1,P2}}, ::Position{3}, P3) where {P1,P2}
-  return MtlArray{P1,P2,P3}
-end
+# # Set parameter 3
+# set_parameter(::Type{<:MtlArray}, ::Position{3}, P3) = MtlArray{<:Any,<:Any,P3}
+# set_parameter(::Type{<:MtlArray{P1}}, ::Position{3}, P3) where {P1} = MtlArray{P1,<:Any,P3}
+# function set_parameter(::Type{<:MtlArray{<:Any,P2}}, ::Position{3}, P3) where {P2}
+#   return MtlArray{<:Any,P2,P3}
+# end
+# function set_parameter(::Type{<:MtlArray{P1,P2}}, ::Position{3}, P3) where {P1,P2}
+#   return MtlArray{P1,P2,P3}
+# end
 
-default_parameter(::Type{<:MtlArray}, ::Position{1}) = Float32
-default_parameter(::Type{<:MtlArray}, ::Position{2}) = 1
-default_parameter(::Type{<:MtlArray}, ::Position{3}) = Metal.DefaultStorageMode
+# default_parameter(::Type{<:MtlArray}, ::Position{1}) = Float32
+# default_parameter(::Type{<:MtlArray}, ::Position{2}) = 1
+# default_parameter(::Type{<:MtlArray}, ::Position{3}) = Metal.DefaultStorageMode
 
-nparameters(::Type{<:MtlArray}) = Val(3)
+# nparameters(::Type{<:MtlArray}) = Val(3)
 
-# Metal-specific type parameter setting
-function set_storagemode(arraytype::Type{<:MtlArray}, storagemode)
-  return set_parameter(arraytype, Position(3), storagemode)
-end
+# # Metal-specific type parameter setting
+# function set_storagemode(arraytype::Type{<:MtlArray}, storagemode)
+#   return set_parameter(arraytype, Position(3), storagemode)
+# end
 
-SetParameters.unspecify_parameters(::Type{<:MtlArray}) = MtlArray
+# TypeParameterAccessor.unspecify_parameters(::Type{<:MtlArray}) = MtlArray

NDTensors/src/NDTensors.jl

@@ -25,7 +25,7 @@ for lib in [
   :BaseExtensions,
   :UnspecifiedTypes,
   :Unwrap,
-  :SetParameters,
+  :TypeParameterAccessor,
   :BroadcastMapConversion,
   :RankFactorization,
   :Sectors,

NDTensors/src/abstractarray/fill.jl

@@ -1,4 +1,4 @@
-using .SetParameters: DefaultParameters, specify_parameters
+using .TypeParameterAccessor: DefaultParameters, specify_parameters
 using .Unwrap: unwrap_type
 
 function generic_randn(

NDTensors/src/abstractarray/set_types.jl

@@ -1,4 +1,4 @@
-using .SetParameters: set_ndims
+using .TypeParameterAccessor: set_ndims
 """
 # Do we still want to define things like this?
 TODO: Use `Accessors.jl` notation:
@@ -11,7 +11,7 @@ TODO: Use `Accessors.jl` notation:
 # TODO: Delete this when we change to using a
 # `FillArray` instead. This is a stand-in
 # to make things work with the current design.
-function SetParameters.set_ndims(numbertype::Type{<:Number}, ndims)
+function TypeParameterAccessor.set_ndims(numbertype::Type{<:Number}, ndims)
   return numbertype
 end
 

NDTensors/src/array/set_types.jl

@@ -1,7 +1,7 @@
-using .SetParameters: Position, get_parameter, set_parameters, set_eltype
+using .TypeParameterAccessor: Position
 
-SetParameters.eltype_position(::Type{<:SubArray}) = Position(1)
-SetParameters.parenttype_position(::Type{<:SubArray}) = Position(3)
+TypeParameterAccessor.eltype_position(::Type{<:SubArray}) = Position(1)
+TypeParameterAccessor.parenttype_position(::Type{<:SubArray}) = Position(3)
 
 # TODO: Figure out how to define this properly.
 # function set_ndims(arraytype::Type{<:SubArray}, ndims)

NDTensors/src/blocksparse/blocksparse.jl

@@ -23,7 +23,7 @@ function set_datatype(storagetype::Type{<:BlockSparse}, datatype::Type{<:Abstrac
   return BlockSparse{eltype(datatype),datatype,ndims(storagetype)}
 end
 
-function SetParameters.set_ndims(storagetype::Type{<:BlockSparse}, ndims::Int)
+function TypeParameterAccessor.set_ndims(storagetype::Type{<:BlockSparse}, ndims::Int)
   return BlockSparse{eltype(storagetype),datatype(storagetype),ndims}
 end
 

NDTensors/src/dense/set_types.jl

@@ -1,5 +1,5 @@
-using .SetParameters:
-  SetParameters, Position, get_parameters, specify_parameters, unspecify_parameters
+using .TypeParameterAccessor:
+  TypeParameterAccessor, Position, parameters, specify_parameters, unspecify_parameters
 
 function set_datatype(storagetype::Type{<:Dense}, datatype::Type{<:AbstractVector})
   return Dense{eltype(datatype),datatype}
@@ -11,23 +11,8 @@ function set_datatype(storagetype::Type{<:Dense}, datatype::Type{<:AbstractArray
   )
 end
 
-SetParameters.unspecify_parameters(::Type{<:Dense}) = Dense
+# TypeParameterAccessor.unspecify_parameters(::Type{<:Dense}) = Dense
 
-SetParameters.parenttype_position(::Type{<:Dense}) = Position(2)
-SetParameters.nparameters(::Type{<:Dense}) = Val(2)
-SetParameters.get_parameter(::Type{<:Dense{P1}}, ::Position{1}) where {P1} = P1
-SetParameters.get_parameter(::Type{<:Dense{<:Any,P2}}, ::Position{2}) where {P2} = P2
-SetParameters.default_parameter(::Type{<:Dense}, ::Position{1}) = Float64
-SetParameters.default_parameter(::Type{<:Dense}, ::Position{2}) = Vector
-
-SetParameters.set_parameter(::Type{<:Dense}, ::Position{1}, P1) = Dense{P1}
-function SetParameters.set_parameter(
-  ::Type{<:Dense{<:Any,P2}}, ::Position{1}, P1
-) where {P2}
-  return Dense{P1,P2}
-end
-
-SetParameters.set_parameter(::Type{<:Dense}, ::Position{2}, P2) = Dense{<:Any,P2}
-function SetParameters.set_parameter(::Type{<:Dense{P1}}, ::Position{2}, P2) where {P1}
-  return Dense{P1,P2}
-end
+TypeParameterAccessor.parenttype_position(::Type{<:Dense}) = Position(2)
+TypeParameterAccessor.default_parameter(::Type{<:Dense}, ::Position{1}) = Float64
+TypeParameterAccessor.default_parameter(::Type{<:Dense}, ::Position{2}) = Vector

NDTensors/src/diag/set_types.jl

@@ -1,8 +1,8 @@
-function SetParameters.set_eltype(storagetype::Type{<:UniformDiag}, eltype::Type)
+function TypeParameterAccessor.set_eltype(storagetype::Type{<:UniformDiag}, eltype::Type)
   return Diag{eltype,eltype}
 end
 
-function SetParameters.set_eltype(
+function TypeParameterAccessor.set_eltype(
   storagetype::Type{<:NonuniformDiag}, eltype::Type{<:AbstractArray}
 )
   return Diag{eltype,similartype(storagetype, eltype)}

NDTensors/src/lib/AlgorithmSelection/src/algorithm.jl

@@ -19,7 +19,7 @@ Algorithm(s; kwargs...) = Algorithm{Symbol(s)}(NamedTuple(kwargs))
 
 Algorithm(alg::Algorithm) = alg
 
-# TODO: Use `SetParameters`.
+# TODO: Use `TypeParameterAccessor`.
 algorithm_string(::Algorithm{Alg}) where {Alg} = string(Alg)
 
 function Base.show(io::IO, alg::Algorithm)

NDTensors/src/lib/BlockSparseArrays/src/backup/blocksparsearray.jl

@@ -15,10 +15,10 @@ end
 
 Base.axes(block_arr::BlockSparseArray) = block_arr.axes
 BlockArrays.blocks(a::BlockSparseArray) = a.blocks
-# TODO: Use `SetParameters`.
+# TODO: Use `TypeParameterAccessor`.
 blocktype(a::BlockSparseArray{<:Any,<:Any,A}) where {A} = A
 
-# TODO: Use `SetParameters`.
+# TODO: Use `TypeParameterAccessor`.
 set_ndims(::Type{<:Array{T}}, n) where {T} = Array{T,n}
 
 # TODO: Move to `AbstractArray` file.

NDTensors/src/lib/BlockSparseArrays/src/blocksparsearray/blocksparsearray.jl

@@ -104,7 +104,7 @@ Base.axes(a::BlockSparseArray) = a.axes
 # BlockArrays `AbstractBlockArray` interface
 BlockArrays.blocks(a::BlockSparseArray) = a.blocks
 
-# TODO: Use `SetParameters`.
+# TODO: Use `TypeParameterAccessor`.
 blockstype(::Type{<:BlockSparseArray{<:Any,<:Any,<:Any,B}}) where {B} = B
 
 # Base interface

NDTensors/src/lib/NamedDimsArrays/src/abstractnameddimsarray.jl

@@ -16,7 +16,7 @@ dimnames(a::AbstractNamedDimsArray) = error("Not implemented")
 Base.parent(::AbstractNamedDimsArray) = error("Not implemented")
 
 # TODO: Use `Unwrap`.
-# TODO: Use `SetParameters`.
+# TODO: Use `TypeParameterAccessor`.
 parenttype(::AbstractNamedDimsArray{<:Any,<:Any,Parent}) where {Parent} = Parent
 
 # Set the names of an unnamed AbstractArray