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 StaticThings.size_from_type(T) 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 of 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.

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.

Defaults to Static.dynamic(x).

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

Get the size of a collection-like object from it's axes.

canonical_axes(sz::SizeLike)

Return the canonical representation 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)::Tuple{Vararg{IntegerLike}}

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

maybestatic_eachindex(x)

Returns the 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)

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

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.

staticarray_type(T, sz::StaticArrays.Size)

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