Arrays

Constructors and Types

Core.AbstractArray — Type.

  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.

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 — Constant.

  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. See undef.

Examples

  1. julia> A = Array{Float64,2}(undef, 2, 3) # N given explicitly
  2. 2×3 Array{Float64,2}:
  3. 6.90198e-310 6.90198e-310 6.90198e-310
  4. 6.90198e-310 6.90198e-310 0.0
  5. julia> B = Array{Float64}(undef, 2) # N determined by the input
  6. 2-element Array{Float64,1}:
  7. 1.87103e-320
  8. 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 Array{Union{Nothing, String},1}:
  3. nothing
  4. nothing
  5. julia> Array{Union{Nothing, Int}}(nothing, 2, 3)
  6. 2×3 Array{Union{Nothing, Int64},2}:
  7. nothing nothing nothing
  8. 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 Array{Union{Missing, String},1}:
  3. missing
  4. missing
  5. julia> Array{Union{Missing, Int}}(missing, 2, 3)
  6. 2×3 Array{Union{Missing, Int64},2}:
  7. missing missing missing
  8. 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.

Examples

  1. julia> Array{Float64,1}(undef, 3)
  2. 3-element Array{Float64,1}:
  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}.

source

Base.Vector — Method.

  1. Vector{T}(undef, n)

Construct an uninitialized Vector{T} of length n. See undef.

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 Array{Union{Nothing, String},1}:
  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 Array{Union{Missing, String},1}:
  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}.

source

Base.Matrix — Method.

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

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

Examples

  1. julia> Matrix{Float64}(undef, 2, 3)
  2. 2×3 Array{Float64,2}:
  3. 6.93517e-310 6.93517e-310 6.93517e-310
  4. 6.93517e-310 6.93517e-310 1.29396e-320

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 Array{Union{Nothing, String},2}:
  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 Array{Union{Missing, String},2}:
  3. missing missing missing
  4. missing missing missing

source

Base.VecOrMat — Constant.

  1. VecOrMat{T}

Union type of Vector{T} and Matrix{T}.

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 — Constant.

  1. DenseVecOrMat{T}

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

source

Base.StridedArray — Constant.

  1. StridedArray{T, N}

An N dimensional strided array with elements of type T. These arrays follow the strided array interface. 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 — Constant.

  1. StridedVector{T}

One dimensional StridedArray with elements of type T.

source

Base.StridedMatrix — Constant.

  1. StridedMatrix{T}

Two dimensional StridedArray with elements of type T.

source

Base.StridedVecOrMat — Constant.

  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 Array{Int8,1}:
  3. 1
  4. 2
  5. 3
  6. julia> getindex(Int8, 1, 2, 3)
  7. 3-element Array{Int8,1}:
  8. 1
  9. 2
  10. 3

source

Base.zeros — Function.

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

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

Examples

  1. julia> zeros(1)
  2. 1-element Array{Float64,1}:
  3. 0.0
  4. julia> zeros(Int8, 2, 3)
  5. 2×3 Array{Int8,2}:
  6. 0 0 0
  7. 0 0 0

source

Base.ones — Function.

  1. 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 Array{Float64,2}:
  3. 1.0 1.0
  4. julia> ones(ComplexF64, 2, 3)
  5. 2×3 Array{Complex{Float64},2}:
  6. 1.0+0.0im 1.0+0.0im 1.0+0.0im
  7. 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.

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 BitArray{2}:
  3. false false
  4. false true
  5. julia> BitArray(undef, (3, 1))
  6. 3×1 BitArray{2}:
  7. false
  8. true
  9. false

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 BitArray{2}:
  3. 1 0
  4. 0 1
  5. julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
  6. 2×3 BitArray{2}:
  7. 0 1 0
  8. 1 0 0
  9. julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
  10. 6-element BitArray{1}:
  11. 0
  12. 1
  13. 0
  14. 1
  15. 0
  16. 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 BitArray{2}:
  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 BitArray{2}:
  3. 0 0 0
  4. 0 0 0

source

Base.fill — Function.

  1. 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.

Examples

  1. julia> fill(1.0, (5,5))
  2. 5×5 Array{Float64,2}:
  3. 1.0 1.0 1.0 1.0 1.0
  4. 1.0 1.0 1.0 1.0 1.0
  5. 1.0 1.0 1.0 1.0 1.0
  6. 1.0 1.0 1.0 1.0 1.0
  7. 1.0 1.0 1.0 1.0 1.0

If x is an object reference, all elements will refer to the same object. fill(Foo(), dims) will return an array filled with the result of evaluating Foo() once.

source

Base.fill! — Function.

  1. fill!(A, x)

Fill array A with the value x. If x is an object reference, all elements will refer to the same object. fill!(A, Foo()) will return A filled with the result of evaluating Foo() once.

Examples

  1. julia> A = zeros(2,3)
  2. 2×3 Array{Float64,2}:
  3. 0.0 0.0 0.0
  4. 0.0 0.0 0.0
  5. julia> fill!(A, 2.)
  6. 2×3 Array{Float64,2}:
  7. 2.0 2.0 2.0
  8. 2.0 2.0 2.0
  9. julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A
  10. 3-element Array{Array{Int64,1},1}:
  11. [2, 1, 1]
  12. [2, 1, 1]
  13. [2, 1, 1]
  14. julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f())
  15. 3-element Array{Int64,1}:
  16. 1
  17. 1
  18. 1

source

Base.similar — Function.

  1. similar(array, [element_type=eltype(array)], [dims=size(array)])

Create an uninitialized mutable array with the given element type and size, based upon the given source array. The second and third arguments are both optional, defaulting to the given array’s eltype and size. The dimensions may be specified either as a single tuple argument or as a series of integer arguments.

Custom AbstractArray subtypes may choose which specific array type is best-suited to return for the given element type and dimensionality. If they do not specialize this method, the default is an Array{element_type}(undef, dims...).

For example, similar(1:10, 1, 4) returns an uninitialized Array{Int,2} since ranges are neither mutable nor support 2 dimensions:

  1. julia> similar(1:10, 1, 4)
  2. 1×4 Array{Int64,2}:
  3. 4419743872 4374413872 4419743888 0

Conversely, similar(trues(10,10), 2) returns an uninitialized BitVector with two elements since BitArrays are both mutable and can support 1-dimensional arrays:

  1. julia> similar(trues(10,10), 2)
  2. 2-element BitArray{1}:
  3. 0
  4. 0

Since BitArrays can only store elements of type Bool, however, if you request a different element type it will create a regular Array instead:

  1. julia> similar(falses(10), Float64, 2, 4)
  2. 2×4 Array{Float64,2}:
  3. 2.18425e-314 2.18425e-314 2.18425e-314 2.18425e-314
  4. 2.18425e-314 2.18425e-314 2.18425e-314 2.18425e-314

source

  1. similar(storagetype, axes)

Create an uninitialized mutable array analogous to that specified by storagetype, but with axes specified by the last argument. storagetype might be a type or a function.

Examples:

  1. similar(Array{Int}, axes(A))

creates an array that “acts like” an Array{Int} (and might indeed be backed by one), but which is indexed identically to A. If A has conventional indexing, this will be identical to Array{Int}(undef, size(A)), but if A has unconventional indexing then the indices of the result will match A.

  1. similar(BitArray, (axes(A, 2),))

would create a 1-dimensional logical array whose indices match those of the columns of A.

source

Basic functions

Base.ndims — Function.

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

Return the number of dimensions of A.

Examples

  1. julia> A = fill(1, (3,4,5));
  2. julia> ndims(A)
  3. 3

source

Base.size — Function.

  1. size(A::AbstractArray, [dim])

Return a tuple containing the dimensions of A. Optionally you can specify a dimension to just get the length of that dimension.

Note that size may not be defined for arrays with non-standard indices, in which case axes may be useful. See the manual chapter on arrays with custom indices.

Examples

  1. julia> A = fill(1, (2,3,4));
  2. julia> size(A)
  3. (2, 3, 4)
  4. julia> size(A, 2)
  5. 3

source

Base.axes — Method.

  1. axes(A)

Return the tuple of valid indices for array A.

Examples

  1. julia> A = fill(1, (5,6,7));
  2. julia> axes(A)
  3. (Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))

source

Base.axes — Method.

  1. axes(A, d)

Return the valid range of indices for array A along dimension d.

See also size, and the manual chapter on arrays with custom indices.

