数组

数组

构造函数与类型

1. AbstractArray{T,N}

Supertype for N-dimensional arrays (or array-like types) with elements of type T. Array and other types are subtypes of this. See the manual section on the AbstractArray interface.

See also: AbstractVector, AbstractMatrix, eltype, ndims.

source

Base.AbstractVector — Type

1. AbstractVector{T}

Supertype for one-dimensional arrays (or array-like types) with elements of type T. Alias for AbstractArray{T,1}.

source

Base.AbstractMatrix — Type

1. AbstractMatrix{T}

Supertype for two-dimensional arrays (or array-like types) with elements of type T. Alias for AbstractArray{T,2}.

source

Base.AbstractVecOrMat — Type

1. AbstractVecOrMat{T}

Union type of AbstractVector{T} and AbstractMatrix{T}.

source

Core.Array — Type

1. Array{T,N} <: AbstractArray{T,N}

N-dimensional dense array with elements of type T.

source

Core.Array — Method

1. Array{T}(undef, dims)
2. Array{T,N}(undef, dims)

Construct an uninitialized N-dimensional Array containing elements of type T. N can either be supplied explicitly, as in Array{T,N}(undef, dims), or be determined by the length or number of dims. dims may be a tuple or a series of integer arguments corresponding to the lengths in each dimension. If the rank N is supplied explicitly, then it must match the length or number of dims. Here undef is the UndefInitializer.

Examples

1. julia> A = Array{Float64, 2}(undef, 2, 3) # N given explicitly
2. 2×3 Matrix{Float64}:
3. 6.90198e-310  6.90198e-310  6.90198e-310
4. 6.90198e-310  6.90198e-310  0.0

6. julia> B = Array{Float64}(undef, 4) # N determined by the input
7. 4-element Vector{Float64}:
8. 2.360075077e-314
9. NaN
10. 2.2671131793e-314
11. 2.299821756e-314

13. julia> similar(B, 2, 4, 1) # use typeof(B), and the given size
14. 2×4×1 Array{Float64, 3}:
15. [:, :, 1] =
16. 2.26703e-314  2.26708e-314  0.0           2.80997e-314
17. 0.0           2.26703e-314  2.26708e-314  0.0

source

Core.Array — Method

1. Array{T}(nothing, dims)
2. Array{T,N}(nothing, dims)

Construct an N-dimensional Array containing elements of type T, initialized with nothing entries. Element type T must be able to hold these values, i.e. Nothing <: T.

Examples

1. julia> Array{Union{Nothing, String}}(nothing, 2)
2. 2-element Vector{Union{Nothing, String}}:
3. nothing
4. nothing

6. julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
7. 2×3 Matrix{Union{Nothing, Int64}}:
8. nothing  nothing  nothing
9. nothing  nothing  nothing

source

Core.Array — Method

1. Array{T}(missing, dims)
2. Array{T,N}(missing, dims)

Construct an N-dimensional Array containing elements of type T, initialized with missing entries. Element type T must be able to hold these values, i.e. Missing <: T.

Examples

1. julia> Array{Union{Missing, String}}(missing, 2)
2. 2-element Vector{Union{Missing, String}}:
3. missing
4. missing

6. julia> Array{Union{Missing, Int}}(missing, 2, 3)
7. 2×3 Matrix{Union{Missing, Int64}}:
8. missing  missing  missing
9. missing  missing  missing

source

Core.UndefInitializer — Type

1. UndefInitializer

Singleton type used in array initialization, indicating the array-constructor-caller would like an uninitialized array. See also undef, an alias for UndefInitializer().

Examples

1. julia> Array{Float64, 1}(UndefInitializer(), 3)
2. 3-element Array{Float64, 1}:
3. 2.2752528595e-314
4. 2.202942107e-314
5. 2.275252907e-314

source

Core.undef — Constant

1. undef

Alias for UndefInitializer(), which constructs an instance of the singleton type UndefInitializer, used in array initialization to indicate the array-constructor-caller would like an uninitialized array.

See also: missing, similar.

Examples

1. julia> Array{Float64, 1}(undef, 3)
2. 3-element Vector{Float64}:
3. 2.2752528595e-314
4. 2.202942107e-314
5. 2.275252907e-314

source

Base.Vector — Type

1. Vector{T} <: AbstractVector{T}

One-dimensional dense array with elements of type T, often used to represent a mathematical vector. Alias for Array{T,1}.

See also empty, similar and zero for creating vectors.

source

Base.Vector — Method

1. Vector{T}(undef, n)

Construct an uninitialized Vector{T} of length n.

Examples

1. julia> Vector{Float64}(undef, 3)
2. 3-element Array{Float64, 1}:
3. 6.90966e-310
4. 6.90966e-310
5. 6.90966e-310

