Arrays

Constructors and Types

Core.AbstractArray —Type

AbstractArray{T,N}

Supertype forN-dimensional arrays (or array-like types) with elements of typeT.Array and other types are subtypes of this. See the manual section on theAbstractArray interface.

source

Base.AbstractVector —Type

AbstractVector{T}

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

source

Base.AbstractMatrix —Type

AbstractMatrix{T}

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

source

Base.AbstractVecOrMat —Type

AbstractVecOrMat{T}

Union type ofAbstractVector{T} andAbstractMatrix{T}.

source

Core.Array —Type

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

N-dimensional dense array with elements of typeT.

source

Core.Array —Method

Array{T}(undef, dims)Array{T,N}(undef, dims)

Construct an uninitializedN-dimensionalArray containing elements of typeT.N can either be supplied explicitly, as inArray{T,N}(undef, dims), or be determined by the length or number ofdims.dims may be a tuple or a series of integer arguments corresponding to the lengths in each dimension. If the rankN is supplied explicitly, then it must match the length or number ofdims. Hereundef is theUndefInitializer.

Examples

julia> A = Array{Float64, 2}(undef, 2, 3) # N given explicitly2×3 Matrix{Float64}: 6.90198e-310  6.90198e-310  6.90198e-310 6.90198e-310  6.90198e-310  0.0julia> B = Array{Float64}(undef, 4) # N determined by the input4-element Vector{Float64}:   2.360075077e-314 NaN   2.2671131793e-314   2.299821756e-314julia> similar(B, 2, 4, 1) # use typeof(B), and the given size2×4×1 Array{Float64, 3}:[:, :, 1] = 2.26703e-314  2.26708e-314  0.0           2.80997e-314 0.0           2.26703e-314  2.26708e-314  0.0

source

Core.Array —Method

Array{T}(nothing, dims)Array{T,N}(nothing, dims)

Construct anN-dimensionalArray containing elements of typeT, initialized withnothing entries. Element typeT must be able to hold these values, i.e.Nothing <: T.

Examples

julia> Array{Union{Nothing, String}}(nothing, 2)2-element Vector{Union{Nothing, String}}: nothing nothingjulia> Array{Union{Nothing, Int}}(nothing, 2, 3)2×3 Matrix{Union{Nothing, Int64}}: nothing  nothing  nothing nothing  nothing  nothing

source

Core.Array —Method

Array{T}(missing, dims)Array{T,N}(missing, dims)

Construct anN-dimensionalArray containing elements of typeT, initialized withmissing entries. Element typeT must be able to hold these values, i.e.Missing <: T.

Examples

julia> Array{Union{Missing, String}}(missing, 2)2-element Vector{Union{Missing, String}}: missing missingjulia> Array{Union{Missing, Int}}(missing, 2, 3)2×3 Matrix{Union{Missing, Int64}}: missing  missing  missing missing  missing  missing

source

Core.UndefInitializer —Type

UndefInitializer

Singleton type used in array initialization, indicating the array-constructor-caller would like an uninitialized array. See alsoundef, an alias forUndefInitializer().

Examples

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

source

Core.undef —Constant

undef

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

Basic functions

Base.ndims —Function

ndims(A::AbstractArray) -> Integer

Return the number of dimensions ofA.

Broadcast and vectorization

See also thedot syntax for vectorizing functions; for example,f.(args...) implicitly callsbroadcast(f, args...). Rather than relying on "vectorized" methods of functions likesin to operate on arrays, you should usesin.(a) to vectorize viabroadcast.

Base.Broadcast.broadcast —Function

broadcast(f, As...)

Broadcast the functionf over the arrays, tuples, collections,Refs and/or scalarsAs.

Broadcasting applies the functionf over the elements of the container arguments and the scalars themselves inAs. 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, includingNumbers,Strings,Symbols,Types,Functions and some common singletons likemissing andnothing. 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 anArray, but custom container types can define their own implementation and promotion-like rules to customize the result when they appear as arguments.
The element type is determined in the same manner as incollect.

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

Examples