Examples

  1. julia> A = fill(1, (5,6,7));
  2. julia> axes(A, 2)
  3. Base.OneTo(6)

source

Base.length — Method.

  1. length(A::AbstractArray)

Return the number of elements in the array, defaults to prod(size(A)).

Examples

  1. julia> length([1, 2, 3, 4])
  2. 4
  3. julia> length([1 2; 3 4])
  4. 4

source

Base.eachindex — Function.

  1. eachindex(A...)

Create an iterable object for visiting each index of an AbstractArray A in an efficient manner. For array types that have opted into fast linear indexing (like Array), this is simply the range 1:length(A). For other array types, return a specialized Cartesian range to efficiently index into the array with indices specified for every dimension. For other iterables, including strings and dictionaries, return an iterator object supporting arbitrary index types (e.g. unevenly spaced or non-integer indices).

If you supply more than one AbstractArray argument, eachindex will create an iterable object that is fast for all arguments (a UnitRange if all inputs have fast linear indexing, a CartesianIndices otherwise). If the arrays have different sizes and/or dimensionalities, eachindex will return an iterable that spans the largest range along each dimension.

Examples

  1. julia> A = [1 2; 3 4];
  2. julia> for i in eachindex(A) # linear indexing
  3. println(i)
  4. end
  5. 1
  6. 2
  7. 3
  8. 4
  9. julia> for i in eachindex(view(A, 1:2, 1:1)) # Cartesian indexing
  10. println(i)
  11. end
  12. CartesianIndex(1, 1)
  13. CartesianIndex(2, 1)

source

Base.IndexStyle — Type.

  1. IndexStyle(A)
  2. IndexStyle(typeof(A))

IndexStyle specifies the “native indexing style” for array A. When you define a new AbstractArray type, you can choose to implement either linear indexing (with IndexLinear) or cartesian indexing. If you decide to implement linear indexing, then you must set this trait for your array type:

  1. Base.IndexStyle(::Type{<:MyArray}) = IndexLinear()

The default is IndexCartesian().

Julia’s internal indexing machinery will automatically (and invisibly) convert all indexing operations into the preferred style. This allows users to access elements of your array using any indexing style, even when explicit methods have not been provided.

If you define both styles of indexing for your AbstractArray, this trait can be used to select the most performant indexing style. Some methods check this trait on their inputs, and dispatch to different algorithms depending on the most efficient access pattern. In particular, eachindex creates an iterator whose type depends on the setting of this trait.

source

Base.IndexLinear — Type.

  1. IndexLinear()

Subtype of IndexStyle used to describe arrays which are optimally indexed by one linear index.

A linear indexing style uses one integer to describe the position in the array (even if it’s a multidimensional array) and column-major ordering is used to access the elements. For example, if A were a (2, 3) custom matrix type with linear indexing, and we referenced A[5] (using linear style), this would be equivalent to referencing A[1, 3] (since 2*1 + 3 = 5). See also IndexCartesian.

source

Base.IndexCartesian — Type.

  1. IndexCartesian()

Subtype of IndexStyle used to describe arrays which are optimally indexed by a Cartesian index.

A cartesian indexing style uses multiple integers/indices to describe the position in the array. For example, if A were a (2, 3, 4) custom matrix type with cartesian indexing, we could reference A[2, 1, 3] and Julia would automatically convert this into the correct location in the underlying memory. See also IndexLinear.

source

Base.conj! — Function.

  1. conj!(A)

Transform an array to its complex conjugate in-place.

See also conj.

Examples

  1. julia> A = [1+im 2-im; 2+2im 3+im]
  2. 2×2 Array{Complex{Int64},2}:
  3. 1+1im 2-1im
  4. 2+2im 3+1im
  5. julia> conj!(A);
  6. julia> A
  7. 2×2 Array{Complex{Int64},2}:
  8. 1-1im 2+1im
  9. 2-2im 3-1im

source

Base.stride — Function.

  1. stride(A, k::Integer)

Return the distance in memory (in number of elements) between adjacent elements in dimension k.

Examples

  1. julia> A = fill(1, (3,4,5));
  2. julia> stride(A,2)
  3. 3
  4. julia> stride(A,3)
  5. 12

source

Base.strides — Function.

  1. strides(A)

Return a tuple of the memory strides in each dimension.

Examples

  1. julia> A = fill(1, (3,4,5));
  2. julia> strides(A)
  3. (1, 3, 12)

source

Broadcast and vectorization

See also the dot syntax for vectorizing functions; for example, f.(args...) implicitly calls broadcast(f, args...). Rather than relying on “vectorized” methods of functions like sin to operate on arrays, you should use sin.(a) to vectorize via 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 Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
  9. 5×2 Array{Int64,2}:
  10. 1 2
  11. 3 4
  12. 5 6
  13. 7 8
  14. 9 10
  15. julia> broadcast(+, A, B)
  16. 5×2 Array{Int64,2}:
  17. 2 3
  18. 5 6
  19. 8 9
  20. 11 12
  21. 14 15
  22. julia> parse.(Int, ["1", "2"])
  23. 2-element Array{Int64,1}:
  24. 1
  25. 2
  26. julia> abs.((1, -2))
  27. (1, 2)
  28. julia> broadcast(+, 1.0, (0, -2.0))
  29. (1.0, -1.0)
  30. julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))
  31. 2-element Array{Array{Int64,1},1}:
  32. [1, 1]
  33. [2, 2]
  34. julia> string.(("one","two","three","four"), ": ", 1:4)
  35. 4-element Array{String,1}:
  36. "one: 1"
  37. "two: 2"
  38. "three: 3"
  39. "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];
  2. julia> broadcast!(+, B, A, (0, -2.0));
  3. julia> B
  4. 2-element Array{Float64,1}:
  5. 1.0
  6. -2.0
  7. julia> A
  8. 2-element Array{Float64,1}:
  9. 1.0
  10. 0.0
  11. julia> broadcast!(+, A, A, (0, -2.0));
  12. julia> A
  13. 2-element Array{Float64,1}:
  14. 1.0
  15. -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);
  2. julia> @. y = x + 3 * sin(x)
  3. 3-element Array{Float64,1}:
  4. 3.5244129544236893
  5. 4.727892280477045
  6. 3.4233600241796016

source

For specializing broadcast on custom types, see

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.

See also Broadcast.DefaultArrayStyle.

source

Base.Broadcast.ArrayStyle — Type.

Broadcast.ArrayStyle{MyArrayType}() is a BroadcastStyle indicating that an object behaves as an array for broadcasting. It presents a simple way to construct Broadcast.AbstractArrayStyles for specific AbstractArray container types. Broadcast styles created this way lose track of dimensionality; if keeping track is important for your type, you should create your own custom Broadcast.AbstractArrayStyle.

source

Base.Broadcast.DefaultArrayStyle — Type.

Broadcast.DefaultArrayStyle{N}() is a BroadcastStyle indicating that an object behaves as an N-dimensional array for broadcasting. Specifically, DefaultArrayStyle is used for any AbstractArray type that hasn’t defined a specialized style, and in the absence of overrides from other broadcast arguments the resulting output type is Array. When there are multiple inputs to broadcast, DefaultArrayStyle “loses” to any other Broadcast.ArrayStyle.

source

Base.Broadcast.broadcastable — Function.

  1. Broadcast.broadcastable(x)

Return either x or an object like x such that it supports axes, indexing, and its type supports ndims.

If x supports iteration, the returned value should have the same axes and indexing behaviors as collect(x).

If x is not an AbstractArray but it supports axes, indexing, and its type supports ndims, then broadcastable(::typeof(x)) may be implemented to just return itself. Further, if x defines its own BroadcastStyle, then it must define its broadcastable method to return itself for the custom style to have any effect.

Examples

  1. julia> Broadcast.broadcastable([1,2,3]) # like `identity` since arrays already support axes and indexing
  2. 3-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. julia> Broadcast.broadcastable(Int) # Types don't support axes, indexing, or iteration but are commonly used as scalars
  7. Base.RefValue{Type{Int64}}(Int64)
  8. julia> Broadcast.broadcastable("hello") # Strings break convention of matching iteration and act like a scalar instead
  9. Base.RefValue{String}("hello")

source

Base.Broadcast.combine_axes — Function.

  1. combine_axes(As...) -> Tuple

