SArray, but heterogeneous?

General Usage
1

Is it possible to have a Julia type for heterogeneous arrays with compile-time-known sizes? In particular I’m thinking of a heterogeneous matrix, so it would be parameterized by number of rows, number of columns and with a type for each of its elements. The latter part is problematic.

Wait a minute I think I got an idea!

2

I think this is feasible. You can wrap a Tuple like the other StaticArrays do, except your array would be fully parametrized by the Tuple’s type, which contains the types of each element. It’ll be odd because an AbstractArray should have a singular eltype aka T, but maybe all of your arrays could just use Any. And if you subtype StaticArray too, you’ll have to adhere to more type parameter conventions.

2 Likes
3

I think it’s going to be something like this:

struct HSArray{T <: Tuple, size}
  data::T

  function HSArray(t::T, ::Val{size}) where {T <: Tuple, size}
    (length(t) == prod(size)) || error("sizing error")
    new{T, size}(t)
  end
end

Base.length(::HSArray{<: Tuple, size}) where {size} = prod(size)
Base.size(::HSArray{<: Tuple, size}) where {size} = size

Base.IndexStyle(::HSArray{<: Tuple, size}) where {size} = Base.IndexLinear()

Just need to implement some more interfaces from Interfaces · The Julia Language

Actually, those interfaces would be of limited use for my type because eltype(::HSarray) would need to be Any, as Benny said.

The most useful method for me would be getindex, which seems easy to implement.

1 Like
4

Now that I check the Interface docs, the eltype is said to be important, but I’m not familiar with how exactly, except for allocating methods like collect and the default similar. So I don’t know how using Any all the time would pan out. I wondered if the eltype affects the type stability of critical methods like getindex, but it seems like you could just forward it to the wrapped Tuple and it should be inferred , which is technically type-unstable but the compiler does infer the output type given a constant index. setindex! is obviously harder for a wrapped Tuple, but if you intend to implement that, you could look into MArray’s “pointer manipulation”.

1 Like
5

For my usecase I don’t think I need setindex!, or iteration, and if I don’t need iteration then eltype shouldn’t matter either, I think. So this is easy, unlike what I thought at first.

6

The default iterate for AbstractArrays is based on scalar getindex, so you’ll get it for free.

7

Just for info and in case this interests someone, I recently wrote this in some of my code:

struct HeterogeneousStaticArray{S<:Tuple,D,T,X<:Tuple} <: StaticArray{S,T,D}
    data::X
  end
  #  HeterogeneousStaticArray{S,D,T}(x::X) where{S,D,T,X} =
  #   HeterogeneousStaticArray{S,D,T,X}(x)
  const HSVector{N,T} =
    HeterogeneousStaticArray{Tuple{N},1,T}
  const HSMatrix{N1,N2,T} =
    HeterogeneousStaticArray{Tuple{N1,N2},2,T}
  
  @propagate_inbounds Base.getindex(a::HeterogeneousStaticArray, i::Int) = a.data[i]
  # these two lines are copied from LinearAlgebra/adjtrans.jl,
  # only removing the typeassert for the result:
  @propagate_inbounds Base.getindex(v::LinearAlgebra.AdjOrTrans{T,<:HSVector},
    i::Int) where {T} =
    LinearAlgebra.wrapperop(v)(v.parent[i-1+first(axes(v.parent)[1])])
  @propagate_inbounds Base.getindex(A::LinearAlgebra.AdjOrTrans{T,<:HSMatrix},
    i::Int, j::Int) where {T} = LinearAlgebra.wrapperop(A)(A.parent[j, i])
  
  """    HSA[x1 x2;x3 x4]
  
  A constructor building a static array with heterogeneous values
  (stored in a tuple)."""
  struct HSA{T} end
  Base.getindex(h::Type{HSA}, x...) = similar_type(h, Size(length(x)))(x)
  
  Base.typed_hvcat(h::Type{HSA}, rows::Dims, x...) =
    _typed_hvcat_tr(h, rows, x)
  Base.typed_hvcat(h::Type{HSA}, rows::Dims, x::Number...) = # disambiguation
    _typed_hvcat_tr(h, rows, x)
  function _typed_hvcat_tr(h, rows, x)
    s = StaticArrays._SA_hvcat_transposed_size(rows)
    isnothing(s) && throw(ArgumentError(string(
      "HSA[...] matrix with inconsistent row lengths: ", rows)))
    similar_type(h, s)(StaticArrays.reorder(x, Val(s[1]), Val(s[2])))
  end
(H::Type{HeterogeneousStaticArray{S}})(x::Tuple) where{S} =
    StaticArrays.construct_type(H, x)(x)
  StaticArrays.similar_type(::Type{HSA}, ::Size{S}) where{S} =
    HeterogeneousStaticArray{Tuple{S...}}
  StaticArrays.construct_type(::Type{H}, x) where{H<:HeterogeneousStaticArray} =
    StaticArrays.adapt_eltype(StaticArrays.adapt_size(H, x), x)
  function StaticArrays.adapt_eltype(::Type{HeterogeneousStaticArray{S,D}},
      x) where{S,D}
    T = StaticArrays.promote_tuple_eltype(x)
    return HeterogeneousStaticArray{S,D,T,typeof(x)}
  end
1 Like