StaticThings

StaticThings provides tools to help write generic code that works with both static and non-static values and arrays.

AxesLike = Union{Tuple{},Tuple{Vararg{AbstractVector{<:IntegerLike}}}}

Something that can represent axes of a collection.

StaticThings.NoTypeSize{T}()

Returned by size_from_type if the size of values of type T is not fixed or not known.

StaticAxesLike = Tuple{Vararg{Union{StaticArrays.SOneTo,StaticArrays.SUnitRange,Static.SUnitRange}}}

Something that can represent axes of a statically sized collection.

const StaticOneTo{T} = StaticArrays.SOneTo{T}

The StaticThings default type for static one-based unit ranges.

Currently an alias for StaticArrays.SOneTo.

StaticUnitRange

The StaticThings default type for static unit ranges.

Currently an alias for StaticArrays.SUnitRange, if it exists, otherwise an alias for Static.SUnitRange.

IntegerLike = Union{Integer,Static.StaticInteger}

A static or dynamic integer value.

OneToLike = Union{Base.OneTo,StaticArrays.SOneTo,Static.SOneTo}

Alias for unit ranges that start at one.

RealLike = Union{Real,Static.StaticInteger}

A static or dynamic real value.

SizeLike = Union{Tuple{},Tuple{Vararg{IntegerLike}},StaticArrays.Size}

Something that can represent the size of a collection.

StaticOneToLike{N} = Union{StaticArrays.SOneTo{N},Static.SOneTo{N}}

A static unit range from one to N.

StaticSizeLike = Union{Tuple{Vararg{StaticInteger}},StaticArrays.Size}

Something that can represent the size of a statically sized collection.

The empty size () counts as static: a zero-dimensional size is fully known at compile time.

StaticUnitRangeLike = Union{StaticArrays.SOneTo,StaticArrays.SUnitRange,Static.SUnitRange}

A static unit range.

asaxes(axs::AxesLike)
asaxes(sz::SizeLike)
asaxes(len::IntegerLike)

Converts axes or a size or a length of a collection to axes.

One-based indexing will be used if the indexing offset can't be inferred from the given dimensions.

asnonstatic(x)

Return a non-static equivalent of x.

Defined for numbers, tuples, ranges, sizes and axes.

StaticThings.axes2size(x::Tuple)
StaticThings.axes2size(x::StaticArrays.Size)

Get the size of a collection-like object from its axes.

canonical_axes(axs::AxesLike)

Return the canonical representation of collection axes.

canonical_indices(idxs::AbstractVector{<:IntegerLike})

Return the canonical representation of a collection axis indices.

canonical_size(sz::SizeLike)

Return the canonical representation of a collection size.

maybestatic_axes(x)::AxesLike

Returns the axes of x as a tuple of dynamic or static unit ranges.

maybestatic_eachindex(x)

Returns the index range of x as a dynamic or static integer range.

maybestatic_fill(x, sz::NTuple{N,<:IntegerLike}) where N

Creates an array of size sz filled with x.

The result will typically be either a FillArrays.Fill or a StaticArrays.StaticArray.

maybestatic_first(A)

Returns the first element of A as a dynamic or static value.

maybestatic_last(A)

Returns the last element of A as a dynamic or static value.

maybestatic_length(x)

Returns the length of x as a dynamic or static integer.

maybestatic_oneto(n::IntegerLike)

Creates a range from one to n.

Returns an instance of Base.OneTo or StaticOneTo, depending on the type of n.

maybestatic_reshape(A, sz)

Reshapes array A to sizes sz.

If A is a static array and sz is static, the result is a static array.

maybestatic_size(x)::SizeLike

Returns the size of x as a tuple of dynamic or static integers or as a StaticArrays.Size.

size2axes(sz::Tuple)
size2axes(sz::StaticArrays.Size)

Get one-based indexing axes from a size of a collection-like object.

size2length(sz::Tuple)
size2length(sz::StaticArrays.Size)

Get a length from a size (tuple).

size_from_type(::Type{T})::StaticThings.SizeLike

Get the size (equivalent of StaticThings.maybestatic_size) of values of type T.

Requires values of type T to have a fixed known size, returns StaticThings.NoTypeSize{T}() otherwise.

For array types the size is determined via StaticArrayInterface.known_size.

staticarray_type(T, sz::StaticArrays.Size)

Returns the type of a static array with element type T and size sz.