source

Base.Vector — Method

1. Vector{T}(nothing, m)

Construct a Vector{T} of length m, initialized with nothing entries. Element type T must be able to hold these values, i.e. Nothing <: T.

Examples

1. julia> Vector{Union{Nothing, String}}(nothing, 2)
2. 2-element Vector{Union{Nothing, String}}:
3. nothing
4. nothing

source

Base.Vector — Method

1. Vector{T}(missing, m)

Construct a Vector{T} of length m, initialized with missing entries. Element type T must be able to hold these values, i.e. Missing <: T.

Examples

1. julia> Vector{Union{Missing, String}}(missing, 2)
2. 2-element Vector{Union{Missing, String}}:
3. missing
4. missing

source

Base.Matrix — Type

1. Matrix{T} <: AbstractMatrix{T}

Two-dimensional dense array with elements of type T, often used to represent a mathematical matrix. Alias for Array{T,2}.

See also fill, zeros, undef and similar for creating matrices.

source

Base.Matrix — Method

1. Matrix{T}(undef, m, n)

Construct an uninitialized Matrix{T} of size m×n.

Examples

1. julia> Matrix{Float64}(undef, 2, 3)
2. 2×3 Array{Float64, 2}:
3. 2.36365e-314  2.28473e-314    5.0e-324
4. 2.26704e-314  2.26711e-314  NaN

6. julia> similar(ans, Int32, 2, 2)
7. 2×2 Matrix{Int32}:
8. 490537216  1277177453
9. 1  1936748399

source

Base.Matrix — Method

1. Matrix{T}(nothing, m, n)

Construct a Matrix{T} of size m×n, initialized with nothing entries. Element type T must be able to hold these values, i.e. Nothing <: T.

Examples

1. julia> Matrix{Union{Nothing, String}}(nothing, 2, 3)
2. 2×3 Matrix{Union{Nothing, String}}:
3. nothing  nothing  nothing
4. nothing  nothing  nothing

source

Base.Matrix — Method

1. Matrix{T}(missing, m, n)

Construct a Matrix{T} of size m×n, initialized with missing entries. Element type T must be able to hold these values, i.e. Missing <: T.

Examples

1. julia> Matrix{Union{Missing, String}}(missing, 2, 3)
2. 2×3 Matrix{Union{Missing, String}}:
3. missing  missing  missing
4. missing  missing  missing

source

Base.VecOrMat — Type

1. VecOrMat{T}

Union type of Vector{T} and Matrix{T} which allows functions to accept either a Matrix or a Vector.

Examples

1. julia> Vector{Float64} <: VecOrMat{Float64}
2. true

4. julia> Matrix{Float64} <: VecOrMat{Float64}
5. true

7. julia> Array{Float64, 3} <: VecOrMat{Float64}
8. false

source

Core.DenseArray — Type

1. DenseArray{T, N} <: AbstractArray{T,N}

N-dimensional dense array with elements of type T. The elements of a dense array are stored contiguously in memory.

source

Base.DenseVector — Type

1. DenseVector{T}

One-dimensional DenseArray with elements of type T. Alias for DenseArray{T,1}.

source

Base.DenseMatrix — Type

1. DenseMatrix{T}

Two-dimensional DenseArray with elements of type T. Alias for DenseArray{T,2}.

source

Base.DenseVecOrMat — Type

1. DenseVecOrMat{T}

Union type of DenseVector{T} and DenseMatrix{T}.

source

Base.StridedArray — Type

1. StridedArray{T, N}

A hard-coded Union of common array types that follow the strided array interface, with elements of type T and N dimensions.

If A is a StridedArray, then its elements are stored in memory with offsets, which may vary between dimensions but are constant within a dimension. For example, A could have stride 2 in dimension 1, and stride 3 in dimension 2. Incrementing A along dimension d jumps in memory by [strides(A, d)] slots. Strided arrays are particularly important and useful because they can sometimes be passed directly as pointers to foreign language libraries like BLAS.

source

Base.StridedVector — Type

1. StridedVector{T}

One dimensional StridedArray with elements of type T.

source

Base.StridedMatrix — Type

1. StridedMatrix{T}

Two dimensional StridedArray with elements of type T.

source

Base.StridedVecOrMat — Type

1. StridedVecOrMat{T}

Union type of StridedVector and StridedMatrix with elements of type T.

source

Base.getindex — Method

1. getindex(type[, elements...])

Construct a 1-d array of the specified type. This is usually called with the syntax Type[]. Element values can be specified using Type[a,b,c,...].

Examples

1. julia> Int8[1, 2, 3]
2. 3-element Vector{Int8}:
3. 1
4. 2
5. 3

