It would be nice to have an undefs function that operates the same way as zeros and ones. The syntax for initializing an array of zeros or ones is more concise than initializing an array of undefs but is not as efficient. I know use cases can be different but I’m simply taking about initializing an …

You are advocating a change to Base. If you want to make the case for it, the best way is start with a package and show that it is indispensable. [image] alex-s-gardner: I’m not sure creating a new package really solves the accessibility issue that is being discussed here. A new function undefs …

You should be able to accept dims as a single tuple. julia> A = Array{Int8}(undef, (2,3,4)); julia> B = Array{Int16}(undef, size(A)); See this issue for other thoughts: design of array constructors opened 06:57PM - 13 Nov 17 UTC (UTC) …

In this API there’s no room to say where the memory comes from, we just pull it out of the sky. If I have a block of memory, I might want to split it up and make arrays and dictionaries out of it, e.g. using allocate!(block, Array, Float64, (2,2)).

As I’ve written it here, allocate just forwards all responsibility to Array, which handles the rest. julia> A = allocate(Int8, (2, 3, 4)) 2×3×4 Array{Int8, 3}: [:, :, 1] = 0 0 0 0 0 0 [:, :, 2] = 0 16 -105 0 -63 -84 [:, :, 3] = -6 0 16 127 0 81 [:, :, 4] = -105 -6 0 -8…

[image] jar1: In this API there’s no room to say where the memory comes from, we just pull it out of the sky That’s one direction I thought of going with ArrayAllocators.jl . One could create a BumpAllocator. I still need to think about how to handle garbage collection with that though. This …

[image] uniment: julia> allocate(::Type{A}, ::Type{T}, dims...) where {A,T} = A{T}(undef, dims...) allocate(::Type{T}, dims...) where T = allocate(Array, T, dims...) allocate(dims...) = allocate(Float64, dims...) One thing I’m not a fan of here is that we are peeling off optiona…

[image] mkitti: As Carsten Bauer mentioned, there is a better solution than undefs for the novice user where they can obtain nearly the same performance. This is calloc , a standard C function. On operating systems, there also more specialized methods in the same vein. “Better” is a very subje…

[image] Sukera: No - this only “works” for types where a zero bitpattern also happens to coincide with the zero of that type, as I mentioned in the linked thread: Does Base allocation handle this any differently? julia> struct Foo x::Int Foo() = new(5) end julia>…

I really don’t want to rehash the same conversation again, but undef just happens to give you whatever is in memory. That’s precisely what undef means - there are no constructors involved, ever. julia> struct Foo bar::Int end julia> Base.zero(::Type{Foo}) = Foo(1) julia> zeros(Fo…

That similar can be used to create arrays having non-similar dimensions is not exactly intuitive. Still, the form similar(Float64[], 2,3) may be easier to remember than Array{Float64}(undef, 2, 3) So, thank you :slightly_smiling_face:

[image] Eben60: That similar can be used to create arrays having non-similar dimensions is not exactly intuitive. similar doesn’t refer to similar dimensions specifically. Its meaning is basically “as similar to the passed array as possible”, optionally specifying the target eltype or dimensi…

What about an `undefs` function in `Base`?

General Usage

mkitti January 24, 2023, 10:58am 65

Undefs.jl is now registered:

Topic		Replies	Views
Is accessing an `undef` array undefined behavior? General Usage	47	1596	July 23, 2023
Why does arrayref throw? New to Julia question	89	3607	November 18, 2023
1.0 annoyances and Matlab comparison Internals & Design	148	13993	June 22, 2018
Handy function for making empty arrays Internals & Design	5	778	February 29, 2020
Faster zeros with calloc Performance array	26	4104	March 23, 2022

What about an `undefs` function in `Base`?

Related topics