julia> A = [1, 2, 3, 4, 5]5-element Vector{Int64}: 1 2 3 4 5julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]5×2 Matrix{Int64}: 1   2 3   4 5   6 7   8 9  10julia> broadcast(+, A, B)5×2 Matrix{Int64}:  2   3  5   6  8   9 11  12 14  15julia> parse.(Int, ["1", "2"])2-element Vector{Int64}: 1 2julia> abs.((1, -2))(1, 2)julia> broadcast(+, 1.0, (0, -2.0))(1.0, -1.0)julia> (+).([[0,2], [1,3]], Ref{Vector{Int}}([1,-1]))2-element Vector{Vector{Int64}}: [1, 1] [2, 2]julia> string.(("one","two","three","four"), ": ", 1:4)4-element Vector{String}: "one: 1" "two: 2" "three: 3" "four: 4"

source

Base.Broadcast.broadcast! —Function

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

Likebroadcast, but store the result ofbroadcast(f, As...) in thedest array. Note thatdest is only used to store the result, and does not supply arguments tof unless it is also listed in theAs, as inbroadcast!(f, A, A, B) to performA[:] = broadcast(f, A, B).

Examples

julia> A = [1.0; 0.0]; B = [0.0; 0.0];julia> broadcast!(+, B, A, (0, -2.0));julia> B2-element Vector{Float64}:  1.0 -2.0julia> A2-element Vector{Float64}: 1.0 0.0julia> broadcast!(+, A, A, (0, -2.0));julia> A2-element Vector{Float64}:  1.0 -2.0

source

Base.Broadcast.@__dot__ —Macro

@. expr

Convert every function call or operator inexpr into a "dot call" (e.g. convertf(x) tof.(x)), and convert every assignment inexpr to a "dot assignment" (e.g. convert+= to.+=).

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

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

Examples

julia> x = 1.0:3.0; y = similar(x);julia> @. y = x + 3 * sin(x)3-element Vector{Float64}: 3.5244129544236893 4.727892280477045 3.4233600241796016

source

Base.Broadcast.BroadcastFunction —Type

BroadcastFunction{F} <: Function

Represents the "dotted" version of an operator, which broadcasts the operator over its arguments, soBroadcastFunction(op) is functionally equivalent to(x...) -> (op).(x...).

Can be created by just passing an operator preceded by a dot to a higher-order function.

Examples

julia> a = [[1 3; 2 4], [5 7; 6 8]];julia> b = [[9 11; 10 12], [13 15; 14 16]];julia> map(.*, a, b)2-element Vector{Matrix{Int64}}: [9 33; 20 48] [65 105; 84 128]julia> Base.BroadcastFunction(+)(a, b) == a .+ btrue

Julia 1.6

BroadcastFunction and the standalone.op syntax are available as of Julia 1.6.

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 withx. To customize the broadcasting behavior of a type, one can declare a style by defining a type/method pair

struct MyContainerStyle <: BroadcastStyle endBase.BroadcastStyle(::Type{<:MyContainer}) = MyContainerStyle()

One then writes method(s) (at leastsimilar) operating onBroadcasted{MyContainerStyle}. There are also several pre-defined subtypes ofBroadcastStyle that you may be able to leverage; see theInterfaces chapter for more information.

source

Base.Broadcast.AbstractArrayStyle —Type

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

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

ForAbstractArray types that support arbitrary dimensionality,N can be set toAny:

struct MyArrayStyle <: Broadcast.AbstractArrayStyle{Any} endBase.BroadcastStyle(::Type{<:MyArray}) = MyArrayStyle()

In cases where you want to be able to mix multipleAbstractArrayStyles and keep track of dimensionality, your style needs to support aVal constructor:

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

Note that if two or moreAbstractArrayStyle subtypes conflict, broadcasting machinery will fall back to producingArrays. If this is undesirable, you may need to define binaryBroadcastStyle rules to control the output type.

Indexing and assignment

Base.getindex —Method

getindex(A, inds...)

Return a subset of arrayA as selected by the indicesinds.

Each index may be anysupported index type, such as anInteger,CartesianIndex,range, orarray of supported indices. A: may be used to select all elements along a specific dimension, and a boolean array (e.g. anArray{Bool} or aBitArray) may be used to filter for elements where the corresponding index istrue.

Wheninds selects multiple elements, this function returns a newly allocated array. To index multiple elements without making a copy, useview instead.

See the manual section onarray indexing for details.

Examples