Determine the result axes for broadcasting across all values in As.

  1. julia> Broadcast.combine_axes([1], [1 2; 3 4; 5 6])
  2. (Base.OneTo(3), Base.OneTo(2))
  3. julia> Broadcast.combine_axes(1, 1, 1)
  4. ()

source

Base.Broadcast.combine_styles — Function.

  1. combine_styles(cs...) -> BroadcastStyle

Decides which BroadcastStyle to use for any number of value arguments. Uses BroadcastStyle to get the style for each argument, and uses result_style to combine styles.

Examples

  1. julia> Broadcast.combine_styles([1], [1 2; 3 4])
  2. Base.Broadcast.DefaultArrayStyle{2}()

source

Base.Broadcast.result_style — Function.

  1. result_style(s1::BroadcastStyle[, s2::BroadcastStyle]) -> BroadcastStyle

Takes one or two BroadcastStyles and combines them using BroadcastStyle to determine a common BroadcastStyle.

Examples

  1. julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
  2. Base.Broadcast.DefaultArrayStyle{3}()
  3. julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
  4. Base.Broadcast.DefaultArrayStyle{1}()

source

Indexing and assignment

Base.getindex — Method.

  1. getindex(A, inds...)

Return a subset of array A as specified by inds, where each ind may be an Int, an AbstractRange, or a Vector. See the manual section on array indexing for details.

Examples

  1. julia> A = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> getindex(A, 1)
  6. 1
  7. julia> getindex(A, [2, 1])
  8. 2-element Array{Int64,1}:
  9. 3
  10. 1
  11. julia> getindex(A, 2:4)
  12. 3-element Array{Int64,1}:
  13. 3
  14. 2
  15. 4

source

Base.setindex! — Method.

  1. setindex!(A, X, inds...)
  2. A[inds...] = X

Store values from array X within some subset of A as specified by inds. The syntax A[inds...] = X is equivalent to setindex!(A, X, inds...).

Examples

  1. julia> A = zeros(2,2);
  2. julia> setindex!(A, [10, 20], [1, 2]);
  3. julia> A[[3, 4]] = [30, 40];
  4. julia> A
  5. 2×2 Array{Float64,2}:
  6. 10.0 30.0
  7. 20.0 40.0

source

Base.copyto! — Method.

  1. copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Copy the block of src in the range of Rsrc to the block of dest in the range of Rdest. The sizes of the two regions must match.

source

Base.isassigned — Function.

  1. isassigned(array, i) -> Bool

Test whether the given array has a value associated with index i. Return false if the index is out of bounds, or has an undefined reference.

Examples

  1. julia> isassigned(rand(3, 3), 5)
  2. true
  3. julia> isassigned(rand(3, 3), 3 * 3 + 1)
  4. false
  5. julia> mutable struct Foo end
  6. julia> v = similar(rand(3), Foo)
  7. 3-element Array{Foo,1}:
  8. #undef
  9. #undef
  10. #undef
  11. julia> isassigned(v, 1)
  12. false

source

Base.Colon — Type.

  1. Colon()

Colons (:) are used to signify indexing entire objects or dimensions at once.

Very few operations are defined on Colons directly; instead they are converted by to_indices to an internal vector type (Base.Slice) to represent the collection of indices they span before being used.

The singleton instance of Colon is also a function used to construct ranges; see :.

source

Base.IteratorsMD.CartesianIndex — Type.

  1. CartesianIndex(i, j, k...) -> I
  2. CartesianIndex((i, j, k...)) -> I

Create a multidimensional index I, which can be used for indexing a multidimensional array A. In particular, A[I] is equivalent to A[i,j,k...]. One can freely mix integer and CartesianIndex indices; for example, A[Ipre, i, Ipost] (where Ipre and Ipost are CartesianIndex indices and i is an Int) can be a useful expression when writing algorithms that work along a single dimension of an array of arbitrary dimensionality.

A CartesianIndex is sometimes produced by eachindex, and always when iterating with an explicit CartesianIndices.

Examples

  1. julia> A = reshape(Vector(1:16), (2, 2, 2, 2))
  2. 2×2×2×2 Array{Int64,4}:
  3. [:, :, 1, 1] =
  4. 1 3
  5. 2 4
  6. [:, :, 2, 1] =
  7. 5 7
  8. 6 8
  9. [:, :, 1, 2] =
  10. 9 11
  11. 10 12
  12. [:, :, 2, 2] =
  13. 13 15
  14. 14 16
  15. julia> A[CartesianIndex((1, 1, 1, 1))]
  16. 1
  17. julia> A[CartesianIndex((1, 1, 1, 2))]
  18. 9
  19. julia> A[CartesianIndex((1, 1, 2, 1))]
  20. 5

source

Base.IteratorsMD.CartesianIndices — Type.

  1. CartesianIndices(sz::Dims) -> R
  2. CartesianIndices((istart:istop, jstart:jstop, ...)) -> R

Define a region R spanning a multidimensional rectangular range of integer indices. These are most commonly encountered in the context of iteration, where for I in R ... end will return CartesianIndex indices I equivalent to the nested loops

  1. for j = jstart:jstop
  2. for i = istart:istop
  3. ...
  4. end
  5. end

Consequently these can be useful for writing algorithms that work in arbitrary dimensions.

  1. CartesianIndices(A::AbstractArray) -> R

As a convenience, constructing a CartesianIndices from an array makes a range of its indices.

Examples

  1. julia> foreach(println, CartesianIndices((2, 2, 2)))
  2. CartesianIndex(1, 1, 1)
  3. CartesianIndex(2, 1, 1)
  4. CartesianIndex(1, 2, 1)
  5. CartesianIndex(2, 2, 1)
  6. CartesianIndex(1, 1, 2)
  7. CartesianIndex(2, 1, 2)
  8. CartesianIndex(1, 2, 2)
  9. CartesianIndex(2, 2, 2)
  10. julia> CartesianIndices(fill(1, (2,3)))
  11. 2×3 CartesianIndices{2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}}:
  12. CartesianIndex(1, 1) CartesianIndex(1, 2) CartesianIndex(1, 3)
  13. CartesianIndex(2, 1) CartesianIndex(2, 2) CartesianIndex(2, 3)

Conversion between linear and cartesian indices

Linear index to cartesian index conversion exploits the fact that a CartesianIndices is an AbstractArray and can be indexed linearly:

  1. julia> cartesian = CartesianIndices((1:3, 1:2))
  2. 3×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
  3. CartesianIndex(1, 1) CartesianIndex(1, 2)
  4. CartesianIndex(2, 1) CartesianIndex(2, 2)
  5. CartesianIndex(3, 1) CartesianIndex(3, 2)
  6. julia> cartesian[4]
  7. CartesianIndex(1, 2)

Broadcasting

CartesianIndices support broadcasting arithmetic (+ and -) with a CartesianIndex.

Julia 1.1

Broadcasting of CartesianIndices requires at least Julia 1.1.

  1. julia> CIs = CartesianIndices((2:3, 5:6))
  2. 2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
  3. CartesianIndex(2, 5) CartesianIndex(2, 6)
  4. CartesianIndex(3, 5) CartesianIndex(3, 6)
  5. julia> CI = CartesianIndex(3, 4)
  6. CartesianIndex(3, 4)
  7. julia> CIs .+ CI
  8. 2×2 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
  9. CartesianIndex(5, 9) CartesianIndex(5, 10)
  10. CartesianIndex(6, 9) CartesianIndex(6, 10)

For cartesian to linear index conversion, see LinearIndices.

source

Base.Dims — Type.

  1. Dims{N}

An NTuple of N Ints used to represent the dimensions of an AbstractArray.

source

Base.LinearIndices — Type.

  1. LinearIndices(A::AbstractArray)

Return a LinearIndices array with the same shape and axes as A, holding the linear index of each entry in A. Indexing this array with cartesian indices allows mapping them to linear indices.

For arrays with conventional indexing (indices start at 1), or any multidimensional array, linear indices range from 1 to length(A). However, for AbstractVectors linear indices are axes(A, 1), and therefore do not start at 1 for vectors with unconventional indexing.

Calling this function is the “safe” way to write algorithms that exploit linear indexing.

Examples

  1. julia> A = fill(1, (5,6,7));
  2. julia> b = LinearIndices(A);
  3. julia> extrema(b)
  4. (1, 210)
  1. LinearIndices(inds::CartesianIndices) -> R
  2. LinearIndices(sz::Dims) -> R
  3. LinearIndices((istart:istop, jstart:jstop, ...)) -> R

