Fixed-length vectors

SmallCollections.AbstractFixedVector — Type

AbstractFixedVector{N,T} <: AbstractVector{T}

AbstractFixedVector{N,T} is the supertype of FixedVector{N,T} and MutableFixedVector{N,T}.

source

SmallCollections.FixedVector — Type

FixedVector{N,T} <: AbstractFixedVector{N,T}

FixedVector{N,T}(iter)
FixedVector{N}(iter)
FixedVector(iter)

FixedVector{N,T} is an immutable vector type that holds exactly N elements of type T. (It is analogous to StaticArrays.SVector and StaticVectors.Values.) The size N can be any (small) positive integer. However, at least for bit integer and hardware float types, one usually takes N to be a power of 2.

If the element type T or the size N are omitted, they are determined from the iterator given as argument. Performance degrades if this is not possible at compile time. (For tuples, the element type is determined via promote_type.) As a rule of thumb, the size should only be omitted for Tuple arguments.

See also MutableFixedVector, Base.promote_type.

source

FixedVector(v::StaticVector{N,T}) where {N,T} -> FixedVector{N,T}
MutableFixedVector(v::StaticVector{N,T}) where {N,T} -> MutableFixedVector{N,T}

Convert a StaticVector to a FixedVector or MutableFixedVector. The length N is inferred from the given vector v. For example, v can be an SVector or MVector.

These methods are only available if the package StaticArrays.jl is loaded.

See also AbstractFixedVector, StaticArrays.StaticVector.

source

SmallCollections.MutableFixedVector — Type

MutableFixedVector{N,T} <: AbstractFixedVector{N,T}

MutableFixedVector{N,T}(iter)
MutableFixedVector{N}(iter)
MutableFixedVector(iter)

MutableFixedVector{N,T}(undef)

MutableFixedVector{N,T} is a mutable vector type that holds exactly N elements of type T. (It is analogous to StaticArrays.MVector and StaticVectors.Variables.) The size N can be any (small) positive integer. However, at least for bit integer and hardware float types, one usually takes N to be a power of 2.

If the element type T or the size N are omitted, they are determined from the iterator given as argument. Performance degrades if this is not possible at compile time. As a rule of thumb, the size should only be omitted for Tuple arguments.

Note that setting individual vector elements (via setindex!) is only supported for isbits element types.

The special form MutableFixedVector{N,T}(undef) returns a non-initialized vector.

See also FixedVector, Base.isbitstype.

source

FixedVector(v::StaticVector{N,T}) where {N,T} -> FixedVector{N,T}
MutableFixedVector(v::StaticVector{N,T}) where {N,T} -> MutableFixedVector{N,T}

Convert a StaticVector to a FixedVector or MutableFixedVector. The length N is inferred from the given vector v. For example, v can be an SVector or MVector.

These methods are only available if the package StaticArrays.jl is loaded.

See also AbstractFixedVector, StaticArrays.StaticVector.

source

SmallCollections.fixedvector — Method

fixedvector(v::AbstractFixedVector{N,T}) where {N,T} -> FixedVector{N,T}

Returns the argument as a FixedVector. The purpose of this function is to make is easier to write code that works for both AbstractFixedVector and AbstractSmallVector.

source

SmallCollections.bits — Method

bits(v::AbstractFixedVector{N,T}) where {N, T <: Union{Base.HWReal, Bool, Char, Enum}} -> Unsigned

Convert the given vector to an unsigned integer.

For bit integers, hardware floats, Char and Enum types this is the same as reinterpret(U, Tuple(v)) provided that U is an unsigned integer type with N*bitsize(T) bits, possibly defined by the package BitIntegers. Otherwise the result will be zero-extended to the next unsigned integer type U whose bit length is a power of 2.

If the element type is Bool, then each element only takes one bit in the return value. If N is less than 8 or not a power of 2, then the result will again be zero-extended.

The inverse operation can be done with convert.

See also Base.convert, SmallCollections.bitsize, Base.HWReal, Base.reinterpret, BitIntegers.

Examples

julia> FixedVector{4,Int8}(1:4) |> bits
0x04030201

julia> FixedVector{3}('a':'c') |> bits
0x00000000630000006200000061000000

julia> m = FixedVector{6,UInt32}(1:6) |> bits
0x0000000000000000000000060000000500000004000000030000000200000001

julia> typeof(m)
BitIntegers.UInt256

julia> FixedVector{22}(map(isodd, 1:22)) |> bits
0x00155555

source

Base.convert — Method

convert(::Type{V}, x::Unsigned) where {N, T <: Union{Base.HWReal, Bool, Char, Enum}, V <: AbstractFixedVector{N,T}}

Convert the unsigned integer x to a FixedVector{N,T} or MutableFixedVector{N,T}. The bits of x are split into groups of size bitsize(T) and reinterpreted as elements of type T. Unused bits are ignored and missing bits are taken as 0. This is the inverse operation to bits.

See also bits, SmallCollections.bitsize, Base.HWReal, BitIntegers.

Examples

julia> v = convert(FixedVector{4,Int8}, 0x030201)
4-element FixedVector{4, Int8}:
 1
 2
 3
 0

julia> bits(v)
0x00030201

julia> convert(FixedVector{6,Bool}, 0xf0)
6-element FixedVector{6, Bool}:
 0
 0
 0
 0
 1
 1

julia> x = FixedVector{2,Char}('a':'b') |> bits
0x6200000061000000

julia> convert(FixedVector{2,Char}, x)
2-element FixedVector{2, Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)

julia> using BitIntegers

julia> convert(FixedVector{4,Int64}, uint256"0x300000000000000020000000000000001")
4-element FixedVector{4, Int64}:
 1
 2
 3
 0

source

SmallCollections.fasthash — Method

fasthash(v::AbstractFixedVector [, h0::UInt]) -> UInt

Return a hash for v that may be computed faster than the standard hash for vectors. This new hash is consistent across all AbstractFixedVectors of the same element type, but it may not be compatible with hash or with fasthash for a AbstractFixedVector having a different element type.

Currently, fasthash differs from hash only if the element type of v is a bit integer type with at most 32 bits, Bool or Char.