julia> A = [1 2; 3 4]2×2 Matrix{Int64}: 1  2 3  4julia> getindex(A, 1)1julia> getindex(A, [2, 1])2-element Vector{Int64}: 3 1julia> getindex(A, 2:4)3-element Vector{Int64}: 3 2 4julia> getindex(A, 2, 1)3julia> getindex(A, CartesianIndex(2, 1))3julia> getindex(A, :, 2)2-element Vector{Int64}: 2 4julia> getindex(A, 2, :)2-element Vector{Int64}: 3 4julia> getindex(A, A .> 2)2-element Vector{Int64}: 3 4

source

Base.setindex! —Method

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

Store values from arrayX within some subset ofA as specified byinds. The syntaxA[inds...] = X is equivalent to(setindex!(A, X, inds...); X).

Warning

Behavior can be unexpected when any mutated argument shares memory with any other argument.

Examples

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

source

Base.nextind —Function

nextind(A, i)

Return the index afteri inA. The returned index is often equivalent toi + 1 for an integeri. This function can be useful for generic code.

Warning

The returned index might be out of bounds. Consider usingcheckbounds.

Views (SubArrays and other view types)

A “view” is a data structure that acts like an array (it is a subtype ofAbstractArray), but the underlying data is actually part of another array.

For example, ifx is an array andv = @view x[1:10], thenv acts like a 10-element array, but its data is actually accessing the first 10 elements ofx. Writing to a view, e.g.v[3] = 2, writes directly to the underlying arrayx (in this case modifyingx[3]).

Slicing operations likex[1:10] create a copy by default in Julia.@view x[1:10] changes it to make a view. The@views macro can be used on a whole block of code (e.g.@views function foo() .... end or@views begin ... end) to change all the slicing operations in that block to use views. Sometimes making a copy of the data is faster and sometimes using a view is faster, as described in theperformance tips.

Base.view —Function

view(A, inds...)

Likegetindex, but returns a lightweight array that lazily references (or is effectively aview into) the parent arrayA at the given index or indicesinds instead of eagerly extracting elements or constructing a copied subset. Callinggetindex orsetindex! on the returned value (often aSubArray) computes the indices to access or modify the parent array on the fly. The behavior is undefined if the shape of the parent array is changed afterview is called because there is no bound check for the parent array; e.g., it may cause a segmentation fault.

Some immutable parent arrays (like ranges) may choose to simply recompute a new array in some circumstances instead of returning aSubArray if doing so is efficient and provides compatible semantics.

Julia 1.6

In Julia 1.6 or later,view can be called on anAbstractString, returning aSubString.

Examples

julia> A = [1 2; 3 4]2×2 Matrix{Int64}: 1  2 3  4julia> b = view(A, :, 1)2-element view(::Matrix{Int64}, :, 1) with eltype Int64: 1 3julia> fill!(b, 0)2-element view(::Matrix{Int64}, :, 1) with eltype Int64: 0 0julia> A # Note A has changed even though we modified b2×2 Matrix{Int64}: 0  2 0  4julia> view(2:5, 2:3) # returns a range as type is immutable3:4

source

Base.@view —Macro

@view A[inds...]

Transform the indexing expressionA[inds...] into the equivalentview call.

This can only be applied directly to a single indexing expression and is particularly helpful for expressions that include the specialbegin orend indexing syntaxes likeA[begin, 2:end-1] (as those are not supported by the normalview function).

Note that@view cannot be used as the target of a regular assignment (e.g.,@view(A[1, 2:end]) = ...), nor would the un-decoratedindexed assignment (A[1, 2:end] = ...) or broadcasted indexed assignment (A[1, 2:end] .= ...) make a copy. It can be useful, however, forupdating broadcasted assignments like@view(A[1, 2:end]) .+= 1 because this is a simple syntax for@view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1, and the indexing expression on the right-hand side would otherwise make a copy without the@view.

See also@views to switch an entire block of code to use views for non-scalar indexing.

Julia 1.5

Usingbegin in an indexing expression to refer to the first index requires at least Julia 1.5.

Examples

julia> A = [1 2; 3 4]2×2 Matrix{Int64}: 1  2 3  4julia> b = @view A[:, 1]2-element view(::Matrix{Int64}, :, 1) with eltype Int64: 1 3julia> fill!(b, 0)2-element view(::Matrix{Int64}, :, 1) with eltype Int64: 0 0julia> A2×2 Matrix{Int64}: 0  2 0  4