Return a LinearIndices array with the specified shape or axes.

Example

The main purpose of this constructor is intuitive conversion from cartesian to linear indexing:

  1. julia> linear = LinearIndices((1:3, 1:2))
  2. 3×2 LinearIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
  3. 1 4
  4. 2 5
  5. 3 6
  6. julia> linear[1,2]
  7. 4

source

Base.to_indices — Function.

  1. to_indices(A, I::Tuple)

Convert the tuple I to a tuple of indices for use in indexing into array A.

The returned tuple must only contain either Ints or AbstractArrays of scalar indices that are supported by array A. It will error upon encountering a novel index type that it does not know how to process.

For simple index types, it defers to the unexported Base.to_index(A, i) to process each index i. While this internal function is not intended to be called directly, Base.to_index may be extended by custom array or index types to provide custom indexing behaviors.

More complicated index types may require more context about the dimension into which they index. To support those cases, to_indices(A, I) calls to_indices(A, axes(A), I), which then recursively walks through both the given tuple of indices and the dimensional indices of A in tandem. As such, not all index types are guaranteed to propagate to Base.to_index.

source

Base.checkbounds — Function.

  1. checkbounds(Bool, A, I...)

Return true if the specified indices I are in bounds for the given array A. Subtypes of AbstractArray should specialize this method if they need to provide custom bounds checking behaviors; however, in many cases one can rely on A‘s indices and checkindex.

See also checkindex.

Examples

  1. julia> A = rand(3, 3);
  2. julia> checkbounds(Bool, A, 2)
  3. true
  4. julia> checkbounds(Bool, A, 3, 4)
  5. false
  6. julia> checkbounds(Bool, A, 1:3)
  7. true
  8. julia> checkbounds(Bool, A, 1:3, 2:4)
  9. false

source

  1. checkbounds(A, I...)

Throw an error if the specified indices I are not in bounds for the given array A.

source

Base.checkindex — Function.

  1. checkindex(Bool, inds::AbstractUnitRange, index)

Return true if the given index is within the bounds of inds. Custom types that would like to behave as indices for all arrays can extend this method in order to provide a specialized bounds checking implementation.

Examples

  1. julia> checkindex(Bool, 1:20, 8)
  2. true
  3. julia> checkindex(Bool, 1:20, 21)
  4. false

source

Views (SubArrays and other view types)

Base.view — Function.

  1. view(A, inds...)

Like getindex, but returns a view into the parent array A with the given indices instead of making a copy. Calling getindex or setindex! on the returned SubArray computes the indices to the parent array on the fly without checking bounds.

Examples

  1. julia> A = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> b = view(A, :, 1)
  6. 2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
  7. 1
  8. 3
  9. julia> fill!(b, 0)
  10. 2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
  11. 0
  12. 0
  13. julia> A # Note A has changed even though we modified b
  14. 2×2 Array{Int64,2}:
  15. 0 2
  16. 0 4

source

Base.@view — Macro.

  1. @view A[inds...]

Creates a SubArray from an indexing expression. This can only be applied directly to a reference expression (e.g. @view A[1,2:end]), and should not be used as the target of an assignment (e.g. @view(A[1,2:end]) = ...). See also @views to switch an entire block of code to use views for slicing.

Examples

  1. julia> A = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> b = @view A[:, 1]
  6. 2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
  7. 1
  8. 3
  9. julia> fill!(b, 0)
  10. 2-element view(::Array{Int64,2}, :, 1) with eltype Int64:
  11. 0
  12. 0
  13. julia> A
  14. 2×2 Array{Int64,2}:
  15. 0 2
  16. 0 4

source

Base.@views — Macro.

  1. @views expression

Convert every array-slicing operation in the given expression (which may be a begin/end block, loop, function, etc.) to return a view. Scalar indices, non-array types, and explicit getindex calls (as opposed to array[...]) are unaffected.

Note

The @views macro only affects array[...] expressions that appear explicitly in the given expression, not array slicing that occurs in functions called by that code.

Examples

  1. julia> A = zeros(3, 3);
  2. julia> @views for row in 1:3
  3. b = A[row, :]
  4. b[:] .= row
  5. end
  6. julia> A
  7. 3×3 Array{Float64,2}:
  8. 1.0 1.0 1.0
  9. 2.0 2.0 2.0
  10. 3.0 3.0 3.0

source

Base.parent — Function.

  1. parent(A)

Returns the “parent array” of an array view type (e.g., SubArray), or the array itself if it is not a view.

Examples

  1. julia> A = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> V = view(A, 1:2, :)
  6. 2×2 view(::Array{Int64,2}, 1:2, :) with eltype Int64:
  7. 1 2
  8. 3 4
  9. julia> parent(V)
  10. 2×2 Array{Int64,2}:
  11. 1 2
  12. 3 4

source

Base.parentindices — Function.

  1. parentindices(A)

Return the indices in the parent which correspond to the array view A.

Examples

  1. julia> A = [1 2; 3 4];
  2. julia> V = view(A, 1, :)
  3. 2-element view(::Array{Int64,2}, 1, :) with eltype Int64:
  4. 1
  5. 2
  6. julia> parentindices(V)
  7. (1, Base.Slice(Base.OneTo(2)))

source

Base.selectdim — Function.

  1. selectdim(A, d::Integer, i)

Return a view of all the data of A where the index for dimension d equals i.

Equivalent to view(A,:,:,...,i,:,:,...) where i is in position d.

Examples

  1. julia> A = [1 2 3 4; 5 6 7 8]
  2. 2×4 Array{Int64,2}:
  3. 1 2 3 4
  4. 5 6 7 8
  5. julia> selectdim(A, 2, 3)
  6. 2-element view(::Array{Int64,2}, :, 3) with eltype Int64:
  7. 3
  8. 7

source

Base.reinterpret — Function.

  1. reinterpret(type, A)

Change the type-interpretation of a block of memory. For arrays, this constructs a view of the array with the same binary data as the given array, but with the specified element type. For example, reinterpret(Float32, UInt32(7)) interprets the 4 bytes corresponding to UInt32(7) as a Float32.

Examples

  1. julia> reinterpret(Float32, UInt32(7))
  2. 1.0f-44
  3. julia> reinterpret(Float32, UInt32[1 2 3 4 5])
  4. 1×5 reinterpret(Float32, ::Array{UInt32,2}):
  5. 1.4013e-45 2.8026e-45 4.2039e-45 5.60519e-45 7.00649e-45

source

Base.reshape — Function.

  1. reshape(A, dims...) -> AbstractArray
  2. reshape(A, dims) -> AbstractArray

Return an array with the same data as A, but with different dimension sizes or number of dimensions. The two arrays share the same underlying data, so that the result is mutable if and only if A is mutable, and setting elements of one alters the values of the other.

The new dimensions may be specified either as a list of arguments or as a shape tuple. At most one dimension may be specified with a :, in which case its length is computed such that its product with all the specified dimensions is equal to the length of the original array A. The total number of elements must not change.

Examples

  1. julia> A = Vector(1:16)
  2. 16-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. 6
  9. 7
  10. 8
  11. 9
  12. 10
  13. 11
  14. 12
  15. 13
  16. 14
  17. 15
  18. 16
  19. julia> reshape(A, (4, 4))
  20. 4×4 Array{Int64,2}:
  21. 1 5 9 13
  22. 2 6 10 14
  23. 3 7 11 15
  24. 4 8 12 16
  25. julia> reshape(A, 2, :)
  26. 2×8 Array{Int64,2}:
  27. 1 3 5 7 9 11 13 15
  28. 2 4 6 8 10 12 14 16
  29. julia> reshape(1:6, 2, 3)
  30. 2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
  31. 1 3 5
  32. 2 4 6

source

Base.dropdims — Function.

  1. dropdims(A; dims)

Remove the dimensions specified by dims from array A. Elements of dims must be unique and within the range 1:ndims(A). size(A,i) must equal 1 for all i in dims.

Examples

  1. julia> a = reshape(Vector(1:4),(2,2,1,1))
  2. 2×2×1×1 Array{Int64,4}:
  3. [:, :, 1, 1] =
  4. 1 3
  5. 2 4
  6. julia> dropdims(a; dims=3)
  7. 2×2×1 Array{Int64,3}:
  8. [:, :, 1] =
  9. 1 3
  10. 2 4

source

Base.vec — Function.

  1. vec(a::AbstractArray) -> AbstractVector

