ArrayInitializers

oneinit
oneinit(::Type{T})

Singleton instance of oneInitializer{Any}. The instance can be called with a type argument to create a typed one initializer.

julia> Matrix(oneinit(Rational), 3, 6)
3×6 Matrix{Rational}:
 1//1  1//1  1//1  1//1  1//1  1//1
 1//1  1//1  1//1  1//1  1//1  1//1
 1//1  1//1  1//1  1//1  1//1  1//1

julia> Matrix{Number}(oneinit, 3, 6)
3×6 Matrix{Number}:
 1  1  1  1  1  1
 1  1  1  1  1  1
 1  1  1  1  1  1

randinit

Initialize array with random values.

julia> Array{UInt8}(randinit, 5)
5-element Vector{UInt8}:
 0x91
 0xcb
 0xf0
 0xa5
 0x9e

julia> Array(randinit(1:3), 5)
5-element Vector{Int64}:
 3
 3
 2
 2
 3

julia> ri = randinit(MersenneTwister(1234), Int8)
ArrayInitializers.RNGArrayInitializer{Int8, Type{Int8}, MersenneTwister}(Int8, MersenneTwister(1234))

julia> Matrix(ri, 2, 3)
2×3 Matrix{Int8}:
  -20   75  126
 -105  115  -42

zeroinit
zeroinit(::Type{T})

Singleton instance of ZeroInitializer{Any}. The instance can be called with a type argument to create a typed zero initializer.

julia> Vector{Int}(zeroinit, 5)
5-element Vector{Int64}:
 0
 0
 0
 0
 0

julia> Matrix(zeroinit(Rational), 4, 2)
4×2 Matrix{Rational}:
 0//1  0//1
 0//1  0//1
 0//1  0//1
 0//1  0//1

FillArrayInitializer{T}(value::T)

When passed to an AbstractArray constructor as the first argument, the constructed array will be filled with value via fill!.

OneInitializer{T}

When passed as the first argument of an AbstractArray constructor, fill the constructed array with ones. This will also add a type to an untyped array.

SizedArrayInitializer(initializer, dims)

Array initializer with dimensions. Construct using Base.reshape

julia> twos = init(2)
ArrayInitializers.FillArrayInitializer{Int64}(2)

julia> twos_3x5 = reshape(twos, 3, 5)
ArrayInitializers.SizedArrayInitializer{Int64, ArrayInitializers.FillArrayInitializer{Int64}, Tuple{Int64, Int64}}(ArrayInitializers.FillArrayInitializer{Int64}(2), (3, 5))

julia> Array(twos_3x5)
3×5 Matrix{Int64}:
 2  2  2  2  2
 2  2  2  2  2
 2  2  2  2  2

UndefTypeArrayInitializer{T}

When passed as the first argument of an AbstractArray constructor, confer the type T if the AbstractArray is not typed. The array is not initialized.

See undeftype

ZeroInitializer{T}

When passed as the first argument of an AbstractArray constructor, fill the constructed array with zeros. This will also add a type to an untyped array.

ArrayInitializers.fill!(value)

Alias for ArrayInitializers.init.

julia> import ArrayInitializers: fill!

julia> const fives = fill!(5)
ArrayInitializers.FillArrayInitializer{Int64}(5)

julia> Matrix(fives, 5, 9)
5×9 Matrix{Int64}:
 5  5  5  5  5  5  5  5  5
 5  5  5  5  5  5  5  5  5
 5  5  5  5  5  5  5  5  5
 5  5  5  5  5  5  5  5  5
 5  5  5  5  5  5  5  5  5

init(value::T)

Create a FillArrayInitializer{T}. When passed to an AbstractArray constructor as the first argument, the constructed array will be filled with value via fill!.

Also the result can be called with an array argument. It will fill! the array.

julia> const threes = init(3)
ArrayInitializers.FillArrayInitializer{Int64}(3)

julia> Array(threes, 5)
5-element Vector{Int64}:
 3
 3
 3
 3
 3

julia> const fives! = init(5)
ArrayInitializers.FillArrayInitializer{Int64}(5)

julia> fives!(ones(3))
3-element Vector{Float64}:
 5.0
 5.0
 5.0

undeftype(::Type{T})

When passed as the first argument of an AbstractArray constructor, confer the type T if the AbstractArray is not typed. The array is not initialized.

julia> Matrix(undeftype(Float64), 3, 6)
3×6 Matrix{Float64}:
 1.5e-323      2.0e-323      7.0e-323      2.5e-323      3.5e-323      3.0e-323
 1.0e-323      1.5e-323      2.0e-323      2.0e-323      2.5e-323      2.5e-323
 1.13396e-311  6.95272e-310  6.95272e-310  1.13394e-311  6.95272e-310  6.95272e-310

julia> Matrix(undeftype(Number), 3, 6)
3×6 Matrix{Number}:
 #undef  #undef  #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef  #undef  #undef