source

Base.@views —Macro

@views expression

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

Similarly,@views converts string slices intoSubString views.

Note

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

Julia 1.5

Usingbegin in an indexing expression to refer to the first index was implemented in Julia 1.4, but was only supported by@views starting in Julia 1.5.

Examples

julia> A = zeros(3, 3);julia> @views for row in 1:3           b = A[row, :] # b is a view, not a copy           b .= row      # assign every element to the row index       endjulia> A3×3 Matrix{Float64}: 1.0  1.0  1.0 2.0  2.0  2.0 3.0  3.0  3.0

source

Base.parent —Function

parent(A)

Return the underlying parent object of the view. This parent of objects of typesSubArray,SubString,ReshapedArray orLinearAlgebra.Transpose is what was passed as an argument toview,reshape,transpose, etc. during object creation. If the input is not a wrapped object, return the input itself. If the input is wrapped multiple times, only the outermost wrapper will be removed.

Examples

julia> A = [1 2; 3 4]2×2 Matrix{Int64}: 1  2 3  4julia> V = view(A, 1:2, :)2×2 view(::Matrix{Int64}, 1:2, :) with eltype Int64: 1  2 3  4julia> parent(V)2×2 Matrix{Int64}: 1  2 3  4

source

Base.parentindices —Function

parentindices(A)

Return the indices in theparent which correspond to the viewA.

Examples

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

source

Base.selectdim —Function

selectdim(A, d::Integer, i)

Return a view of all the data ofA where the index for dimensiond equalsi.

Equivalent toview(A,:,:,...,i,:,:,...) wherei is in positiond.

Concatenation and permutation

Base.cat —Function

cat(A...; dims)

Concatenate the input arrays along the dimensions specified indims.

Along a dimensiond in dims, the size of the output array issum(size(a,d) for a in A). Along other dimensions, all input arrays should have the same size, which will also be the size of the output array along those dimensions.

Ifdims is a single number, the different arrays are tightly packed along that dimension. Ifdims is an iterable containing several dimensions, the positions along these dimensions are increased simultaneously for each input array, filling with zero elsewhere. This allows one to construct block-diagonal matrices ascat(matrices...; dims=(1,2)), and their higher-dimensional analogues.

The special casedims=1 isvcat, anddims=2 ishcat. See alsohvcat,hvncat,stack,repeat.

The keyword also acceptsVal(dims).

Julia 1.8

For multiple dimensionsdims = Val(::Tuple) was added in Julia 1.8.

Examples

Concatenate two arrays in different dimensions:

julia> a = [1 2 3]1×3 Matrix{Int64}: 1  2  3julia> b = [4 5 6]1×3 Matrix{Int64}: 4  5  6julia> cat(a, b; dims=1)2×3 Matrix{Int64}: 1  2  3 4  5  6julia> cat(a, b; dims=2)1×6 Matrix{Int64}: 1  2  3  4  5  6julia> cat(a, b; dims=(1, 2))2×6 Matrix{Int64}: 1  2  3  0  0  0 0  0  0  4  5  6

Extended Help

Concatenate 3D arrays:

julia> a = ones(2, 2, 3);julia> b = ones(2, 2, 4);julia> c = cat(a, b; dims=3);julia> size(c) == (2, 2, 7)true

Concatenate arrays of different sizes:

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # same as hcat2×6×1 Array{Float64, 3}:[:, :, 1] = 1.0  2.0  3.14159  10.0  10.0  10.0 3.0  4.0  3.14159  10.0  10.0  10.0

Construct a block diagonal matrix:

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # block-diagonal4×7 Matrix{Bool}: 1  0  0  0  0  0  0 0  1  1  0  0  0  0 0  1  1  0  0  0  0 0  0  0  1  1  1  1

julia> cat(1, [2], [3;;]; dims=Val(2))1×3 Matrix{Int64}: 1  2  3

Note

cat does not join two strings, you may want to use*.

julia> a = "aaa";julia> b = "bbb";julia> cat(a, b; dims=1)2-element Vector{String}: "aaa" "bbb"julia> cat(a, b; dims=2)1×2 Matrix{String}: "aaa"  "bbb"julia> a * b"aaabbb"

source