Reshape the array a as a one-dimensional column vector. Return a if it is already an AbstractVector. The resulting array shares the same underlying data as a, so it will only be mutable if a is mutable, in which case modifying one will also modify the other.

Examples

  1. julia> a = [1 2 3; 4 5 6]
  2. 2×3 Array{Int64,2}:
  3. 1 2 3
  4. 4 5 6
  5. julia> vec(a)
  6. 6-element Array{Int64,1}:
  7. 1
  8. 4
  9. 2
  10. 5
  11. 3
  12. 6
  13. julia> vec(1:3)
  14. 1:3

See also reshape.

source

Concatenation and permutation

Base.cat — Function.

  1. cat(A...; dims=dims)

Concatenate the input arrays along the specified dimensions in the iterable dims. For dimensions not in dims, all input arrays should have the same size, which will also be the size of the output array along that dimension. For dimensions in dims, the size of the output array is the sum of the sizes of the input arrays along that dimension. If dims is a single number, the different arrays are tightly stacked along that dimension. If dims is an iterable containing several dimensions, this allows one to construct block diagonal matrices and their higher-dimensional analogues by simultaneously increasing several dimensions for every new input array and putting zero blocks elsewhere. For example, cat(matrices...; dims=(1,2)) builds a block diagonal matrix, i.e. a block matrix with matrices[1], matrices[2], … as diagonal blocks and matching zero blocks away from the diagonal.

source

Base.vcat — Function.

  1. vcat(A...)

Concatenate along dimension 1.

Examples

  1. julia> a = [1 2 3 4 5]
  2. 1×5 Array{Int64,2}:
  3. 1 2 3 4 5
  4. julia> b = [6 7 8 9 10; 11 12 13 14 15]
  5. 2×5 Array{Int64,2}:
  6. 6 7 8 9 10
  7. 11 12 13 14 15
  8. julia> vcat(a,b)
  9. 3×5 Array{Int64,2}:
  10. 1 2 3 4 5
  11. 6 7 8 9 10
  12. 11 12 13 14 15
  13. julia> c = ([1 2 3], [4 5 6])
  14. ([1 2 3], [4 5 6])
  15. julia> vcat(c...)
  16. 2×3 Array{Int64,2}:
  17. 1 2 3
  18. 4 5 6

source

Base.hcat — Function.

  1. hcat(A...)

Concatenate along dimension 2.

Examples

  1. julia> a = [1; 2; 3; 4; 5]
  2. 5-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. julia> b = [6 7; 8 9; 10 11; 12 13; 14 15]
  9. 5×2 Array{Int64,2}:
  10. 6 7
  11. 8 9
  12. 10 11
  13. 12 13
  14. 14 15
  15. julia> hcat(a,b)
  16. 5×3 Array{Int64,2}:
  17. 1 6 7
  18. 2 8 9
  19. 3 10 11
  20. 4 12 13
  21. 5 14 15
  22. julia> c = ([1; 2; 3], [4; 5; 6])
  23. ([1, 2, 3], [4, 5, 6])
  24. julia> hcat(c...)
  25. 3×2 Array{Int64,2}:
  26. 1 4
  27. 2 5
  28. 3 6

source

Base.hvcat — Function.

  1. hvcat(rows::Tuple{Vararg{Int}}, values...)

Horizontal and vertical concatenation in one call. This function is called for block matrix syntax. The first argument specifies the number of arguments to concatenate in each block row.

Examples

  1. julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
  2. (1, 2, 3, 4, 5, 6)
  3. julia> [a b c; d e f]
  4. 2×3 Array{Int64,2}:
  5. 1 2 3
  6. 4 5 6
  7. julia> hvcat((3,3), a,b,c,d,e,f)
  8. 2×3 Array{Int64,2}:
  9. 1 2 3
  10. 4 5 6
  11. julia> [a b;c d; e f]
  12. 3×2 Array{Int64,2}:
  13. 1 2
  14. 3 4
  15. 5 6
  16. julia> hvcat((2,2,2), a,b,c,d,e,f)
  17. 3×2 Array{Int64,2}:
  18. 1 2
  19. 3 4
  20. 5 6

If the first argument is a single integer n, then all block rows are assumed to have n block columns.

source

Base.vect — Function.

  1. vect(X...)

Create a Vector with element type computed from the promote_typeof of the argument, containing the argument list.

Examples

  1. julia> a = Base.vect(UInt8(1), 2.5, 1//2)
  2. 3-element Array{Float64,1}:
  3. 1.0
  4. 2.5
  5. 0.5

source

Base.circshift — Function.

  1. circshift(A, shifts)

Circularly shift, i.e. rotate, the data in an array. The second argument is a tuple or vector giving the amount to shift in each dimension, or an integer to shift only in the first dimension.

Examples

  1. julia> b = reshape(Vector(1:16), (4,4))
  2. 4×4 Array{Int64,2}:
  3. 1 5 9 13
  4. 2 6 10 14
  5. 3 7 11 15
  6. 4 8 12 16
  7. julia> circshift(b, (0,2))
  8. 4×4 Array{Int64,2}:
  9. 9 13 1 5
  10. 10 14 2 6
  11. 11 15 3 7
  12. 12 16 4 8
  13. julia> circshift(b, (-1,0))
  14. 4×4 Array{Int64,2}:
  15. 2 6 10 14
  16. 3 7 11 15
  17. 4 8 12 16
  18. 1 5 9 13
  19. julia> a = BitArray([true, true, false, false, true])
  20. 5-element BitArray{1}:
  21. 1
  22. 1
  23. 0
  24. 0
  25. 1
  26. julia> circshift(a, 1)
  27. 5-element BitArray{1}:
  28. 1
  29. 1
  30. 1
  31. 0
  32. 0
  33. julia> circshift(a, -1)
  34. 5-element BitArray{1}:
  35. 1
  36. 0
  37. 0
  38. 1
  39. 1

See also circshift!.

source

Base.circshift! — Function.

  1. circshift!(dest, src, shifts)

Circularly shift, i.e. rotate, the data in src, storing the result in dest. shifts specifies the amount to shift in each dimension.

The dest array must be distinct from the src array (they cannot alias each other).

See also circshift.

source

Base.circcopy! — Function.

  1. circcopy!(dest, src)

Copy src to dest, indexing each dimension modulo its length. src and dest must have the same size, but can be offset in their indices; any offset results in a (circular) wraparound. If the arrays have overlapping indices, then on the domain of the overlap dest agrees with src.

Examples

  1. julia> src = reshape(Vector(1:16), (4,4))
  2. 4×4 Array{Int64,2}:
  3. 1 5 9 13
  4. 2 6 10 14
  5. 3 7 11 15
  6. 4 8 12 16
  7. julia> dest = OffsetArray{Int}(undef, (0:3,2:5))
  8. julia> circcopy!(dest, src)
  9. OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} with indices 0:3×2:5:
  10. 8 12 16 4
  11. 5 9 13 1
  12. 6 10 14 2
  13. 7 11 15 3
  14. julia> dest[1:3,2:4] == src[1:3,2:4]
  15. true

source

Base.findall — Method.

  1. findall(A)

Return a vector I of the true indices or keys of A. If there are no such elements of A, return an empty array. To search for other kinds of values, pass a predicate as the first argument.

Indices or keys are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [true, false, false, true]
  2. 4-element Array{Bool,1}:
  3. 1
  4. 0
  5. 0
  6. 1
  7. julia> findall(A)
  8. 2-element Array{Int64,1}:
  9. 1
  10. 4
  11. julia> A = [true false; false true]
  12. 2×2 Array{Bool,2}:
  13. 1 0
  14. 0 1
  15. julia> findall(A)
  16. 2-element Array{CartesianIndex{2},1}:
  17. CartesianIndex(1, 1)
  18. CartesianIndex(2, 2)
  19. julia> findall(falses(3))
  20. 0-element Array{Int64,1}

source

Base.findall — Method.

  1. findall(f::Function, A)

Return a vector I of the indices or keys of A where f(A[I]) returns true. If there are no such elements of A, return an empty array.

