Skip to content

Commit 691d04d

Browse files
stevengjstevengj
committed
eliminate StoredArray, rename DenseArray -> RegularArray (fix JuliaLang#6212, JuliaLang#987); UniformScaling is no longer an AbstractArray (JuliaLang#5810)
1 parent c81664a commit 691d04d

20 files changed

+87
-79
lines changed

‎NEWS.md

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,9 +12,9 @@ New language features
1212
* Default "inner" constructors now accept any arguments. Constructors that
1313
look like `MyType(a, b) = new(a, b)` can and should be removed ([#4026]).
1414

15-
* Expanded array type hierarchy, including ``StoredArray`` for all
16-
container-like arrays, and ``DenseArray`` for in-memory arrays with
17-
standard strided storage ([#987], [#2345]).
15+
* Expanded array type hierarchy, including ``RegularArray`` for
16+
in-memory arrays with standard strided storage ([#987], [#2345],
17+
[#6212]).
1818

1919
* When reloading code, types whose definitions have not changed can be
2020
ignored in some cases.

‎base/abstractarray.jl

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -163,7 +163,7 @@ function squeeze(A::AbstractArray, dims)
163163
reshape(A, d)
164164
end
165165

166-
function copy!(dest::StoredArray, src)
166+
function copy!(dest::AbstractArray, src)
167167
i = 1
168168
for x in src
169169
dest[i] = x
@@ -174,7 +174,7 @@ end
174174

175175
# copy with minimal requirements on src
176176
# if src is not an AbstractArray, moving to the offset might be O(n)
177-
function copy!(dest::StoredArray, doffs::Integer, src, soffs::Integer=1)
177+
function copy!(dest::AbstractArray, doffs::Integer, src, soffs::Integer=1)
178178
st = start(src)
179179
for j = 1:(soffs-1)
180180
_, st = next(src, st)
@@ -191,13 +191,13 @@ end
191191
# NOTE: this is to avoid ambiguity with the deprecation of
192192
# copy!(dest::AbstractArray, src, doffs::Integer)
193193
# Remove this when that deprecation is removed.
194-
function copy!(dest::StoredArray, doffs::Integer, src::Integer)
194+
function copy!(dest::AbstractArray, doffs::Integer, src::Integer)
195195
dest[doffs] = src
196196
return dest
197197
end
198198

199199
# this method must be separate from the above since src might not have a length
200-
function copy!(dest::StoredArray, doffs::Integer, src, soffs::Integer, n::Integer)
200+
function copy!(dest::AbstractArray, doffs::Integer, src, soffs::Integer, n::Integer)
201201
n == 0 && return dest
202202
st = start(src)
203203
for j = 1:(soffs-1)
@@ -212,7 +212,7 @@ function copy!(dest::StoredArray, doffs::Integer, src, soffs::Integer, n::Intege
212212
end
213213

214214
# if src is an AbstractArray and a source offset is passed, use indexing
215-
function copy!(dest::StoredArray, doffs::Integer, src::AbstractArray, soffs::Integer, n::Integer=length(src))
215+
function copy!(dest::AbstractArray, doffs::Integer, src::AbstractArray, soffs::Integer, n::Integer=length(src))
216216
for i = 0:(n-1)
217217
dest[doffs+i] = src[soffs+i]
218218
end
@@ -248,9 +248,9 @@ for (f,t) in ((:char, Char),
248248
(:uint128,Uint128))
249249
@eval begin
250250
($f)(x::AbstractArray{$t}) = x
251-
($f)(x::StoredArray{$t}) = x
251+
($f)(x::AbstractArray{$t}) = x
252252

253-
function ($f)(x::StoredArray)
253+
function ($f)(x::AbstractArray)
254254
y = similar(x,$t)
255255
i = 1
256256
for e in x
@@ -266,9 +266,9 @@ for (f,t) in ((:integer, Integer),
266266
(:unsigned, Unsigned))
267267
@eval begin
268268
($f){T<:$t}(x::AbstractArray{T}) = x
269-
($f){T<:$t}(x::StoredArray{T}) = x
269+
($f){T<:$t}(x::AbstractArray{T}) = x
270270

271-
function ($f)(x::StoredArray)
271+
function ($f)(x::AbstractArray)
272272
y = similar(x,typeof(($f)(one(eltype(x)))))
273273
i = 1
274274
for e in x
@@ -1228,7 +1228,7 @@ end
12281228

12291229

12301230
## 1 argument
1231-
function map_to!(f::Callable, first, dest::StoredArray, A::AbstractArray)
1231+
function map_to!(f::Callable, first, dest::AbstractArray, A::AbstractArray)
12321232
dest[1] = first
12331233
for i=2:length(A)
12341234
dest[i] = f(A[i])
@@ -1244,7 +1244,7 @@ function map(f::Callable, A::AbstractArray)
12441244
end
12451245

12461246
## 2 argument
1247-
function map_to!(f::Callable, first, dest::StoredArray, A::AbstractArray, B::AbstractArray)
1247+
function map_to!(f::Callable, first, dest::AbstractArray, A::AbstractArray, B::AbstractArray)
12481248
dest[1] = first
12491249
for i=2:length(A)
12501250
dest[i] = f(A[i], B[i])
@@ -1263,7 +1263,7 @@ function map(f::Callable, A::AbstractArray, B::AbstractArray)
12631263
end
12641264

12651265
## N argument
1266-
function map_to!(f::Callable, first, dest::StoredArray, As::AbstractArray...)
1266+
function map_to!(f::Callable, first, dest::AbstractArray, As::AbstractArray...)
12671267
n = length(As[1])
12681268
i = 1
12691269
ith = a->a[i]

‎base/array.jl

Lines changed: 12 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -4,14 +4,13 @@ typealias Vector{T} Array{T,1}
44
typealias Matrix{T} Array{T,2}
55
typealias VecOrMat{T} Union(Vector{T}, Matrix{T})
66

7-
typealias DenseVector{T} DenseArray{T,1}
8-
typealias DenseMatrix{T} DenseArray{T,2}
9-
typealias DenseVecOrMat{T} Union(DenseVector{T}, DenseMatrix{T})
10-
11-
typealias StoredVector{T} StoredArray{T,1}
12-
typealias StridedArray{T,N,A<:DenseArray} Union(DenseArray{T,N}, SubArray{T,N,A})
13-
typealias StridedVector{T,A<:DenseArray} Union(DenseArray{T,1}, SubArray{T,1,A})
14-
typealias StridedMatrix{T,A<:DenseArray} Union(DenseArray{T,2}, SubArray{T,2,A})
7+
typealias RegularVector{T} RegularArray{T,1}
8+
typealias RegularMatrix{T} RegularArray{T,2}
9+
typealias RegularVecOrMat{T} Union(RegularVector{T}, RegularMatrix{T})
10+
11+
typealias StridedArray{T,N,A<:RegularArray} Union(RegularArray{T,N}, SubArray{T,N,A})
12+
typealias StridedVector{T,A<:RegularArray} Union(RegularArray{T,1}, SubArray{T,1,A})
13+
typealias StridedMatrix{T,A<:RegularArray} Union(RegularArray{T,2}, SubArray{T,2,A})
1514
typealias StridedVecOrMat{T} Union(StridedVector{T}, StridedMatrix{T})
1615

1716
## Basic functions ##
@@ -689,7 +688,7 @@ end
689688

690689
## Unary operators ##
691690

692-
function conj!{T<:Number}(A::StoredArray{T})
691+
function conj!{T<:Number}(A::AbstractArray{T})
693692
for i=1:length(A)
694693
A[i] = conj(A[i])
695694
end
@@ -994,7 +993,7 @@ end
994993
rotr90(A::AbstractMatrix, k::Integer) = rotl90(A,-k)
995994
rot180(A::AbstractMatrix, k::Integer) = mod(k, 2) == 1 ? rot180(A) : copy(A)
996995

997-
# note: probably should be StridedVector or StoredVector
996+
# note: probably should be StridedVector or AbstractVector
998997
function reverse(A::AbstractVector, s=1, n=length(A))
999998
B = similar(A)
1000999
for i = 1:s-1
@@ -1392,7 +1391,7 @@ _cumsum_type(v) = typeof(v[1]+v[1])
13921391
for (f, fp, op) = ((:cumsum, :cumsum_pairwise, :+),
13931392
(:cumprod, :cumprod_pairwise, :*) )
13941393
# in-place cumsum of c = s+v(i1:n), using pairwise summation as for sum
1395-
@eval function ($fp)(v::StoredVector, c::StoredVector, s, i1, n)
1394+
@eval function ($fp)(v::AbstractVector, c::AbstractVector, s, i1, n)
13961395
if n < 128
13971396
@inbounds c[i1] = ($op)(s, v[i1])
13981397
for i = i1+1:i1+n-1
@@ -1405,7 +1404,7 @@ for (f, fp, op) = ((:cumsum, :cumsum_pairwise, :+),
14051404
end
14061405
end
14071406

1408-
@eval function ($f)(v::StoredVector)
1407+
@eval function ($f)(v::AbstractVector)
14091408
n = length(v)
14101409
c = $(op===:+ ? (:(similar(v,_cumsum_type(v)))) :
14111410
(:(similar(v))))
@@ -1445,7 +1444,7 @@ for (f, fp, op) = ((:cumsum, :cumsum_pairwise, :+),
14451444
end
14461445

14471446
for (f, op) = ((:cummin, :min), (:cummax, :max))
1448-
@eval function ($f)(v::StoredVector)
1447+
@eval function ($f)(v::AbstractVector)
14491448
n = length(v)
14501449
cur_val = v[1]
14511450
res = similar(v, n)

‎base/bitarray.jl

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ num_bit_chunks(n::Int) = @_div64 (n+63)
1111

1212
# notes: bits are stored in contiguous chunks
1313
# unused bits must always be set to 0
14-
type BitArray{N} <: DenseArray{Bool, N}
14+
type BitArray{N} <: AbstractArray{Bool, N}
1515
chunks::Vector{Uint64}
1616
len::Int
1717
dims::NTuple{N,Int}

‎base/boot.jl

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -46,10 +46,9 @@
4646
#end
4747

4848
#abstract AbstractArray{T,N}
49-
#abstract StoredArray{T,N} <: AbstractArray{T,N}
50-
#abstract DenseArray{T,N} <: StoredArray{T,N}
49+
#abstract RegularArray{T,N} <: AbstractArray{T,N}
5150

52-
#type Array{T,N} <: DenseArray{T,N}
51+
#type Array{T,N} <: RegularArray{T,N}
5352
#end
5453

5554
#type Module
@@ -118,7 +117,7 @@ export
118117
# key types
119118
Any, DataType, Vararg, ANY, NTuple, None, Top,
120119
Tuple, Type, TypeConstructor, TypeName, TypeVar, Union, UnionType, Void,
121-
AbstractArray, StoredArray, DenseArray,
120+
AbstractArray, RegularArray,
122121
# special objects
123122
Box, Function, IntrinsicFunction, LambdaStaticData, Method, MethodTable,
124123
Module, Nothing, Symbol, Task, Array,

‎base/darray.jl

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
type DArray{T,N,A} <: StoredArray{T,N}
1+
type DArray{T,N,A} <: AbstractArray{T,N}
22
dims::NTuple{N,Int}
33

44
chunks::Array{RemoteRef,N}

‎base/exports.jl

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -38,9 +38,9 @@ export
3838
Complex64,
3939
Complex32,
4040
DArray,
41-
DenseMatrix,
42-
DenseVecOrMat,
43-
DenseVector,
41+
RegularMatrix,
42+
RegularVecOrMat,
43+
RegularVector,
4444
DevNull,
4545
Diagonal,
4646
Dict,

‎base/linalg/diagonal.jl

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,13 @@ size(D::Diagonal,d::Integer) = d<1 ? error("dimension out of range") : (d<=2 ? l
1313
full(D::Diagonal) = diagm(D.diag)
1414
getindex(D::Diagonal, i::Integer, j::Integer) = i == j ? D.diag[i] : zero(eltype(D.diag))
1515

16+
function getindex(D::Diagonal, i::Integer)
17+
n = length(D.diag)
18+
id = div(i-1, n)
19+
id + id * n == i-1 && return D.diag[id+1]
20+
zero(eltype(D.diag))
21+
end
22+
1623
ishermitian(D::Diagonal) = true
1724
issym(D::Diagonal) = true
1825
isposdef(D::Diagonal) = all(D.diag .> 0)

‎base/linalg/uniformscaling.jl

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,13 @@
11
import Base: +, -, *, /, copy, ctranspose, getindex, showarray, transpose
22
import Base.LinAlg: SingularException
3-
immutable UniformScaling{T<:Number} <: AbstractMatrix{T}
3+
immutable UniformScaling{T<:Number}
44
λ::T
55
end
66

77
const I = UniformScaling(1)
88

9+
eltype{T}(J::UniformScaling{T}) = T
10+
ndims(J::UniformScaling) = 2
911
getindex(J::UniformScaling, i::Integer,j::Integer) = ifelse(i==j,J.λ,zero(J.λ))
1012

1113
showarray(io::IO,J::UniformScaling;kw...) = print(io,"$(typeof(J))\n$(J.λ)*I")

‎base/multidimensional.jl

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -132,14 +132,14 @@ eval(ngenerate(:N, nothing, :(setindex!{T}(s::SubArray{T,N}, v, ind::Integer)),
132132

133133
### from abstractarray.jl
134134

135-
@ngenerate N typeof(A) function fill!{T,N}(A::StoredArray{T,N}, x)
135+
@ngenerate N typeof(A) function fill!{T,N}(A::AbstractArray{T,N}, x)
136136
@nloops N i A begin
137137
@inbounds (@nref N A i) = x
138138
end
139139
A
140140
end
141141

142-
@ngenerate N typeof(dest) function copy!{T,N}(dest::StoredArray{T,N}, src::StoredArray{T,N})
142+
@ngenerate N typeof(dest) function copy!{T,N}(dest::AbstractArray{T,N}, src::AbstractArray{T,N})
143143
if @nall N d->(size(dest,d) == size(src,d))
144144
@nloops N i dest begin
145145
@inbounds (@nref N dest i) = (@nref N src i)

‎base/sharedarray.jl

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
type SharedArray{T,N} <: DenseArray{T,N}
1+
type SharedArray{T,N} <: AbstractArray{T,N}
22
dims::NTuple{N,Int}
33
pids::Vector{Int}
44
refs::Array{RemoteRef}

‎base/statistics.jl

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -147,7 +147,7 @@ function sturges(n) # Sturges' formula
147147
iceil(log2(n))+1
148148
end
149149

150-
function hist!{HT}(h::StoredArray{HT}, v::AbstractVector, edg::AbstractVector; init::Bool=true)
150+
function hist!{HT}(h::AbstractArray{HT}, v::AbstractVector, edg::AbstractVector; init::Bool=true)
151151
n = length(edg) - 1
152152
length(h) == n || error("length(h) must equal length(edg) - 1.")
153153
if init
@@ -166,7 +166,7 @@ hist(v::AbstractVector, edg::AbstractVector) = hist!(Array(Int, length(edg)-1),
166166
hist(v::AbstractVector, n::Integer) = hist(v,histrange(v,n))
167167
hist(v::AbstractVector) = hist(v,sturges(length(v)))
168168

169-
function hist!{HT}(H::StoredArray{HT,2}, A::AbstractMatrix, edg::AbstractVector; init::Bool=true)
169+
function hist!{HT}(H::AbstractArray{HT,2}, A::AbstractMatrix, edg::AbstractVector; init::Bool=true)
170170
m, n = size(A)
171171
size(H) == (length(edg)-1, n) || error("Incorrect size of H.")
172172
if init
@@ -184,7 +184,7 @@ hist(A::AbstractMatrix) = hist(A,sturges(size(A,1)))
184184

185185

186186
## hist2d
187-
function hist2d!{HT}(H::StoredArray{HT,2}, v::AbstractMatrix,
187+
function hist2d!{HT}(H::AbstractArray{HT,2}, v::AbstractMatrix,
188188
edg1::AbstractVector, edg2::AbstractVector; init::Bool=true)
189189
size(v,2) == 2 || error("hist2d requires an Nx2 matrix.")
190190
n = length(edg1) - 1

‎base/subarray.jl

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22

33
typealias RangeIndex Union(Int, Range{Int}, Range1{Int})
44

5-
type SubArray{T,N,A<:StoredArray,I<:(RangeIndex...,)} <: StoredArray{T,N}
5+
type SubArray{T,N,A<:AbstractArray,I<:(RangeIndex...,)} <: AbstractArray{T,N}
66
parent::A
77
indexes::I
88
dims::NTuple{N,Int}

‎base/test.jl

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ macro test_fails(ex)
6161
:(@test_throws $ex)
6262
end
6363

64-
approx_full(x::StoredArray) = x
64+
approx_full(x::AbstractArray) = x
6565
approx_full(x::Number) = x
6666
approx_full(x) = full(x)
6767

‎contrib/julia-mode.el

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@
7777
].* \\(in\\)\\(\\s-\\|$\\)+")
7878

7979
(defconst julia-font-lock-keywords
80-
(list '("\\<\\(\\|Uint\\(8\\|16\\|32\\|64\\|128\\)\\|Int\\(8\\|16\\|32\\|64\\|128\\)\\|BigInt\\|Integer\\|BigFloat\\|FloatingPoint\\|Float16\\|Float32\\|Float64\\|Complex128\\|Complex64\\|ComplexPair\\|Bool\\|Char\\|DataType\\|Number\\|Real\\|Int\\|Uint\\|Array\\|DArray\\|AbstractArray\\|AbstractVector\\|AbstractMatrix\\|AbstractSparseMatrix\\|SubArray\\|StridedArray\\|StridedVector\\|StridedMatrix\\|VecOrMat\\|StridedVecOrMat\\|StoredArray\\|DenseArray\\|Range\\|Range1\\|SparseMatrixCSC\\|Tuple\\|NTuple\\|Symbol\\|Function\\|Vector\\|Matrix\\|Union\\|Type\\|Any\\|Complex\\|None\\|String\\|Ptr\\|Void\\|Exception\\|Task\\|Signed\\|Unsigned\\|Associative\\|Dict\\|IO\\|IOStream\\|Ranges\\|Rational\\|Regex\\|RegexMatch\\|Set\\|IntSet\\|ASCIIString\\|UTF8String\\|ByteString\\|Expr\\|WeakRef\\|Nothing\\|ObjectIdDict\\|SubString\\)\\>" .
80+
(list '("\\<\\(\\|Uint\\(8\\|16\\|32\\|64\\|128\\)\\|Int\\(8\\|16\\|32\\|64\\|128\\)\\|BigInt\\|Integer\\|BigFloat\\|FloatingPoint\\|Float16\\|Float32\\|Float64\\|Complex128\\|Complex64\\|ComplexPair\\|Bool\\|Char\\|DataType\\|Number\\|Real\\|Int\\|Uint\\|Array\\|DArray\\|AbstractArray\\|AbstractVector\\|AbstractMatrix\\|AbstractSparseMatrix\\|SubArray\\|StridedArray\\|StridedVector\\|StridedMatrix\\|VecOrMat\\|StridedVecOrMat\\|RegularArray\\|Range\\|Range1\\|SparseMatrixCSC\\|Tuple\\|NTuple\\|Symbol\\|Function\\|Vector\\|Matrix\\|Union\\|Type\\|Any\\|Complex\\|None\\|String\\|Ptr\\|Void\\|Exception\\|Task\\|Signed\\|Unsigned\\|Associative\\|Dict\\|IO\\|IOStream\\|Ranges\\|Rational\\|Regex\\|RegexMatch\\|Set\\|IntSet\\|ASCIIString\\|UTF8String\\|ByteString\\|Expr\\|WeakRef\\|Nothing\\|ObjectIdDict\\|SubString\\)\\>" .
8181
font-lock-type-face)
8282
(cons
8383
(concat "\\<\\("

‎doc/manual/arrays.rst

Lines changed: 22 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -391,8 +391,8 @@ Implementation
391391
--------------
392392

393393
The base array type in Julia is the abstract type
394-
``AbstractArray{T,n}``. It is parametrized by the number of dimensions
395-
``n`` and the element type ``T``. ``AbstractVector`` and
394+
``AbstractArray{T,N}``. It is parametrized by the number of dimensions
395+
``N`` and the element type ``T``. ``AbstractVector`` and
396396
``AbstractMatrix`` are aliases for the 1-d and 2-d cases. Operations on
397397
``AbstractArray`` objects are defined using higher level operators and
398398
functions, in a way that is independent of the underlying storage.
@@ -402,25 +402,33 @@ specific array implementation.
402402
The ``AbstractArray`` type includes anything vaguely array-like, and
403403
implementations of it might be quite different from conventional
404404
arrays. For example, elements might be computed on request rather than
405-
stored. Or, it might not be possible to assign or access every array
406-
location.
407-
408-
``StoredArray`` is an abstract subtype of ``AbstractArray`` intended to
409-
include all arrays that behave like memories: all elements are independent,
410-
can be accessed, and (for mutable arrays) all elements can be assigned.
411-
``DenseArray`` is a further abstract subtype of ``StoredArray``. Arrays of
412-
this type have storage for every possible index, and provide uniform access
413-
performance for all elements.
414-
415-
The ``Array{T,n}`` type is a specific instance of ``DenseArray``
405+
stored. However, any concrete ``AbstractArray{T,N}`` type should
406+
generally implement at least ``size(A)`` (returing an ``Int`` tuple),
407+
``getindex(A,i)`` and ``getindex(A,i1,...,iN)`` (returning an element
408+
of type ``T``); mutable arrays should also implement ``setindex!``. It
409+
is recommended that these operations have nearly constant time complexity,
410+
or technically Õ(1) complexity, as otherwise some array functions may
411+
be unexpectedly slow.
412+
413+
``RegularArray`` is an abstract subtype of ``AbstractArray`` intended
414+
to include all arrays that are laid out at regular offsets in memory,
415+
and which can therefore be passed to external C and Fortran functions
416+
expecting this memory layout. Subtypes should provide a method
417+
``stride(A,k)`` that returns the "stride" of dimension ``k``:
418+
increasing the index of dimension ``k`` by ``1`` should increase the
419+
index ``i`` of ``getindex(A,i)`` by ``stride(A,k)``. If a
420+
pointer conversion method ``convert(Ptr{T}, A)`` is provided, the
421+
memory layout should correspond in the same way to these strides.
422+
423+
The ``Array{T,N}`` type is a specific instance of ``RegularArray``
416424
where elements are stored in column-major order (see additional notes in
417425
:ref:`man-performance-tips`). ``Vector`` and ``Matrix`` are aliases for
418426
the 1-d and 2-d cases. Specific operations such as scalar indexing,
419427
assignment, and a few other basic storage-specific operations are all
420428
that have to be implemented for ``Array``, so that the rest of the array
421429
library can be implemented in a generic manner.
422430

423-
``SubArray`` is a specialization of ``StoredArray`` that performs
431+
``SubArray`` is a specialization of ``AbstractArray`` that performs
424432
indexing by reference rather than by copying. A ``SubArray`` is created
425433
with the ``sub`` function, which is called the same way as ``getindex`` (with
426434
an array and a series of index arguments). The result of ``sub`` looks

‎src/builtins.c

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1048,8 +1048,7 @@ void jl_init_primitives(void)
10481048
add_builtin("Task", (jl_value_t*)jl_task_type);
10491049

10501050
add_builtin("AbstractArray", (jl_value_t*)jl_abstractarray_type);
1051-
add_builtin("StoredArray", (jl_value_t*)jl_storedarray_type);
1052-
add_builtin("DenseArray", (jl_value_t*)jl_densearray_type);
1051+
add_builtin("RegularArray", (jl_value_t*)jl_regulararray_type);
10531052
add_builtin("Array", (jl_value_t*)jl_array_type);
10541053

10551054
add_builtin("Expr", (jl_value_t*)jl_expr_type);

0 commit comments

Comments
 (0)