Base.vcat —Function

vcat(A...)

Concatenate arrays or numbers vertically. Equivalent tocat(A...; dims=1), and to the syntax[a; b; c].

To concatenate a large vector of arrays,reduce(vcat, A) calls an efficient method whenA isa AbstractVector{<:AbstractVecOrMat}, rather than working pairwise.

Examples

julia> v = vcat([1,2], [3,4])4-element Vector{Int64}: 1 2 3 4julia> v == vcat(1, 2, [3,4])  # accepts numberstruejulia> v == [1; 2; [3,4]]  # syntax for the same operationtruejulia> summary(ComplexF64[1; 2; [3,4]])  # syntax for supplying the element type"4-element Vector{ComplexF64}"julia> vcat(range(1, 2, length=3))  # collects lazy ranges3-element Vector{Float64}: 1.0 1.5 2.0julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # row vector and a matrix(adjoint([10, 20, 30]), [4.0 5.0 6.0; 7.0 8.0 9.0])julia> vcat(two...)3×3 Matrix{Float64}: 10.0  20.0  30.0  4.0   5.0   6.0  7.0   8.0   9.0julia> vs = [[1, 2], [3, 4], [5, 6]];julia> reduce(vcat, vs)  # more efficient than vcat(vs...)6-element Vector{Int64}: 1 2 3 4 5 6julia> ans == collect(Iterators.flatten(vs))true

source

Base.hcat —Function

hcat(A...)

Concatenate arrays or numbers horizontally. Equivalent tocat(A...; dims=2), and to the syntax[a b c] or[a;; b;; c].

For a large vector of arrays,reduce(hcat, A) calls an efficient method whenA isa AbstractVector{<:AbstractVecOrMat}. For a vector of vectors, this can also be writtenstack(A).

Array functions

Base.accumulate —Function

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

Cumulative operationop along the dimensiondims ofA (providingdims is optional for vectors). An initial valueinit may optionally be provided by a keyword argument. See alsoaccumulate! 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 ofaccumulate, seecumsum,cumprod. For a lazy version, seeIterators.accumulate.

Julia 1.5

accumulate on a non-array iterator requires at least Julia 1.5.

Examples

julia> accumulate(+, [1,2,3])3-element Vector{Int64}: 1 3 6julia> accumulate(min, (1, -2, 3, -4, 5), init=0)(0, -2, -2, -4, -4)julia> accumulate(/, (2, 4, Inf), init=100)(50.0, 12.5, 0.0)julia> accumulate(=>, i^2 for i in 1:3)3-element Vector{Any}:          1        1 => 4 (1 => 4) => 9julia> accumulate(+, fill(1, 3, 4))3×4 Matrix{Int64}: 1  4  7  10 2  5  8  11 3  6  9  12julia> accumulate(+, fill(1, 2, 5), dims=2, init=100.0)2×5 Matrix{Float64}: 101.0  102.0  103.0  104.0  105.0 101.0  102.0  103.0  104.0  105.0

source

Base.accumulate! —Function

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

Cumulative operationop onA along the dimensiondims, storing the result inB. Providingdims is optional for vectors. If the keyword argumentinit is given, its value is used to instantiate the accumulation.

Warning

Behavior can be unexpected when any mutated argument shares memory with any other argument.

Examples

julia> x = [1, 0, 2, 0, 3];julia> y = rand(5);julia> accumulate!(+, y, x);julia> y5-element Vector{Float64}: 1.0 1.0 3.0 3.0 6.0julia> A = [1 2 3; 4 5 6];julia> B = similar(A);julia> accumulate!(-, B, A, dims=1)2×3 Matrix{Int64}:  1   2   3 -3  -3  -3julia> accumulate!(*, B, A, dims=2, init=10)2×3 Matrix{Int64}: 10   20    60 40  200  1200

source

Base.cumprod —Function

cumprod(itr)

Cumulative product of an iterator.

Julia 1.5

cumprod on a non-array iterator requires at least Julia 1.5.

Examples