Indices or keys are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> x = [1, 3, 4]
  2. 3-element Array{Int64,1}:
  3. 1
  4. 3
  5. 4
  6. julia> findall(isodd, x)
  7. 2-element Array{Int64,1}:
  8. 1
  9. 2
  10. julia> A = [1 2 0; 3 4 0]
  11. 2×3 Array{Int64,2}:
  12. 1 2 0
  13. 3 4 0
  14. julia> findall(isodd, A)
  15. 2-element Array{CartesianIndex{2},1}:
  16. CartesianIndex(1, 1)
  17. CartesianIndex(2, 1)
  18. julia> findall(!iszero, A)
  19. 4-element Array{CartesianIndex{2},1}:
  20. CartesianIndex(1, 1)
  21. CartesianIndex(2, 1)
  22. CartesianIndex(1, 2)
  23. CartesianIndex(2, 2)
  24. julia> d = Dict(:A => 10, :B => -1, :C => 0)
  25. Dict{Symbol,Int64} with 3 entries:
  26. :A => 10
  27. :B => -1
  28. :C => 0
  29. julia> findall(x -> x >= 0, d)
  30. 2-element Array{Symbol,1}:
  31. :A
  32. :C

source

Base.findfirst — Method.

  1. findfirst(A)

Return the index or key of the first true value in A. Return nothing if no such value is found. To search for other kinds of values, pass a predicate as the first argument.

Indices or keys are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [false, false, true, false]
  2. 4-element Array{Bool,1}:
  3. 0
  4. 0
  5. 1
  6. 0
  7. julia> findfirst(A)
  8. 3
  9. julia> findfirst(falses(3)) # returns nothing, but not printed in the REPL
  10. julia> A = [false false; true false]
  11. 2×2 Array{Bool,2}:
  12. 0 0
  13. 1 0
  14. julia> findfirst(A)
  15. CartesianIndex(2, 1)

source

Base.findfirst — Method.

  1. findfirst(predicate::Function, A)

Return the index or key of the first element of A for which predicate returns true. Return nothing if there is no such element.

Indices or keys are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [1, 4, 2, 2]
  2. 4-element Array{Int64,1}:
  3. 1
  4. 4
  5. 2
  6. 2
  7. julia> findfirst(iseven, A)
  8. 2
  9. julia> findfirst(x -> x>10, A) # returns nothing, but not printed in the REPL
  10. julia> findfirst(isequal(4), A)
  11. 2
  12. julia> A = [1 4; 2 2]
  13. 2×2 Array{Int64,2}:
  14. 1 4
  15. 2 2
  16. julia> findfirst(iseven, A)
  17. CartesianIndex(2, 1)

source

Base.findlast — Method.

  1. findlast(A)

Return the index or key of the last true value in A. Return nothing if there is no true value in A.

Indices or keys are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [true, false, true, false]
  2. 4-element Array{Bool,1}:
  3. 1
  4. 0
  5. 1
  6. 0
  7. julia> findlast(A)
  8. 3
  9. julia> A = falses(2,2);
  10. julia> findlast(A) # returns nothing, but not printed in the REPL
  11. julia> A = [true false; true false]
  12. 2×2 Array{Bool,2}:
  13. 1 0
  14. 1 0
  15. julia> findlast(A)
  16. CartesianIndex(2, 1)

source

Base.findlast — Method.

  1. findlast(predicate::Function, A)

Return the index or key of the last element of A for which predicate returns true. Return nothing if there is no such element.

Indices or keys are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [1, 2, 3, 4]
  2. 4-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 4
  7. julia> findlast(isodd, A)
  8. 3
  9. julia> findlast(x -> x > 5, A) # returns nothing, but not printed in the REPL
  10. julia> A = [1 2; 3 4]
  11. 2×2 Array{Int64,2}:
  12. 1 2
  13. 3 4
  14. julia> findlast(isodd, A)
  15. CartesianIndex(2, 1)

source

Base.findnext — Method.

  1. findnext(A, i)

Find the next index after or including i of a true element of A, or nothing if not found.

Indices are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [false, false, true, false]
  2. 4-element Array{Bool,1}:
  3. 0
  4. 0
  5. 1
  6. 0
  7. julia> findnext(A, 1)
  8. 3
  9. julia> findnext(A, 4) # returns nothing, but not printed in the REPL
  10. julia> A = [false false; true false]
  11. 2×2 Array{Bool,2}:
  12. 0 0
  13. 1 0
  14. julia> findnext(A, CartesianIndex(1, 1))
  15. CartesianIndex(2, 1)

source

Base.findnext — Method.

  1. findnext(predicate::Function, A, i)

Find the next index after or including i of an element of A for which predicate returns true, or nothing if not found.

Indices are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [1, 4, 2, 2];
  2. julia> findnext(isodd, A, 1)
  3. 1
  4. julia> findnext(isodd, A, 2) # returns nothing, but not printed in the REPL
  5. julia> A = [1 4; 2 2];
  6. julia> findnext(isodd, A, CartesianIndex(1, 1))
  7. CartesianIndex(1, 1)

source

Base.findprev — Method.

  1. findprev(A, i)

Find the previous index before or including i of a true element of A, or nothing if not found.

Indices are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [false, false, true, true]
  2. 4-element Array{Bool,1}:
  3. 0
  4. 0
  5. 1
  6. 1
  7. julia> findprev(A, 3)
  8. 3
  9. julia> findprev(A, 1) # returns nothing, but not printed in the REPL
  10. julia> A = [false false; true true]
  11. 2×2 Array{Bool,2}:
  12. 0 0
  13. 1 1
  14. julia> findprev(A, CartesianIndex(2, 1))
  15. CartesianIndex(2, 1)

source

Base.findprev — Method.

  1. findprev(predicate::Function, A, i)

Find the previous index before or including i of an element of A for which predicate returns true, or nothing if not found.

Indices are of the same type as those returned by keys(A) and pairs(A).

Examples

  1. julia> A = [4, 6, 1, 2]
  2. 4-element Array{Int64,1}:
  3. 4
  4. 6
  5. 1
  6. 2
  7. julia> findprev(isodd, A, 1) # returns nothing, but not printed in the REPL
  8. julia> findprev(isodd, A, 3)
  9. 3
  10. julia> A = [4 6; 1 2]
  11. 2×2 Array{Int64,2}:
  12. 4 6
  13. 1 2
  14. julia> findprev(isodd, A, CartesianIndex(1, 2))
  15. CartesianIndex(2, 1)

source

Base.permutedims — Function.

  1. permutedims(A::AbstractArray, perm)

Permute the dimensions of array A. perm is a vector specifying a permutation of length ndims(A).

See also: PermutedDimsArray.

Examples

  1. julia> A = reshape(Vector(1:8), (2,2,2))
  2. 2×2×2 Array{Int64,3}:
  3. [:, :, 1] =
  4. 1 3
  5. 2 4
  6. [:, :, 2] =
  7. 5 7
  8. 6 8
  9. julia> permutedims(A, [3, 2, 1])
  10. 2×2×2 Array{Int64,3}:
  11. [:, :, 1] =
  12. 1 3
  13. 5 7
  14. [:, :, 2] =
  15. 2 4
  16. 6 8

source

  1. permutedims(m::AbstractMatrix)

Permute the dimensions of the matrix m, by flipping the elements across the diagonal of the matrix. Differs from LinearAlgebra‘s transpose in that the operation is not recursive.

Examples

  1. julia> a = [1 2; 3 4];
  2. julia> b = [5 6; 7 8];
  3. julia> c = [9 10; 11 12];
  4. julia> d = [13 14; 15 16];
  5. julia> X = [[a] [b]; [c] [d]]
  6. 2×2 Array{Array{Int64,2},2}:
  7. [1 2; 3 4] [5 6; 7 8]
  8. [9 10; 11 12] [13 14; 15 16]
  9. julia> permutedims(X)
  10. 2×2 Array{Array{Int64,2},2}:
  11. [1 2; 3 4] [9 10; 11 12]
  12. [5 6; 7 8] [13 14; 15 16]
  13. julia> transpose(X)
  14. 2×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},2}}:
  15. [1 3; 2 4] [9 11; 10 12]
  16. [5 7; 6 8] [13 15; 14 16]

source

  1. permutedims(v::AbstractVector)

Reshape vector v into a 1 × length(v) row matrix. Differs from LinearAlgebra‘s transpose in that the operation is not recursive.

Examples

  1. julia> permutedims([1, 2, 3, 4])
  2. 1×4 Array{Int64,2}:
  3. 1 2 3 4
  4. julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
  5. 2-element Array{Array{Int64,2},1}:
  6. [1 2; 3 4]
  7. [5 6; 7 8]
  8. julia> permutedims(V)
  9. 1×2 Array{Array{Int64,2},2}:
  10. [1 2; 3 4] [5 6; 7 8]
  11. julia> transpose(V)
  12. 1×2 Transpose{Transpose{Int64,Array{Int64,2}},Array{Array{Int64,2},1}}:
  13. [1 3; 2 4] [5 7; 6 8]