7. julia> getindex(Int8, 1, 2, 3)
8. 3-element Vector{Int8}:
9. 1
10. 2
11. 3

source

Base.zeros — Function

1. zeros([T=Float64,] dims::Tuple)
2. zeros([T=Float64,] dims...)

Create an Array, with element type T, of all zeros with size specified by dims. See also fill, ones, zero.

Examples

1. julia> zeros(1)
2. 1-element Vector{Float64}:
3. 0.0

5. julia> zeros(Int8, 2, 3)
6. 2×3 Matrix{Int8}:
7. 0  0  0
8. 0  0  0

source

Base.ones — Function

1. ones([T=Float64,] dims::Tuple)
2. ones([T=Float64,] dims...)

Create an Array, with element type T, of all ones with size specified by dims. See also fill, zeros.

Examples

1. julia> ones(1,2)
2. 1×2 Matrix{Float64}:
3. 1.0  1.0

5. julia> ones(ComplexF64, 2, 3)
6. 2×3 Matrix{ComplexF64}:
7. 1.0+0.0im  1.0+0.0im  1.0+0.0im
8. 1.0+0.0im  1.0+0.0im  1.0+0.0im

source

Base.BitArray — Type

1. BitArray{N} <: AbstractArray{Bool, N}

Space-efficient N-dimensional boolean array, using just one bit for each boolean value.

BitArrays pack up to 64 values into every 8 bytes, resulting in an 8x space efficiency over Array{Bool, N} and allowing some operations to work on 64 values at once.

By default, Julia returns BitArrays from broadcasting operations that generate boolean elements (including dotted-comparisons like .==) as well as from the functions trues and falses.

Note

Due to its packed storage format, concurrent access to the elements of a BitArray where at least one of them is a write is not thread safe.

source

Base.BitArray — Method

1. BitArray(undef, dims::Integer...)
2. BitArray{N}(undef, dims::NTuple{N,Int})

Construct an undef BitArray with the given dimensions. Behaves identically to the Array constructor. See undef.

Examples

1. julia> BitArray(undef, 2, 2)
2. 2×2 BitMatrix:
3. 0  0
4. 0  0

6. julia> BitArray(undef, (3, 1))
7. 3×1 BitMatrix:
8. 0
9. 0
10. 0

source

Base.BitArray — Method

1. BitArray(itr)

Construct a BitArray generated by the given iterable object. The shape is inferred from the itr object.

Examples

1. julia> BitArray([1 0; 0 1])
2. 2×2 BitMatrix:
3. 1  0
4. 0  1

6. julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
7. 2×3 BitMatrix:
8. 0  1  0
9. 1  0  0

11. julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
12. 6-element BitVector:
13. 0
14. 1
15. 0
16. 1
17. 0
18. 0

source

Base.trues — Function

1. trues(dims)

Create a BitArray with all values set to true.

Examples

1. julia> trues(2,3)
2. 2×3 BitMatrix:
3. 1  1  1
4. 1  1  1

source

Base.falses — Function

1. falses(dims)

Create a BitArray with all values set to false.

Examples

1. julia> falses(2,3)
2. 2×3 BitMatrix:
3. 0  0  0
4. 0  0  0

source

Base.fill — Function

1. fill(x, dims::Tuple)
2. fill(x, dims...)

Create an array filled with the value x. For example, fill(1.0, (5,5)) returns a 5×5 array of floats, with each element initialized to 1.0.

dims may be specified as either a tuple or a sequence of arguments. For example, the common idiom fill(x) creates a zero-dimensional array containing the single value x.

基础函数

Base.ndims — Function

1. ndims(A::AbstractArray) -> Integer

Return the number of dimensions of A.

广播与矢量化

也可参照 dot syntax for vectorizing functions；例如，f.(args...) 隐式调用 broadcast(f, args...)。与其依赖如 sin 函数的“已矢量化”方法，你应该使用 sin.(a) 来使用broadcast来矢量化。

Base.Broadcast.broadcast — Function

1. broadcast(f, As...)

Broadcast the function f over the arrays, tuples, collections, Refs and/or scalars As.

Broadcasting applies the function f over the elements of the container arguments and the scalars themselves in As. Singleton and missing dimensions are expanded to match the extents of the other arguments by virtually repeating the value. By default, only a limited number of types are considered scalars, including Numbers, Strings, Symbols, Types, Functions and some common singletons like missing and nothing. All other arguments are iterated over or indexed into elementwise.

The resulting container type is established by the following rules:

If all the arguments are scalars or zero-dimensional arrays, it returns an unwrapped scalar.
If at least one argument is a tuple and all others are scalars or zero-dimensional arrays, it returns a tuple.
All other combinations of arguments default to returning an Array, but custom container types can define their own implementation and promotion-like rules to customize the result when they appear as arguments.

A special syntax exists for broadcasting: f.(args...) is equivalent to broadcast(f, args...), and nested f.(g.(args...)) calls are fused into a single broadcast loop.

Examples

1. julia> A = [1, 2, 3, 4, 5]
2. 5-element Vector{Int64}:
3. 1
4. 2
5. 3
6. 4
7. 5

9. julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
10. 5×2 Matrix{Int64}:
11. 1   2
12. 3   4
13. 5   6
14. 7   8
15. 9  10

17. julia> broadcast(+, A, B)
18. 5×2 Matrix{Int64}:
19. 2   3
20. 5   6
21. 8   9
22. 11  12
23. 14  15

25. julia> parse.(Int, ["1", "2"])
26. 2-element Vector{Int64}:
27. 1
28. 2

30. julia> abs.((1, -2))
31. (1, 2)

33. julia> broadcast(+, 1.0, (0, -2.0))
34. (1.0, -1.0)

36. julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
37. 2-element Vector{Vector{Int64}}:
38. [1, 1]
39. [2, 2]

41. julia> string.(("one","two","three","four"), ": ", 1:4)
42. 4-element Vector{String}:
43. "one: 1"
44. "two: 2"
45. "three: 3"
46. "four: 4"

source

Base.Broadcast.broadcast! — Function

1. broadcast!(f, dest, As...)

Like broadcast, but store the result of broadcast(f, As...) in the dest array. Note that dest is only used to store the result, and does not supply arguments to f unless it is also listed in the As, as in broadcast!(f, A, A, B) to perform A[:] = broadcast(f, A, B).

Examples

1. julia> A = [1.0; 0.0]; B = [0.0; 0.0];

3. julia> broadcast!(+, B, A, (0, -2.0));

5. julia> B
6. 2-element Vector{Float64}:
7. 1.0
8. -2.0

10. julia> A
11. 2-element Vector{Float64}:
12. 1.0
13. 0.0

15. julia> broadcast!(+, A, A, (0, -2.0));

17. julia> A
18. 2-element Vector{Float64}:
19. 1.0
20. -2.0

source

Base.Broadcast.@__dot__ — Macro

1. @. expr

Convert every function call or operator in expr into a “dot call” (e.g. convert f(x) to f.(x)), and convert every assignment in expr to a “dot assignment” (e.g. convert += to .+=).

If you want to avoid adding dots for selected function calls in expr, splice those function calls in with $. For example, @. sqrt(abs($sort(x))) is equivalent to sqrt.(abs.(sort(x))) (no dot for sort).

(@. is equivalent to a call to @__dot__.)

Examples

1. julia> x = 1.0:3.0; y = similar(x);

3. julia> @. y = x + 3 * sin(x)
4. 3-element Vector{Float64}:
5. 3.5244129544236893
6. 4.727892280477045
7. 3.4233600241796016

source

自定义类型的广播，请参照

Base.Broadcast.BroadcastStyle — Type

BroadcastStyle is an abstract type and trait-function used to determine behavior of objects under broadcasting. BroadcastStyle(typeof(x)) returns the style associated with x. To customize the broadcasting behavior of a type, one can declare a style by defining a type/method pair

1. struct MyContainerStyle <: BroadcastStyle end
2. Base.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

One then writes method(s) (at least similar) operating on Broadcasted{MyContainerStyle}. There are also several pre-defined subtypes of BroadcastStyle that you may be able to leverage; see the Interfaces chapter for more information.

source

Base.Broadcast.AbstractArrayStyle — Type

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle is the abstract supertype for any style associated with an AbstractArray type. The N parameter is the dimensionality, which can be handy for AbstractArray types that only support specific dimensionalities:

1. struct SparseMatrixStyle <: Broadcast.AbstractArrayStyle{2} end
2. Base.BroadcastStyle(::Type{<:SparseMatrixCSC}) = SparseMatrixStyle()

For AbstractArray types that support arbitrary dimensionality, N can be set to Any:

1. struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
2. Base.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

In cases where you want to be able to mix multiple AbstractArrayStyles and keep track of dimensionality, your style needs to support a Val constructor:

1. struct MyArrayStyleDim{N} <: Broadcast.AbstractArrayStyle{N} end
2. (::Type{<:MyArrayStyleDim})(::Val{N}) where N = MyArrayStyleDim{N}()

Note that if two or more AbstractArrayStyle subtypes conflict, broadcasting machinery will fall back to producing Arrays. If this is undesirable, you may need to define binary BroadcastStyle rules to control the output type.