julia> cumprod(fill(1//2, 3))3-element Vector{Rational{Int64}}: 1//2 1//4 1//8julia> cumprod((1, 2, 1, 3, 1))(1, 2, 2, 6, 6)julia> cumprod("julia")5-element Vector{String}: "j" "ju" "jul" "juli" "julia"

source

cumprod(A; dims::Integer)

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

Examples

julia> a = Int8[1 2 3; 4 5 6];julia> cumprod(a, dims=1)2×3 Matrix{Int64}: 1   2   3 4  10  18julia> cumprod(a, dims=2)2×3 Matrix{Int64}: 1   2    6 4  20  120

source

Base.cumprod! —Function

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

Cumulative product of a vectorx, storing the result iny. See alsocumprod.

Warning

Behavior can be unexpected when any mutated argument shares memory with any other argument.

source

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

Cumulative product ofA along the dimensiondims, storing the result inB. See alsocumprod.

Warning

Behavior can be unexpected when any mutated argument shares memory with any other argument.

source

Base.cumsum —Function

cumsum(itr)

Cumulative sum of an iterator.

See alsoaccumulate to apply functions other than+.

Julia 1.5

cumsum on a non-array iterator requires at least Julia 1.5.

Examples

julia> cumsum(1:3)3-element Vector{Int64}: 1 3 6julia> cumsum((true, false, true, false, true))(1, 1, 2, 2, 3)julia> cumsum(fill(1, 2) for i in 1:3)3-element Vector{Vector{Int64}}: [1, 1] [2, 2] [3, 3]

source

cumsum(A; dims::Integer)

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

Examples

julia> a = [1 2 3; 4 5 6]2×3 Matrix{Int64}: 1  2  3 4  5  6julia> cumsum(a, dims=1)2×3 Matrix{Int64}: 1  2  3 5  7  9julia> cumsum(a, dims=2)2×3 Matrix{Int64}: 1  3   6 4  9  15

Note

The return array'seltype isInt for signed integers of less than system word size andUInt for unsigned integers of less than system word size. To preserveeltype of arrays with small signed or unsigned integeraccumulate(+, A) should be used.

julia> cumsum(Int8[100, 28])2-element Vector{Int64}: 100 128julia> accumulate(+,Int8[100, 28])2-element Vector{Int8}:  100 -128

In the former case, the integers are widened to system word size and therefore the result isInt64[100, 128]. In the latter case, no such widening happens and integer overflow results inInt8[100, -128].

source

Base.cumsum! —Function

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

Cumulative sum ofA along the dimensiondims, storing the result inB. See alsocumsum.

Warning

Behavior can be unexpected when any mutated argument shares memory with any other argument.

source

Base.diff —Function

diff(A::AbstractVector)diff(A::AbstractArray; dims::Integer)

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

Julia 1.1

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

Examples

julia> a = [2 4; 6 16]2×2 Matrix{Int64}: 2   4 6  16julia> diff(a, dims=2)2×1 Matrix{Int64}:  2 10julia> diff(vec(a))3-element Vector{Int64}:  4 -2 12

source

Base.repeat —Function

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

Repeat a characterr times. This can equivalently be accomplished by callingc^r.

Examples

julia> repeat('A', 3)"AAA"

source

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

Repeat a stringr times. This can be written ass^r.

Combinatorics

Base.invperm —Function

invperm(v)

Return the inverse permutation ofv. IfB = A[v], thenA == B[invperm(v)].

Examples

julia> p = (2, 3, 1);julia> invperm(p)(3, 1, 2)julia> v = [2; 4; 3; 1];julia> invperm(v)4-element Vector{Int64}: 4 1 3 2julia> A = ['a','b','c','d'];julia> B = A[v]4-element Vector{Char}: 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase) 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase) 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase) 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)julia> B[invperm(v)]4-element Vector{Char}: 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase) 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase) 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase) 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

source

Base.isperm —Function

isperm(v) -> Bool

Returntrue ifv is a valid permutation.

Examples

julia> isperm([1; 2])truejulia> isperm([1; 3])false

source

Base.permute! —Method

permute!(v, p)

Permute vectorv in-place, according to permutationp. No checking is done to verify thatp is a permutation.

To return a new permutation, usev[p]. This is generally faster thanpermute!(v, p); it is even faster to write into a pre-allocated output array withu .= @view v[p]. (Even thoughpermute! overwritesv in-place, it internally requires some allocation to keep track of which elements have been moved.)

Warning

Behavior can be unexpected when any mutated argument shares memory with any other argument.

Movatterモバイル変換