source

Base.permutedims! — Function.

  1. permutedims!(dest, src, perm)

Permute the dimensions of array src and store the result in the array dest. perm is a vector specifying a permutation of length ndims(src). The preallocated array dest should have size(dest) == size(src)[perm] and is completely overwritten. No in-place permutation is supported and unexpected results will happen if src and dest have overlapping memory regions.

See also permutedims.

source

Base.PermutedDimsArrays.PermutedDimsArray — Type.

  1. PermutedDimsArray(A, perm) -> B

Given an AbstractArray A, create a view B such that the dimensions appear to be permuted. Similar to permutedims, except that no copying occurs (B shares storage with A).

See also: permutedims.

Examples

  1. julia> A = rand(3,5,4);
  2. julia> B = PermutedDimsArray(A, (3,1,2));
  3. julia> size(B)
  4. (4, 3, 5)
  5. julia> B[3,1,2] == A[1,2,3]
  6. true

source

Base.promote_shape — Function.

  1. promote_shape(s1, s2)

Check two array shapes for compatibility, allowing trailing singleton dimensions, and return whichever shape has more dimensions.

Examples

  1. julia> a = fill(1, (3,4,1,1,1));
  2. julia> b = fill(1, (3,4));
  3. julia> promote_shape(a,b)
  4. (Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))
  5. julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
  6. (2, 3, 1, 4, 1)

source

Array functions

Base.accumulate — Function.

  1. accumulate(op, A; dims::Integer, [init])

Cumulative operation op along the dimension dims of A (providing dims is optional for vectors). An initial value init may optionally be provided by a keyword argument. See also accumulate! to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow). For common operations there are specialized variants of accumulate, see: cumsum, cumprod

Examples

  1. julia> accumulate(+, [1,2,3])
  2. 3-element Array{Int64,1}:
  3. 1
  4. 3
  5. 6
  6. julia> accumulate(*, [1,2,3])
  7. 3-element Array{Int64,1}:
  8. 1
  9. 2
  10. 6
  11. julia> accumulate(+, [1,2,3]; init=100)
  12. 3-element Array{Int64,1}:
  13. 101
  14. 103
  15. 106
  16. julia> accumulate(min, [1,2,-1]; init=0)
  17. 3-element Array{Int64,1}:
  18. 0
  19. 0
  20. -1
  21. julia> accumulate(+, fill(1, 3, 3), dims=1)
  22. 3×3 Array{Int64,2}:
  23. 1 1 1
  24. 2 2 2
  25. 3 3 3
  26. julia> accumulate(+, fill(1, 3, 3), dims=2)
  27. 3×3 Array{Int64,2}:
  28. 1 2 3
  29. 1 2 3
  30. 1 2 3

source

Base.accumulate! — Function.

  1. accumulate!(op, B, A; [dims], [init])

Cumulative operation op on A along the dimension dims, storing the result in B. Providing dims is optional for vectors. If the keyword argument init is given, its value is used to instantiate the accumulation. See also accumulate.

Examples

  1. julia> x = [1, 0, 2, 0, 3];
  2. julia> y = [0, 0, 0, 0, 0];
  3. julia> accumulate!(+, y, x);
  4. julia> y
  5. 5-element Array{Int64,1}:
  6. 1
  7. 1
  8. 3
  9. 3
  10. 6
  11. julia> A = [1 2; 3 4];
  12. julia> B = [0 0; 0 0];
  13. julia> accumulate!(-, B, A, dims=1);
  14. julia> B
  15. 2×2 Array{Int64,2}:
  16. 1 2
  17. -2 -2
  18. julia> accumulate!(-, B, A, dims=2);
  19. julia> B
  20. 2×2 Array{Int64,2}:
  21. 1 -1
  22. 3 -1

source

Base.cumprod — Function.

  1. cumprod(A; dims::Integer)

Cumulative product along the dimension dim. See also cumprod! to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow).

Examples

  1. julia> a = [1 2 3; 4 5 6]
  2. 2×3 Array{Int64,2}:
  3. 1 2 3
  4. 4 5 6
  5. julia> cumprod(a, dims=1)
  6. 2×3 Array{Int64,2}:
  7. 1 2 3
  8. 4 10 18
  9. julia> cumprod(a, dims=2)
  10. 2×3 Array{Int64,2}:
  11. 1 2 6
  12. 4 20 120

source

  1. cumprod(x::AbstractVector)

Cumulative product of a vector. See also cumprod! to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow).

Examples

  1. julia> cumprod(fill(1//2, 3))
  2. 3-element Array{Rational{Int64},1}:
  3. 1//2
  4. 1//4
  5. 1//8
  6. julia> cumprod([fill(1//3, 2, 2) for i in 1:3])
  7. 3-element Array{Array{Rational{Int64},2},1}:
  8. [1//3 1//3; 1//3 1//3]
  9. [2//9 2//9; 2//9 2//9]
  10. [4//27 4//27; 4//27 4//27]

source

Base.cumprod! — Function.

  1. cumprod!(B, A; dims::Integer)

Cumulative product of A along the dimension dims, storing the result in B. See also cumprod.

source

  1. cumprod!(y::AbstractVector, x::AbstractVector)

Cumulative product of a vector x, storing the result in y. See also cumprod.

source

Base.cumsum — Function.

  1. cumsum(A; dims::Integer)

Cumulative sum along the dimension dims. See also cumsum! to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow).

Examples

  1. julia> a = [1 2 3; 4 5 6]
  2. 2×3 Array{Int64,2}:
  3. 1 2 3
  4. 4 5 6
  5. julia> cumsum(a, dims=1)
  6. 2×3 Array{Int64,2}:
  7. 1 2 3
  8. 5 7 9
  9. julia> cumsum(a, dims=2)
  10. 2×3 Array{Int64,2}:
  11. 1 3 6
  12. 4 9 15

source

  1. cumsum(x::AbstractVector)

Cumulative sum a vector. See also cumsum! to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow).

Examples

  1. julia> cumsum([1, 1, 1])
  2. 3-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. julia> cumsum([fill(1, 2) for i in 1:3])
  7. 3-element Array{Array{Int64,1},1}:
  8. [1, 1]
  9. [2, 2]
  10. [3, 3]

source

Base.cumsum! — Function.

  1. cumsum!(B, A; dims::Integer)

Cumulative sum of A along the dimension dims, storing the result in B. See also cumsum.

source

Base.diff — Function.

  1. diff(A::AbstractVector)
  2. diff(A::AbstractArray; dims::Integer)

Finite difference operator on a vector or a multidimensional array A. In the latter case the dimension to operate on needs to be specified with the dims keyword argument.

Julia 1.1

diff for arrays with dimension higher than 2 requires at least Julia 1.1.

Examples

  1. julia> a = [2 4; 6 16]
  2. 2×2 Array{Int64,2}:
  3. 2 4
  4. 6 16
  5. julia> diff(a, dims=2)
  6. 2×1 Array{Int64,2}:
  7. 2
  8. 10
  9. julia> diff(vec(a))
  10. 3-element Array{Int64,1}:
  11. 4
  12. -2
  13. 12

source

Base.repeat — Function.

  1. repeat(A::AbstractArray, counts::Integer...)

Construct an array by repeating array A a given number of times in each dimension, specified by counts.

Examples

  1. julia> repeat([1, 2, 3], 2)
  2. 6-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 1
  7. 2
  8. 3
  9. julia> repeat([1, 2, 3], 2, 3)
  10. 6×3 Array{Int64,2}:
  11. 1 1 1
  12. 2 2 2
  13. 3 3 3
  14. 1 1 1
  15. 2 2 2
  16. 3 3 3

source

  1. repeat(A::AbstractArray; inner=ntuple(x->1, ndims(A)), outer=ntuple(x->1, ndims(A)))

Construct an array by repeating the entries of A. The i-th element of inner specifies the number of times that the individual entries of the i-th dimension of A should be repeated. The i-th element of outer specifies the number of times that a slice along the i-th dimension of A should be repeated. If inner or outer are omitted, no repetition is performed.

Examples

  1. julia> repeat(1:2, inner=2)
  2. 4-element Array{Int64,1}:
  3. 1
  4. 1
  5. 2
  6. 2
  7. julia> repeat(1:2, outer=2)
  8. 4-element Array{Int64,1}:
  9. 1
  10. 2
  11. 1
  12. 2
  13. julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
  14. 4×6 Array{Int64,2}:
  15. 1 2 1 2 1 2
  16. 1 2 1 2 1 2
  17. 3 4 3 4 3 4
  18. 3 4 3 4 3 4

source

  1. repeat(s::AbstractString, r::Integer)

Repeat a string r times. This can be written as s^r.

See also: ^

Examples

  1. julia> repeat("ha", 3)
  2. "hahaha"

source

  1. repeat(c::AbstractChar, r::Integer) -> String

Repeat a character r times. This can equivalently be accomplished by calling c^r.

Examples

  1. julia> repeat('A', 3)
  2. "AAA"

source

Base.rot180 — Function.

  1. rot180(A)

Rotate matrix A 180 degrees.

Examples

  1. julia> a = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> rot180(a)
  6. 2×2 Array{Int64,2}:
  7. 4 3
  8. 2 1

source

  1. rot180(A, k)

Rotate matrix A 180 degrees an integer k number of times. If k is even, this is equivalent to a copy.

Examples

  1. julia> a = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> rot180(a,1)
  6. 2×2 Array{Int64,2}:
  7. 4 3
  8. 2 1
  9. julia> rot180(a,2)
  10. 2×2 Array{Int64,2}:
  11. 1 2
  12. 3 4

source

Base.rotl90 — Function.

  1. rotl90(A)

Rotate matrix A left 90 degrees.

Examples

  1. julia> a = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> rotl90(a)
  6. 2×2 Array{Int64,2}:
  7. 2 4
  8. 1 3

source

  1. rotl90(A, k)

Left-rotate matrix A 90 degrees counterclockwise an integer k number of times. If k is a multiple of four (including zero), this is equivalent to a copy.

Examples

  1. julia> a = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> rotl90(a,1)
  6. 2×2 Array{Int64,2}:
  7. 2 4
  8. 1 3
  9. julia> rotl90(a,2)
  10. 2×2 Array{Int64,2}:
  11. 4 3
  12. 2 1
  13. julia> rotl90(a,3)
  14. 2×2 Array{Int64,2}:
  15. 3 1
  16. 4 2
  17. julia> rotl90(a,4)
  18. 2×2 Array{Int64,2}:
  19. 1 2
  20. 3 4

source

Base.rotr90 — Function.

  1. rotr90(A)

Rotate matrix A right 90 degrees.

Examples

  1. julia> a = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> rotr90(a)
  6. 2×2 Array{Int64,2}:
  7. 3 1
  8. 4 2

source

  1. rotr90(A, k)

Right-rotate matrix A 90 degrees clockwise an integer k number of times. If k is a multiple of four (including zero), this is equivalent to a copy.

Examples

  1. julia> a = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> rotr90(a,1)
  6. 2×2 Array{Int64,2}:
  7. 3 1
  8. 4 2
  9. julia> rotr90(a,2)
  10. 2×2 Array{Int64,2}:
  11. 4 3
  12. 2 1
  13. julia> rotr90(a,3)
  14. 2×2 Array{Int64,2}:
  15. 2 4
  16. 1 3
  17. julia> rotr90(a,4)
  18. 2×2 Array{Int64,2}:
  19. 1 2
  20. 3 4

source

Base.mapslices — Function.

  1. mapslices(f, A; dims)

Transform the given dimensions of array A using function f. f is called on each slice of A of the form A[...,:,...,:,...]. dims is an integer vector specifying where the colons go in this expression. The results are concatenated along the remaining dimensions. For example, if dims is [1,2] and A is 4-dimensional, f is called on A[:,:,i,j] for all i and j.

Examples

  1. julia> a = reshape(Vector(1:16),(2,2,2,2))
  2. 2×2×2×2 Array{Int64,4}:
  3. [:, :, 1, 1] =
  4. 1 3
  5. 2 4
  6. [:, :, 2, 1] =
  7. 5 7
  8. 6 8
  9. [:, :, 1, 2] =
  10. 9 11
  11. 10 12
  12. [:, :, 2, 2] =
  13. 13 15
  14. 14 16
  15. julia> mapslices(sum, a, dims = [1,2])
  16. 1×1×2×2 Array{Int64,4}:
  17. [:, :, 1, 1] =
  18. 10
  19. [:, :, 2, 1] =
  20. 26
  21. [:, :, 1, 2] =
  22. 42
  23. [:, :, 2, 2] =
  24. 58

source

Combinatorics

Base.invperm — Function.

  1. invperm(v)

Return the inverse permutation of v. If B = A[v], then A == B[invperm(v)].

Examples

  1. julia> v = [2; 4; 3; 1];
  2. julia> invperm(v)
  3. 4-element Array{Int64,1}:
  4. 4
  5. 1
  6. 3
  7. 2
  8. julia> A = ['a','b','c','d'];
  9. julia> B = A[v]
  10. 4-element Array{Char,1}:
  11. 'b'
  12. 'd'
  13. 'c'
  14. 'a'
  15. julia> B[invperm(v)]
  16. 4-element Array{Char,1}:
  17. 'a'
  18. 'b'
  19. 'c'
  20. 'd'

source

Base.isperm — Function.

  1. isperm(v) -> Bool

Return true if v is a valid permutation.

Examples

  1. julia> isperm([1; 2])
  2. true
  3. julia> isperm([1; 3])
  4. false

source

Base.permute! — Method.

  1. permute!(v, p)

Permute vector v in-place, according to permutation p. No checking is done to verify that p is a permutation.

To return a new permutation, use v[p]. Note that this is generally faster than permute!(v,p) for large vectors.

See also invpermute!.

Examples

  1. julia> A = [1, 1, 3, 4];
  2. julia> perm = [2, 4, 3, 1];
  3. julia> permute!(A, perm);
  4. julia> A
  5. 4-element Array{Int64,1}:
  6. 1
  7. 4
  8. 3
  9. 1

source

Base.invpermute! — Function.

  1. invpermute!(v, p)

Like permute!, but the inverse of the given permutation is applied.

Examples

  1. julia> A = [1, 1, 3, 4];
  2. julia> perm = [2, 4, 3, 1];
  3. julia> invpermute!(A, perm);
  4. julia> A
  5. 4-element Array{Int64,1}:
  6. 4
  7. 1
  8. 3
  9. 1

source

Base.reverse — Method.

  1. reverse(v [, start=1 [, stop=length(v) ]] )

Return a copy of v reversed from start to stop. See also Iterators.reverse for reverse-order iteration without making a copy.

Examples

  1. julia> A = Vector(1:5)
  2. 5-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. julia> reverse(A)
  9. 5-element Array{Int64,1}:
  10. 5
  11. 4
  12. 3
  13. 2
  14. 1
  15. julia> reverse(A, 1, 4)
  16. 5-element Array{Int64,1}:
  17. 4
  18. 3
  19. 2
  20. 1
  21. 5
  22. julia> reverse(A, 3, 5)
  23. 5-element Array{Int64,1}:
  24. 1
  25. 2
  26. 5
  27. 4
  28. 3

source

  1. reverse(A; dims::Integer)

Reverse A in dimension dims.

Examples

  1. julia> b = [1 2; 3 4]
  2. 2×2 Array{Int64,2}:
  3. 1 2
  4. 3 4
  5. julia> reverse(b, dims=2)
  6. 2×2 Array{Int64,2}:
  7. 2 1
  8. 4 3

source

Base.reverseind — Function.

  1. reverseind(v, i)

Given an index i in reverse(v), return the corresponding index in v so that v[reverseind(v,i)] == reverse(v)[i]. (This can be nontrivial in cases where v contains non-ASCII characters.)

Examples

  1. julia> r = reverse("Julia")
  2. "ailuJ"
  3. julia> for i in 1:length(r)
  4. print(r[reverseind("Julia", i)])
  5. end
  6. Julia

source

Base.reverse! — Function.

  1. reverse!(v [, start=1 [, stop=length(v) ]]) -> v

In-place version of reverse.

Examples

  1. julia> A = Vector(1:5)
  2. 5-element Array{Int64,1}:
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. julia> reverse!(A);
  9. julia> A
  10. 5-element Array{Int64,1}:
  11. 5
  12. 4
  13. 3
  14. 2
  15. 1

source