Arrays

AbstractArray{T,N}

Obertyp für N-dimensionale Arrays (oder array-ähnliche Typen) mit Elementen des Typs T. Array und andere Typen sind Untertypen davon. Siehe den Handbuchabschnitt über die AbstractArray-Schnittstelle.

Siehe auch: AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

Obertyp für eindimensionale Arrays (oder array-ähnliche Typen) mit Elementen des Typs T. Alias für AbstractArray{T,1}.

AbstractMatrix{T}

Obertyp für zweidimensionale Arrays (oder array-ähnliche Typen) mit Elementen des Typs T. Alias für AbstractArray{T,2}.

AbstractVecOrMat{T}

Vereinigungstyp von AbstractVector{T} und AbstractMatrix{T}.

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

N-dimensionale dichte Array mit Elementen vom Typ T.

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

Konstruiere ein nicht initialisiertes N-dimensionales Array, das Elemente des Typs T enthält. N kann entweder explizit angegeben werden, wie in Array{T,N}(undef, dims), oder durch die Länge oder Anzahl von dims bestimmt werden. dims kann ein Tupel oder eine Reihe von ganzzahligen Argumenten sein, die den Längen in jeder Dimension entsprechen. Wenn der Rang N explizit angegeben wird, muss er mit der Länge oder Anzahl von dims übereinstimmen. Hier ist undef der UndefInitializer.

Beispiele

julia> A = Array{Float64, 2}(undef, 2, 3) # N wird explizit angegeben
2×3 Matrix{Float64}:
 6.90198e-310  6.90198e-310  6.90198e-310
 6.90198e-310  6.90198e-310  0.0

julia> B = Array{Float64}(undef, 4) # N wird durch die Eingabe bestimmt
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # verwende typeof(B) und die angegebene Größe
2×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

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

Konstruiere ein N-dimensionales Array, das Elemente des Typs T enthält, initialisiert mit nichts Einträgen. Der Elementtyp T muss in der Lage sein, diese Werte zu halten, d.h. Nothing <: T.

Beispiele

julia> Array{Union{Nothing, String}}(nichts, 2)
2-element Vector{Union{Nothing, String}}:
 nichts
 nichts

julia> Array{Union{Nothing, Int}}(nichts, 2, 3)
2×3 Matrix{Union{Nothing, Int64}}:
 nichts  nichts  nichts
 nichts  nichts  nichts

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

Konstruiere ein N-dimensionales Array, das Elemente des Typs T enthält, initialisiert mit missing Einträgen. Der Elementtyp T muss in der Lage sein, diese Werte zu halten, d.h. Missing <: T.

Beispiele

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

julia> Array{Union{Missing, Int}}(missing, 2, 3)
2×3 Matrix{Union{Missing, Int64}}:
 missing  missing  missing
 missing  missing  missing

UndefInitializer

Singleton-Typ, der bei der Array-Initialisierung verwendet wird und anzeigt, dass der Array-Konstruktor-Aufrufer ein uninitialisiertes Array wünscht. Siehe auch undef, ein Alias für UndefInitializer().

Beispiele

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

undef

Alias für UndefInitializer(), das eine Instanz des Singleton-Typs UndefInitializer erstellt, der bei der Array-Initialisierung verwendet wird, um anzuzeigen, dass der Array-Konstruktor-Aufrufer ein uninitialisiertes Array wünscht.

Siehe auch: missing, similar.

Beispiele

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

Vector{T} <: AbstractVector{T}

Eindimensionales dichtes Array mit Elementen des Typs T, das häufig verwendet wird, um einen mathematischen Vektor darzustellen. Alias für Array{T,1}.

Siehe auch empty, similar und zero zum Erstellen von Vektoren.

Vector{T}(undef, n)

Konstruiere einen nicht initialisierten Vector{T} der Länge n.

Beispiele

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

Vector{T}(nichts, m)

Konstruiere einen Vector{T} der Länge m, initialisiert mit nichts Einträgen. Der Elementtyp T muss in der Lage sein, diese Werte zu halten, d.h. Nichts <: T.

Beispiele

julia> Vector{Union{Nichts, String}}(nichts, 2)
2-element Vector{Union{Nichts, String}}:
 nichts
 nichts

Vector{T}(missing, m)

Konstruiere einen Vector{T} der Länge m, initialisiert mit missing Einträgen. Der Elementtyp T muss in der Lage sein, diese Werte zu halten, d.h. Missing <: T.

Beispiele

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

Matrix{T} <: AbstractMatrix{T}

Zweidimensionales dichtes Array mit Elementen des Typs T, das häufig zur Darstellung einer mathematischen Matrix verwendet wird. Alias für Array{T,2}.

Siehe auch fill, zeros, undef und similar zum Erstellen von Matrizen.

Matrix{T}(undef, m, n)

Konstruiere eine nicht initialisierte Matrix{T} der Größe m×n.

Beispiele

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

julia> similar(ans, Int32, 2, 2)
2×2 Matrix{Int32}:
 490537216  1277177453
         1  1936748399

Matrix{T}(nothing, m, n)

Konstruiere eine Matrix{T} der Größe m×n, initialisiert mit nothing Einträgen. Der Elementtyp T muss in der Lage sein, diese Werte zu halten, d.h. Nothing <: T.

Beispiele

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

Matrix{T}(missing, m, n)

Konstruiere eine Matrix{T} der Größe m×n, initialisiert mit missing Einträgen. Der Elementtyp T muss in der Lage sein, diese Werte zu halten, d.h. Missing <: T.

Beispiele

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

VecOrMat{T}

Union-Typ von Vector{T} und Matrix{T}, der es Funktionen ermöglicht, entweder eine Matrix oder einen Vektor zu akzeptieren.

Beispiele

julia> Vector{Float64} <: VecOrMat{Float64}
true

julia> Matrix{Float64} <: VecOrMat{Float64}
true

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

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

N-dimensionale dichte Array mit Elementen vom Typ T. Die Elemente eines dichten Arrays werden zusammenhängend im Speicher gespeichert.

DenseVector{T}

Eindimensionaler DenseArray mit Elementen vom Typ T. Alias für DenseArray{T,1}.

DenseMatrix{T}

Zweidimensionales DenseArray mit Elementen des Typs T. Alias für DenseArray{T,2}.

DenseVecOrMat{T}

Vereinigungstyp von DenseVector{T} und DenseMatrix{T}.

StridedArray{T, N}

Ein fest codierter Union gängiger Array-Typen, die der strided array interface folgen, mit Elementen vom Typ T und N Dimensionen.

Wenn A ein StridedArray ist, dann werden seine Elemente im Speicher mit Offsets gespeichert, die zwischen den Dimensionen variieren können, aber innerhalb einer Dimension konstant sind. Zum Beispiel könnte A in Dimension 1 einen Stride von 2 und in Dimension 2 einen Stride von 3 haben. Das Inkrementieren von A entlang der Dimension d springt im Speicher um [stride(A, d)] Slots. Strided Arrays sind besonders wichtig und nützlich, da sie manchmal direkt als Zeiger an Bibliotheken fremder Sprachen wie BLAS übergeben werden können.

StridedVector{T}

Eindimensionaler StridedArray mit Elementen vom Typ T.

StridedMatrix{T}

Zweidimensionales StridedArray mit Elementen des Typs T.

StridedVecOrMat{T}

Unionstyp von StridedVector und StridedMatrix mit Elementen des Typs T.

GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: DenseVector{T}

Feste Größe DenseVector{T}.

kind kann derzeit entweder :not_atomic oder :atomic sein. Für Details zu dem, was :atomic impliziert, siehe AtomicMemory

addrspace kann derzeit nur auf Core.CPU gesetzt werden. Es ist so konzipiert, dass es die Erweiterung durch andere Systeme wie GPUs ermöglicht, die Werte wie folgt definieren könnten:

module CUDA
const Generic = bitcast(Core.AddrSpace{CUDA}, 0)
const Global = bitcast(Core.AddrSpace{CUDA}, 1)
end

Die genauen Semantiken dieser anderen addrspaces werden durch das spezifische Backend definiert, aber es wird einen Fehler geben, wenn der Benutzer versucht, diese auf der CPU zuzugreifen.

Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}

Festgelegte Größe DenseVector{T}.

`memoryref(::GenericMemory)`

Konstruiere ein GenericMemoryRef aus einem Speicherobjekt. Dies schlägt nicht fehl, aber der resultierende Speicher zeigt nur dann außerhalb der Grenzen, wenn der Speicher leer ist.

memoryref(::GenericMemory, index::Integer)
memoryref(::GenericMemoryRef, index::Integer)

Konstruiere einen GenericMemoryRef aus einem Speicherobjekt und einem Offset-Index (1-basiert), der auch negativ sein kann. Dies gibt immer ein gültiges Objekt zurück und wirft einen Fehler, wenn dies nicht möglich ist (weil der Index zu einer Verschiebung außerhalb der Grenzen des zugrunde liegenden Speichers führen würde).

Slices{P,SM,AX,S,N} <: AbstractSlices{S,N}

Ein AbstractArray von Schnitten in ein übergeordnete Array über die angegebenen Dimension(en), das Ansichten zurückgibt, die alle Daten aus den anderen Dimension(en) auswählen.

Diese sollten typischerweise durch eachslice, eachcol oder eachrow erstellt werden.

parent(s::Slices) gibt das übergeordnete Array zurück.

RowSlices{M,AX,S}

Ein Sonderfall von Slices, der ein Vektor von Zeilenschnitten einer Matrix ist, wie sie durch eachrow erstellt werden.

parent kann verwendet werden, um die zugrunde liegende Matrix zu erhalten.

ColumnSlices{M,AX,S}

Ein Sonderfall von Slices, der ein Vektor von Spaltenausschnitten einer Matrix ist, wie sie durch eachcol erstellt werden.

parent kann verwendet werden, um die zugrunde liegende Matrix zu erhalten.

getindex(type[, elements...])

Konstruiere ein 1-d Array des angegebenen Typs. Dies wird normalerweise mit der Syntax Type[] aufgerufen. Elementwerte können mit Type[a,b,c,...] angegeben werden.

Beispiele

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

julia> getindex(Int8, 1, 2, 3)
3-element Vector{Int8}:
 1
 2
 3

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

Erstellt ein Array mit dem Elementtyp T, das aus lauter Nullen besteht und dessen Größe durch dims angegeben wird. Siehe auch fill, ones, zero.

Beispiele

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

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
 0  0  0
 0  0  0

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

Erstellt ein Array mit dem Elementtyp T, das aus lauter Einsen besteht und dessen Größe durch dims angegeben wird. Siehe auch fill, zeros.

Beispiele

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

julia> ones(ComplexF64, 2, 3)
2×3 Matrix{ComplexF64}:
 1.0+0.0im  1.0+0.0im  1.0+0.0im
 1.0+0.0im  1.0+0.0im  1.0+0.0im

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

Speichereffizientes N-dimensionales Boolesches Array, das für jeden Booleschen Wert nur ein Bit verwendet.

BitArrays packen bis zu 64 Werte in jede 8 Bytes, was zu einer 8-fachen Speichereffizienz im Vergleich zu Array{Bool, N} führt und es ermöglicht, einige Operationen auf 64 Werten gleichzeitig auszuführen.

Standardmäßig gibt Julia BitArrays von Broadcasting Operationen zurück, die Boolesche Elemente erzeugen (einschließlich punktierter Vergleiche wie .==) sowie von den Funktionen trues und falses.

!!! Hinweis Aufgrund seines kompakten Speicherformats ist der gleichzeitige Zugriff auf die Elemente eines BitArray, bei dem mindestens eines von ihnen ein Schreibzugriff ist, nicht threadsicher.

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

Konstruiere ein undef BitArray mit den gegebenen Dimensionen. Verhält sich identisch zum Array Konstruktor. Siehe undef.

Beispiele

julia> BitArray(undef, 2, 2)
2×2 BitMatrix:
 0  0
 0  0

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

BitArray(itr)

Konstruiere ein BitArray, das durch das gegebene iterable Objekt erzeugt wird. Die Form wird aus dem itr-Objekt abgeleitet.

Beispiele

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

julia> BitArray(x+y == 3 for x = 1:2, y = 1:3)
2×3 BitMatrix:
 0  1  0
 1  0  0

julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
6-element BitVector:
 0
 1
 0
 1
 0
 0

trues(dims)

Erstellt ein BitArray mit allen Werten, die auf true gesetzt sind.

Beispiele

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

falses(dims)

Erstellt ein BitArray mit allen Werten, die auf false gesetzt sind.

Beispiele

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

fill(value, dims::Tuple)
fill(value, dims...)

Erstellt ein Array der Größe dims, wobei jeder Ort auf value gesetzt ist.

Zum Beispiel gibt fill(1.0, (5,5)) ein 5×5-Array von Fließkommazahlen zurück, mit 1.0 an jedem Ort des Arrays.

Die Längen der Dimensionen dims können entweder als Tuple oder als eine Sequenz von Argumenten angegeben werden. Ein N-längiges Tuple oder N Argumente, die dem value folgen, spezifizieren ein N-dimensionales Array. Daher ist ein gängiges Idiom zur Erstellung eines null-dimensionalen Arrays, dessen einziger Ort auf x gesetzt ist, fill(x).

Jeder Ort des zurückgegebenen Arrays ist auf (und ist somit === zu) dem value gesetzt, das übergeben wurde; das bedeutet, dass, wenn das value selbst geändert wird, alle Elemente des gefüllten Arrays diese Änderung widerspiegeln, weil sie immer noch genau dieses value sind. Dies ist bei fill(1.0, (5,5)) unbedenklich, da das value 1.0 unveränderlich ist und nicht selbst geändert werden kann, kann jedoch bei veränderlichen Werten wie – am häufigsten – Arrays unerwartet sein. Zum Beispiel platziert fill([], 3) das genau gleiche leere Array an allen drei Orten des zurückgegebenen Vektors:

julia> v = fill([], 3)
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v[1] === v[2] === v[3]
true

julia> value = v[1]
Any[]

julia> push!(value, 867_5309)
1-element Vector{Any}:
 8675309

julia> v
3-element Vector{Vector{Any}}:
 [8675309]
 [8675309]
 [8675309]

Um ein Array mit vielen unabhängigen inneren Arrays zu erstellen, verwenden Sie stattdessen eine Komprehension. Dies erstellt bei jeder Iteration der Schleife ein neues und distinct Array:

julia> v2 = [[] for _ in 1:3]
3-element Vector{Vector{Any}}:
 []
 []
 []

julia> v2[1] === v2[2] === v2[3]
false

julia> push!(v2[1], 8675309)
1-element Vector{Any}:
 8675309

julia> v2
3-element Vector{Vector{Any}}:
 [8675309]
 []
 []

Siehe auch: fill!, zeros, ones, similar.

Beispiele

julia> fill(1.0, (2,3))
2×3 Matrix{Float64}:
 1.0  1.0  1.0
 1.0  1.0  1.0

julia> fill(42)
0-dimensional Array{Int64, 0}:
42

julia> A = fill(zeros(2), 2) # setzt beide Elemente auf den gleichen [0.0, 0.0] Vektor
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # ändert den gefüllten Wert auf [42.0, 0.0]

julia> A # sowohl A[1] als auch A[2] sind der genau gleiche Vektor
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

Fülle das Array A mit dem Wert x. Wenn x eine Objektreferenz ist, werden alle Elemente auf dasselbe Objekt verweisen. fill!(A, Foo()) gibt A zurück, das mit dem Ergebnis der einmaligen Auswertung von Foo() gefüllt ist.

Beispiele

julia> A = zeros(2,3)
2×3 Matrix{Float64}:
 0.0  0.0  0.0
 0.0  0.0  0.0

julia> fill!(A, 2.)
2×3 Matrix{Float64}:
 2.0  2.0  2.0
 2.0  2.0  2.0

julia> a = [1, 1, 1]; A = fill!(Vector{Vector{Int}}(undef, 3), a); a[1] = 2; A
3-element Vector{Vector{Int64}}:
 [2, 1, 1]
 [2, 1, 1]
 [2, 1, 1]

julia> x = 0; f() = (global x += 1; x); fill!(Vector{Int}(undef, 3), f())
3-element Vector{Int64}:
 1
 1
 1

empty(x::Tuple)

Gibt ein leeres Tuple zurück, ().

empty(v::AbstractVector, [eltype])

Erstellt einen leeren Vektor, der v ähnlich ist, wobei optional der eltype geändert werden kann.

Siehe auch: empty!, isempty, isassigned.

Beispiele

julia> empty([1.0, 2.0, 3.0])
Float64[]

julia> empty([1.0, 2.0, 3.0], String)
String[]

empty(a::AbstractDict, [index_type=keytype(a)], [value_type=valtype(a)])

Erstellt einen leeren AbstractDict-Container, der Indizes vom Typ index_type und Werte vom Typ value_type akzeptieren kann. Die zweiten und dritten Argumente sind optional und standardmäßig auf den keytype und valtype des Eingangs gesetzt. (Wenn nur einer der beiden Typen angegeben ist, wird angenommen, dass es sich um den value_type handelt, und der index_type wird standardmäßig auf keytype(a) gesetzt).

Benutzerdefinierte AbstractDict-Subtypen können wählen, welcher spezifische Dictionary-Typ am besten für die gegebenen Index- und Werttypen geeignet ist, indem sie sich auf die dre argumentige Signatur spezialisieren. Der Standardwert ist, ein leeres Dict zurückzugeben.

similar(A::AbstractSparseMatrixCSC{Tv,Ti}, [::Type{TvNew}, ::Type{TiNew}, m::Integer, n::Integer]) where {Tv,Ti}

Erstellt ein nicht initialisiertes veränderliches Array mit dem angegebenen Elementtyp, Indextyp und der Größe, basierend auf der gegebenen Quelle SparseMatrixCSC. Die neue spärliche Matrix behält die Struktur der ursprünglichen spärlichen Matrix bei, es sei denn, die Dimensionen der Ausgabematrix unterscheiden sich von der Ausgabe.

Die Ausgabematrix hat Nullen an denselben Stellen wie die Eingabe, aber nicht initialisierte Werte für die nicht nullen Stellen.

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

Erstellt ein nicht initialisiertes veränderliches Array mit dem angegebenen Elementtyp und der Größe, basierend auf dem gegebenen Quell-Array. Die zweiten und dritten Argumente sind beide optional und standardmäßig auf den eltype und die size des gegebenen Arrays gesetzt. Die Dimensionen können entweder als einzelnes Tupel-Argument oder als eine Reihe von Ganzzahl-Argumenten angegeben werden.

Benutzerdefinierte AbstractArray-Subtypen können wählen, welcher spezifische Array-Typ am besten geeignet ist, um den gegebenen Elementtyp und die Dimensionalität zurückzugeben. Wenn sie diese Methode nicht spezialisieren, ist der Standard ein Array{element_type}(undef, dims...).

Zum Beispiel gibt similar(1:10, 1, 4) ein nicht initialisiertes Array{Int,2} zurück, da Bereiche weder veränderlich sind noch 2 Dimensionen unterstützen:

julia> similar(1:10, 1, 4)
1×4 Matrix{Int64}:
 4419743872  4374413872  4419743888  0

Umgekehrt gibt similar(trues(10,10), 2) ein nicht initialisiertes BitVector mit zwei Elementen zurück, da BitArrays sowohl veränderlich sind als auch 1-dimensionale Arrays unterstützen können:

julia> similar(trues(10,10), 2)
2-element BitVector:
 0
 0

Da BitArrays jedoch nur Elemente des Typs Bool speichern können, wird ein reguläres Array erstellt, wenn Sie einen anderen Elementtyp anfordern:

julia> similar(falses(10), Float64, 2, 4)
2×4 Matrix{Float64}:
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
 2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314

Siehe auch: undef, isassigned.

similar(storagetype, axes)

Erstellt ein uninitialisiertes veränderliches Array, das dem durch storagetype angegebenen entspricht, jedoch mit axes, die durch das letzte Argument angegeben sind.

Beispiele:

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

erstellt ein Array, das "wie" ein Array{Int} funktioniert (und möglicherweise tatsächlich von einem unterstützt wird), aber das identisch zu A indiziert wird. Wenn A eine konventionelle Indizierung hat, ist dies identisch zu Array{Int}(undef, size(A)), aber wenn A eine unkonventionelle Indizierung hat, dann stimmen die Indizes des Ergebnisses mit denen von A überein.

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

würde ein eindimensionales logisches Array erstellen, dessen Indizes mit denen der Spalten von A übereinstimmen. ```

ndims(A::AbstractArray) -> Integer

Gibt die Anzahl der Dimensionen von A zurück.

Siehe auch: size, axes.

Beispiele

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

Gibt ein Tupel zurück, das die Dimensionen von A enthält. Optional können Sie eine Dimension angeben, um nur die Länge dieser Dimension zu erhalten.

Beachten Sie, dass size möglicherweise nicht für Arrays mit nicht standardmäßigen Indizes definiert ist, in diesem Fall kann axes nützlich sein. Siehe das Handbuchkapitel über Arrays mit benutzerdefinierten Indizes.

Siehe auch: length, ndims, eachindex, sizeof.

Beispiele

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

julia> size(A)
(2, 3, 4)

julia> size(A, 2)
3

axes(A)

Gibt das Tupel der gültigen Indizes für das Array A zurück.

Siehe auch: size, keys, eachindex.

Beispiele

julia> A = fill(1, (5,6,7));

julia> axes(A)
(Base.OneTo(5), Base.OneTo(6), Base.OneTo(7))

axes(A, d)

Gibt den gültigen Bereich der Indizes für das Array A entlang der Dimension d zurück.

Siehe auch size und das Handbuchkapitel über Arrays mit benutzerdefinierten Indizes.

Beispiele

julia> A = fill(1, (5,6,7));

julia> axes(A, 2)
Base.OneTo(6)

julia> axes(A, 4) == 1:1  # alle Dimensionen d > ndims(A) haben die Größe 1
true

Verwendungshinweis

Jeder der Indizes muss ein AbstractUnitRange{<:Integer} sein, kann aber gleichzeitig ein Typ sein, der benutzerdefinierte Indizes verwendet. Wenn Sie beispielsweise eine Teilmenge benötigen, verwenden Sie verallgemeinerte Indexierungs-Konstrukte wie begin/end oder firstindex/lastindex:

ix = axes(v, 1)
ix[2:end]          # funktioniert z.B. für Vector, kann aber allgemein fehlschlagen
ix[(begin+1):end]  # funktioniert für verallgemeinerte Indizes

length(A::AbstractArray)

Gibt die Anzahl der Elemente im Array zurück, standardmäßig prod(size(A)).

Beispiele

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

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

keys(a::AbstractArray)

Gibt ein effizientes Array zurück, das alle gültigen Indizes für a beschreibt, angeordnet in der Form von a selbst.

Die Schlüssel von eindimensionalen Arrays (Vektoren) sind Ganzzahlen, während alle anderen N-dimensionalen Arrays CartesianIndex verwenden, um ihre Positionen zu beschreiben. Oft werden die speziellen Array-Typen LinearIndices und CartesianIndices verwendet, um diese Arrays von Ganzzahlen und CartesianIndex-Objekten effizient darzustellen.

Beachten Sie, dass die keys eines Arrays möglicherweise nicht der effizienteste Indextyp sind; für maximale Leistung verwenden Sie stattdessen eachindex.

Beispiele

julia> keys([4, 5, 6])
3-element LinearIndices{1, Tuple{Base.OneTo{Int64}}}:
 1
 2
 3

julia> keys([4 5; 6 7])
CartesianIndices((2, 2))

eachindex(A...)
eachindex(::IndexStyle, A::AbstractArray...)

Erstellen Sie ein iterierbares Objekt, um jeden Index eines AbstractArray A effizient zu besuchen. Für Array-Typen, die sich für schnelles lineares Indizieren entschieden haben (wie Array), ist dies einfach der Bereich 1:length(A), wenn sie 1-basiertes Indizieren verwenden. Für Array-Typen, die sich nicht für schnelles lineares Indizieren entschieden haben, wird typischerweise ein spezialisiertes kartesisches Intervall zurückgegeben, um effizient in das Array mit für jede Dimension angegebenen Indizes zu indizieren.

Im Allgemeinen akzeptiert eachindex beliebige Iterables, einschließlich Strings und Dictionaries, und gibt ein Iterator-Objekt zurück, das beliebige Indextypen unterstützt (z. B. ungleichmäßig verteilte oder nicht-ganzzahlige Indizes).

Wenn A ein AbstractArray ist, ist es möglich, den Stil der Indizes, die von eachindex zurückgegeben werden sollen, explizit anzugeben, indem ein Wert vom Typ IndexStyle als erstes Argument übergeben wird (typischerweise IndexLinear(), wenn lineare Indizes erforderlich sind, oder IndexCartesian(), wenn ein kartesisches Intervall gewünscht ist).

Wenn Sie mehr als ein AbstractArray-Argument übergeben, erstellt eachindex ein iterierbares Objekt, das für alle Argumente schnell ist (typischerweise ein UnitRange, wenn alle Eingaben schnelles lineares Indizieren haben, andernfalls ein CartesianIndices). Wenn die Arrays unterschiedliche Größen und/oder Dimensionen haben, wird eine DimensionMismatch-Ausnahme ausgelöst.

Siehe auch pairs(A), um über Indizes und Werte zusammen zu iterieren, und axes(A, 2), um gültige Indizes entlang einer Dimension zu erhalten.

Beispiele

julia> A = [10 20; 30 40];

julia> for i in eachindex(A) # lineares Indizieren
           println("A[", i, "] == ", A[i])
       end
A[1] == 10
A[2] == 30
A[3] == 20
A[4] == 40

julia> for i in eachindex(view(A, 1:2, 1:1)) # kartesisches Indizieren
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle gibt den "nativen Indexierungsstil" für das Array A an. Wenn Sie einen neuen AbstractArray Typ definieren, können Sie wählen, ob Sie entweder die lineare Indexierung (mit IndexLinear) oder die kartesische Indexierung implementieren möchten. Wenn Sie sich entscheiden, nur die lineare Indexierung zu implementieren, müssen Sie dieses Merkmal für Ihren Array-Typ festlegen:

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

Der Standardwert ist IndexCartesian().

Julias interne Indexierungsmechanismen werden automatisch (und unsichtbar) alle Indexierungsoperationen in den bevorzugten Stil umrechnen. Dies ermöglicht es Benutzern, auf Elemente Ihres Arrays mit jedem Indexierungsstil zuzugreifen, selbst wenn keine expliziten Methoden bereitgestellt wurden.

Wenn Sie beide Indexierungsstile für Ihr AbstractArray definieren, kann dieses Merkmal verwendet werden, um den leistungsfähigsten Indexierungsstil auszuwählen. Einige Methoden überprüfen dieses Merkmal bei ihren Eingaben und leiten je nach dem effizientesten Zugriffsmodus an unterschiedliche Algorithmen weiter. Insbesondere erstellt eachindex einen Iterator, dessen Typ von der Einstellung dieses Merkmals abhängt.

IndexLinear()

Untertyp von IndexStyle, der verwendet wird, um Arrays zu beschreiben, die optimal mit einem linearen Index indiziert werden.

Ein lineares Indizierungsstil verwendet einen ganzzahligen Index, um die Position im Array zu beschreiben (auch wenn es sich um ein mehrdimensionales Array handelt), und die Spalten-Hauptordnung wird verwendet, um die Elemente effizient zuzugreifen. Das bedeutet, dass die Anforderung von eachindex von einem Array, das IndexLinear ist, einen einfachen eindimensionalen Bereich zurückgibt, auch wenn es mehrdimensional ist.

Ein benutzerdefiniertes Array, das seinen IndexStyle als IndexLinear meldet, muss nur die Indizierung (und die indizierte Zuweisung) mit einem einzelnen Int-Index implementieren; alle anderen Indizierungsanfragen — einschließlich mehrdimensionaler Zugriffe — werden auf den linearen Index neu berechnet. Zum Beispiel, wenn A eine 2×3 benutzerdefinierte Matrix mit linearer Indizierung wäre und wir A[1, 3] referenzieren, würde dies auf den entsprechenden linearen Index neu berechnet und A[5] aufgerufen, da 1 + 2*(3 - 1) = 5.

Siehe auch IndexCartesian.

IndexCartesian()

Untertyp von IndexStyle, der verwendet wird, um Arrays zu beschreiben, die optimal mit einem kartesischen Index indiziert werden. Dies ist der Standard für neue benutzerdefinierte AbstractArray Untertypen.

Ein kartesischer Indizierungsstil verwendet mehrere ganzzahlige Indizes, um die Position in einem mehrdimensionalen Array zu beschreiben, wobei genau ein Index pro Dimension verwendet wird. Das bedeutet, dass die Anforderung von eachindex von einem Array, das IndexCartesian ist, einen Bereich von CartesianIndices zurückgibt.

Ein N-dimensionales benutzerdefiniertes Array, das seinen IndexStyle als IndexCartesian meldet, muss die Indizierung (und indizierte Zuweisung) mit genau N Int-Indizes implementieren; alle anderen Indizierungsanfragen — einschließlich linearer Indizierung — werden auf die entsprechende kartesische Position umgerechnet. Zum Beispiel, wenn A eine 2×3 benutzerdefinierte Matrix mit kartesischer Indizierung wäre und wir A[5] referenzieren, würde dies auf den entsprechenden kartesischen Index umgerechnet und A[1, 3] aufgerufen, da 5 = 1 + 2*(3 - 1).

Es ist erheblich teurer, kartesische Indizes aus einem linearen Index zu berechnen, als umgekehrt. Die erste Operation erfordert eine Division — eine sehr kostspielige Operation — während die letztere nur Multiplikation und Addition verwendet und im Wesentlichen kostenlos ist. Diese Asymmetrie bedeutet, dass es viel kostspieliger ist, die lineare Indizierung mit einem IndexCartesian-Array zu verwenden, als die kartesische Indizierung mit einem IndexLinear-Array zu verwenden.

Siehe auch IndexLinear.

conj!(A)

Transformiere ein Array in seinen komplexen Konjugierten vor Ort.

Siehe auch conj.

Beispiele

julia> A = [1+im 2-im; 2+2im 3+im]
2×2 Matrix{Complex{Int64}}:
 1+1im  2-1im
 2+2im  3+1im

julia> conj!(A);

julia> A
2×2 Matrix{Complex{Int64}}:
 1-1im  2+1im
 2-2im  3-1im

stride(A, k::Integer)

Gibt den Abstand im Speicher (in Anzahl der Elemente) zwischen benachbarten Elementen in der Dimension k zurück.

Siehe auch: strides.

Beispiele

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

Gibt ein Tupel der Speicherstrides in jeder Dimension zurück.

Siehe auch: stride.

Beispiele

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

julia> strides(A)
(1, 3, 12)

broadcast(f, As...)

Übertrage die Funktion f über die Arrays, Tupel, Sammlungen, Refs und/oder Skalare As.

Das Broadcasting wendet die Funktion f auf die Elemente der Container-Argumente und die Skalare selbst in As an. Singleton- und fehlende Dimensionen werden erweitert, um den Ausdehnungen der anderen Argumente zu entsprechen, indem der Wert virtuell wiederholt wird. Standardmäßig werden nur eine begrenzte Anzahl von Typen als Skalare betrachtet, einschließlich Numbers, Strings, Symbols, Types, Functions und einigen gängigen Singletons wie missing und nothing. Alle anderen Argumente werden elementweise durchlaufen oder indiziert.

Der resultierende Containertyp wird durch die folgenden Regeln festgelegt:

• Wenn alle Argumente Skalare oder nulldimensionale Arrays sind, gibt es ein entpacktes Skalar zurück.
• Wenn mindestens ein Argument ein Tupel ist und alle anderen Skalare oder nulldimensionale Arrays sind, gibt es ein Tupel zurück.
• Alle anderen Kombinationen von Argumenten geben standardmäßig ein Array zurück, aber benutzerdefinierte Containertypen können ihre eigene Implementierung und ähnliche Regeln zur Förderung definieren, um das Ergebnis anzupassen, wenn sie als Argumente erscheinen.

Es gibt eine spezielle Syntax für das Broadcasting: f.(args...) ist äquivalent zu broadcast(f, args...), und verschachtelte f.(g.(args...))-Aufrufe werden in eine einzige Broadcast-Schleife zusammengeführt.

Beispiele

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

julia> B = [1 2; 3 4; 5 6; 7 8; 9 10]
5×2 Matrix{Int64}:
 1   2
 3   4
 5   6
 7   8
 9  10

julia> broadcast(+, A, B)
5×2 Matrix{Int64}:
  2   3
  5   6
  8   9
 11  12
 14  15

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

julia> 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"

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

Wie broadcast, aber speichert das Ergebnis von broadcast(f, As...) im dest-Array. Beachten Sie, dass dest nur verwendet wird, um das Ergebnis zu speichern, und keine Argumente an f liefert, es sei denn, es ist auch in den As aufgeführt, wie in broadcast!(f, A, A, B), um A[:] = broadcast(f, A, B) auszuführen.

Beispiele

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

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

julia> B
2-element Vector{Float64}:
  1.0
 -2.0

julia> A
2-element Vector{Float64}:
 1.0
 0.0

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

julia> A
2-element Vector{Float64}:
  1.0
 -2.0

@. expr

Konvertiere jeden Funktionsaufruf oder Operator in expr in einen "Punktaufruf" (z. B. konvertiere f(x) in f.(x)) und konvertiere jede Zuweisung in expr in eine "Punktzuweisung" (z. B. konvertiere += in .+=).

Wenn du vermeiden möchtest, Punkte für ausgewählte Funktionsaufrufe in expr hinzuzufügen, füge diese Funktionsaufrufe mit $ ein. Zum Beispiel ist @. sqrt(abs($sort(x))) äquivalent zu sqrt.(abs.(sort(x))) (kein Punkt für sort).

(@. ist äquivalent zu einem Aufruf von @__dot__.)

Beispiele

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

BroadcastStyle ist ein abstrakter Typ und eine Trait-Funktion, die verwendet wird, um das Verhalten von Objekten unter Broadcasting zu bestimmen. BroadcastStyle(typeof(x)) gibt den Stil zurück, der mit x verbunden ist. Um das Broadcasting-Verhalten eines Typs anzupassen, kann man einen Stil deklarieren, indem man ein Typ-/Methoden-Paar definiert

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

Man schreibt dann Methode(n) (mindestens similar) die auf Broadcasted{MyContainerStyle} operieren. Es gibt auch mehrere vordefinierte Subtypen von BroadcastStyle, die Sie möglicherweise nutzen können; siehe das Interfaces-Kapitel für weitere Informationen.

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle ist der abstrakte Supertyp für jeden Stil, der mit einem AbstractArray-Typ verbunden ist. Der Parameter N ist die Dimensionalität, die nützlich sein kann für AbstractArray-Typen, die nur bestimmte Dimensionalitäten unterstützen:

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

Für AbstractArray-Typen, die beliebige Dimensionalität unterstützen, kann N auf Any gesetzt werden:

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

In Fällen, in denen Sie mehrere AbstractArrayStyles mischen und die Dimensionalität im Auge behalten möchten, muss Ihr Stil einen Val Konstruktor unterstützen:

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

Beachten Sie, dass, wenn zwei oder mehr AbstractArrayStyle-Subtypen in Konflikt stehen, die Broadcast-Mechanik auf die Erzeugung von Arrays zurückgreift. Wenn dies unerwünscht ist, müssen Sie möglicherweise binäre BroadcastStyle Regeln definieren, um den Ausgabetyp zu steuern.

Siehe auch Broadcast.DefaultArrayStyle.

Broadcast.ArrayStyle{MyArrayType}() ist ein BroadcastStyle, das angibt, dass ein Objekt sich wie ein Array für das Broadcasting verhält. Es bietet eine einfache Möglichkeit, Broadcast.AbstractArrayStyles für spezifische AbstractArray-Containertypen zu erstellen. Auf diese Weise erstellte Broadcast-Stile verlieren die Verfolgung der Dimensionalität; wenn die Verfolgung für Ihren Typ wichtig ist, sollten Sie Ihr eigenes benutzerdefiniertes Broadcast.AbstractArrayStyle erstellen.

Broadcast.DefaultArrayStyle{N}() ist ein BroadcastStyle, das angibt, dass ein Objekt sich wie ein N-dimensionales Array für das Broadcasting verhält. Insbesondere wird DefaultArrayStyle für jeden AbstractArray-Typ verwendet, der keinen spezialisierten Stil definiert hat, und in Abwesenheit von Überschreibungen durch andere broadcast-Argumente ist der resultierende Ausgabetyp Array. Wenn es mehrere Eingaben für broadcast gibt, "verliert" DefaultArrayStyle gegen jeden anderen Broadcast.ArrayStyle.

Broadcast.broadcastable(x)

Gibt entweder x oder ein Objekt wie x zurück, sodass es axes, Indizierung unterstützt und sein Typ ndims unterstützt.

Wenn x Iteration unterstützt, sollte der zurückgegebene Wert die gleichen axes und Indizierungsverhalten wie collect(x) haben.

Wenn x kein AbstractArray ist, aber axes, Indizierung unterstützt und sein Typ ndims unterstützt, dann kann broadcastable(::typeof(x)) implementiert werden, um einfach sich selbst zurückzugeben. Darüber hinaus, wenn x seinen eigenen BroadcastStyle definiert, muss es seine broadcastable-Methode definieren, um sich selbst zurückzugeben, damit der benutzerdefinierte Stil irgendeine Wirkung hat.

Beispiele

julia> Broadcast.broadcastable([1,2,3]) # wie `identity`, da Arrays bereits axes und Indizierung unterstützen
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Typen unterstützen keine axes, Indizierung oder Iteration, werden aber häufig als Skalare verwendet
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Strings brechen die Konvention der Übereinstimmung von Iteration und verhalten sich stattdessen wie ein Skalar
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

Bestimmen Sie die Ergebnisachsen für das Broadcasting über alle Werte in As.

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

julia> Broadcast.combine_axes(1, 1, 1)
()

combine_styles(cs...) -> BroadcastStyle

Entscheidet, welchen BroadcastStyle für eine beliebige Anzahl von Wertargumenten verwendet werden soll. Verwendet BroadcastStyle, um den Stil für jedes Argument zu erhalten, und verwendet result_style, um Stile zu kombinieren.

Beispiele

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

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

Nimmt einen oder zwei BroadcastStyles und kombiniert sie mithilfe von BroadcastStyle, um einen gemeinsamen BroadcastStyle zu bestimmen.

Beispiele

julia> Broadcast.result_style(Broadcast.DefaultArrayStyle{0}(), Broadcast.DefaultArrayStyle{3}())
Base.Broadcast.DefaultArrayStyle{3}()

julia> Broadcast.result_style(Broadcast.Unknown(), Broadcast.DefaultArrayStyle{1}())
Base.Broadcast.DefaultArrayStyle{1}()

getindex(A, inds...)

Gibt eine Teilmenge des Arrays A zurück, die durch die Indizes inds ausgewählt wurde.

Jeder Index kann ein unterstützter Indextyp sein, wie z.B. ein Integer, CartesianIndex, Bereich oder Array von unterstützten Indizes. Ein : kann verwendet werden, um alle Elemente entlang einer bestimmten Dimension auszuwählen, und ein boolesches Array (z.B. ein Array{Bool} oder ein BitArray) kann verwendet werden, um Elemente zu filtern, bei denen der entsprechende Index true ist.

Wenn inds mehrere Elemente auswählt, gibt diese Funktion ein neu zugewiesenes Array zurück. Um mehrere Elemente zu indizieren, ohne eine Kopie zu erstellen, verwenden Sie stattdessen view.

Siehe den Abschnitt im Handbuch über Array-Indizierung für weitere Details.

Beispiele

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> getindex(A, 1)
1

julia> getindex(A, [2, 1])
2-element Vector{Int64}:
 3
 1

julia> getindex(A, 2:4)
3-element Vector{Int64}:
 3
 2
 4

julia> getindex(A, 2, 1)
3

julia> getindex(A, CartesianIndex(2, 1))
3

julia> getindex(A, :, 2)
2-element Vector{Int64}:
 2
 4

julia> getindex(A, 2, :)
2-element Vector{Int64}:
 3
 4

julia> getindex(A, A .> 2)
2-element Vector{Int64}:
 3
 4

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

Speichern Sie Werte aus dem Array X innerhalb einer Teilmenge von A, wie durch inds angegeben. Die Syntax A[inds...] = X ist äquivalent zu (setindex!(A, X, inds...); X).

Beispiele

julia> A = zeros(2,2);

julia> setindex!(A, [10, 20], [1, 2]);

julia> A[[3, 4]] = [30, 40];

julia> A
2×2 Matrix{Float64}:
 10.0  30.0
 20.0  40.0

nextind(A, i)

Gibt den Index nach i in A zurück. Der zurückgegebene Index entspricht oft i + 1 für ein ganzzahliges i. Diese Funktion kann für generischen Code nützlich sein.

Siehe auch: prevind.

Beispiele

julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> nextind(x, 1) # gültiges Ergebnis
2

julia> nextind(x, 4) # ungültiges Ergebnis
5

julia> nextind(x, CartesianIndex(1, 1)) # gültiges Ergebnis
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # ungültiges Ergebnis
CartesianIndex(1, 3)

prevind(A, i)

Gibt den Index vor i in A zurück. Der zurückgegebene Index entspricht oft i - 1 für ein ganzzahliges i. Diese Funktion kann für generischen Code nützlich sein.

Siehe auch: nextind.

Beispiele

julia> x = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> prevind(x, 4) # gültiges Ergebnis
3

julia> prevind(x, 1) # ungültiges Ergebnis
0

julia> prevind(x, CartesianIndex(2, 2)) # gültiges Ergebnis
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # ungültiges Ergebnis
CartesianIndex(2, 0)

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

Kopiere den Block von src im Bereich von Rsrc in den Block von dest im Bereich von Rdest. Die Größen der beiden Regionen müssen übereinstimmen.

Beispiele

julia> A = zeros(5, 5);

julia> B = [1 2; 3 4];

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0

copy!(dst, src) -> dst

In-place copy von src nach dst, wobei alle vorhandenen Elemente in dst verworfen werden. Wenn dst und src vom gleichen Typ sind, sollte nach dem Aufruf dst == src gelten. Wenn dst und src mehrdimensionale Arrays sind, müssen sie gleiche axes haben.

Siehe auch copyto!.

isassigned(array, i) -> Bool

Überprüfen Sie, ob das gegebene Array einen Wert mit dem Index i hat. Gibt false zurück, wenn der Index außerhalb der Grenzen liegt oder eine undefinierte Referenz hat.

Beispiele

julia> isassigned(rand(3, 3), 5)
true

julia> isassigned(rand(3, 3), 3 * 3 + 1)
false

julia> mutable struct Foo end

julia> v = similar(rand(3), Foo)
3-element Vector{Foo}:
 #undef
 #undef
 #undef

julia> isassigned(v, 1)
false

Colon()

Doppelpunkt (:) werden verwendet, um das Indizieren ganzer Objekte oder Dimensionen auf einmal zu kennzeichnen.

Sehr wenige Operationen sind direkt auf Doppelpunkt definiert; stattdessen werden sie durch to_indices in einen internen Vektortyp (Base.Slice) umgewandelt, um die Sammlung von Indizes darzustellen, die sie abdecken, bevor sie verwendet werden.

Die Singleton-Instanz von Colon ist auch eine Funktion, die verwendet wird, um Bereiche zu konstruieren; siehe :.

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

Erstellen Sie einen mehrdimensionalen Index I, der zum Indizieren eines mehrdimensionalen Arrays A verwendet werden kann. Insbesondere ist A[I] äquivalent zu A[i,j,k...]. Man kann ganzzahlige und CartesianIndex-Indizes frei mischen; zum Beispiel kann A[Ipre, i, Ipost] (wobei Ipre und Ipost CartesianIndex-Indizes und i ein Int ist) ein nützliches Ausdruck sein, wenn man Algorithmen schreibt, die entlang einer einzelnen Dimension eines Arrays beliebiger Dimensionalität arbeiten.

Ein CartesianIndex wird manchmal von eachindex erzeugt und immer, wenn man mit expliziten CartesianIndices iteriert.

Ein I::CartesianIndex wird als "Skalar" (nicht als Container) für broadcast behandelt. Um über die Komponenten eines CartesianIndex zu iterieren, konvertieren Sie ihn mit Tuple(I) in ein Tupel.

Beispiele

julia> A = reshape(Vector(1:16), (2, 2, 2, 2))
2×2×2×2 Array{Int64, 4}:
[:, :, 1, 1] =
 1  3
 2  4

[:, :, 2, 1] =
 5  7
 6  8

[:, :, 1, 2] =
  9  11
 10  12

[:, :, 2, 2] =
 13  15
 14  16

julia> A[CartesianIndex((1, 1, 1, 1))]
1

julia> A[CartesianIndex((1, 1, 1, 2))]
9

julia> A[CartesianIndex((1, 1, 2, 1))]
5

CartesianIndices(sz::Dims) -> R
CartesianIndices((istart:[istep:]istop, jstart:[jstep:]jstop, ...)) -> R

Definieren Sie einen Bereich R, der einen mehrdimensionalen rechteckigen Bereich von ganzzahligen Indizes umfasst. Diese werden am häufigsten im Kontext der Iteration verwendet, wo for I in R ... end CartesianIndex Indizes I zurückgibt, die den geschachtelten Schleifen entsprechen

for j = jstart:jstep:jstop
    for i = istart:istep:istop
        ...
    end
end

Folglich können diese nützlich sein, um Algorithmen zu schreiben, die in beliebigen Dimensionen arbeiten.

CartesianIndices(A::AbstractArray) -> R

Zur Vereinfachung erstellt die Konstruktion eines CartesianIndices aus einem Array einen Bereich seiner Indizes.

Beispiele

julia> foreach(println, CartesianIndices((2, 2, 2)))
CartesianIndex(1, 1, 1)
CartesianIndex(2, 1, 1)
CartesianIndex(1, 2, 1)
CartesianIndex(2, 2, 1)
CartesianIndex(1, 1, 2)
CartesianIndex(2, 1, 2)
CartesianIndex(1, 2, 2)
CartesianIndex(2, 2, 2)

julia> CartesianIndices(fill(1, (2,3)))
CartesianIndices((2, 3))

Umwandlung zwischen linearen und kartesischen Indizes

Die Umwandlung von linearen Indizes in kartesische Indizes nutzt die Tatsache aus, dass ein CartesianIndices ein AbstractArray ist und linear indiziert werden kann:

julia> cartesian = CartesianIndices((1:3, 1:2))
CartesianIndices((1:3, 1:2))

julia> cartesian[4]
CartesianIndex(1, 2)

julia> cartesian = CartesianIndices((1:2:5, 1:2))
CartesianIndices((1:2:5, 1:2))

julia> cartesian[2, 2]
CartesianIndex(3, 2)

Broadcasting

CartesianIndices unterstützen die Broadcasting-Arithmetik (+ und -) mit einem CartesianIndex.

julia> CIs = CartesianIndices((2:3, 5:6))
CartesianIndices((2:3, 5:6))

julia> CI = CartesianIndex(3, 4)
CartesianIndex(3, 4)

julia> CIs .+ CI
CartesianIndices((5:6, 9:10))

Für die Umwandlung von kartesischen zu linearen Indizes siehe LinearIndices. ```

Dims{N}

Ein NTuple von N Ints, das verwendet wird, um die Dimensionen eines AbstractArray darzustellen.

LinearIndices(A::AbstractArray)

Gibt ein LinearIndices-Array mit derselben Form und axes wie A zurück, das den linearen Index jedes Eintrags in A enthält. Das Indizieren dieses Arrays mit kartesischen Indizes ermöglicht die Zuordnung zu linearen Indizes.

Für Arrays mit konventioneller Indizierung (Indizes beginnen bei 1) oder für beliebige mehrdimensionale Arrays reichen die linearen Indizes von 1 bis length(A). Für AbstractVectors sind die linearen Indizes jedoch axes(A, 1), und beginnen daher nicht bei 1 für Vektoren mit unkonventioneller Indizierung.

Diese Funktion aufzurufen ist der "sichere" Weg, um Algorithmen zu schreiben, die lineare Indizierung nutzen.

Beispiele

julia> A = fill(1, (5,6,7));

julia> b = LinearIndices(A);

julia> extrema(b)
(1, 210)

LinearIndices(inds::CartesianIndices) -> R
LinearIndices(sz::Dims) -> R
LinearIndices((istart:istop, jstart:jstop, ...)) -> R

Gibt ein LinearIndices-Array mit der angegebenen Form oder axes zurück.

Beispiele

Der Hauptzweck dieses Konstruktors ist die intuitive Umwandlung von kartesischer in lineare Indizierung:

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

julia> linear[1,2]
4

to_indices(A, I::Tuple)

Konvertiere das Tupel I in ein Tupel von Indizes zur Verwendung beim Indizieren des Arrays A.

Das zurückgegebene Tupel darf nur Ints oder AbstractArrays von Skalarindizes enthalten, die von Array A unterstützt werden. Es wird einen Fehler auslösen, wenn es auf einen neuartigen Indextyp stößt, den es nicht verarbeiten kann.

Für einfache Indextypen wird auf die nicht exportierte Funktion Base.to_index(A, i) verwiesen, um jeden Index i zu verarbeiten. Während diese interne Funktion nicht direkt aufgerufen werden soll, kann Base.to_index von benutzerdefinierten Array- oder Indextypen erweitert werden, um benutzerdefinierte Indizierungsverhalten bereitzustellen.

Kompliziertere Indextypen benötigen möglicherweise mehr Kontext über die Dimension, in die sie indizieren. Um diese Fälle zu unterstützen, ruft to_indices(A, I) to_indices(A, axes(A), I) auf, das dann rekursiv sowohl durch das gegebene Tupel von Indizes als auch durch die dimensionalen Indizes von A in Tandem geht. Daher ist nicht garantiert, dass alle Indextypen zu Base.to_index weitergeleitet werden.

Beispiele

julia> A = zeros(1,2,3,4);

julia> to_indices(A, (1,1,2,2))
(1, 1, 2, 2)

julia> to_indices(A, (1,1,2,20)) # keine Grenzüberprüfung
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # exotischer Index
(1, 2, 3, 4)

julia> to_indices(A, ([1,1], 1:2, 3, 4))
([1, 1], 1:2, 3, 4)

julia> to_indices(A, (1,2)) # keine Formüberprüfung
(1, 2)

checkbounds(Bool, A, I...)

Gibt true zurück, wenn die angegebenen Indizes I im Bereich für das gegebene Array A liegen. Subtypen von AbstractArray sollten diese Methode spezialisieren, wenn sie benutzerdefinierte Überprüfungsverhalten für Grenzen bereitstellen müssen; jedoch kann man in vielen Fällen auf die Indizes von A und checkindex vertrauen.

Siehe auch checkindex.

Beispiele

julia> A = rand(3, 3);

julia> checkbounds(Bool, A, 2)
true

julia> checkbounds(Bool, A, 3, 4)
false

julia> checkbounds(Bool, A, 1:3)
true

julia> checkbounds(Bool, A, 1:3, 2:4)
false

checkbounds(A, I...)

Wirft einen Fehler, wenn die angegebenen Indizes I nicht im Bereich des gegebenen Arrays A liegen.

checkindex(Bool, inds::AbstractUnitRange, index)

Gibt true zurück, wenn der angegebene index innerhalb der Grenzen von inds liegt. Benutzerdefinierte Typen, die sich wie Indizes für alle Arrays verhalten möchten, können diese Methode erweitern, um eine spezialisierte Implementierung der Bereichsüberprüfung bereitzustellen.

Siehe auch checkbounds.

Beispiele

julia> checkindex(Bool, 1:20, 8)
true

julia> checkindex(Bool, 1:20, 21)
false

elsize(type)

Berechne den Speicherabstand in Bytes zwischen aufeinanderfolgenden Elementen des eltype, die im angegebenen type gespeichert sind, wenn die Array-Elemente dicht mit einem einheitlichen linearen Abstand gespeichert sind.

Beispiele

julia> Base.elsize(rand(Float32, 10))
4

view(A, inds...)

Wie getindex, aber gibt ein leichtgewichtiges Array zurück, das faul auf das übergeordnete Array A an dem gegebenen Index oder den Indizes inds verweist (oder effektiv eine Ansicht darauf ist), anstatt Elemente sofort zu extrahieren oder eine kopierte Teilmenge zu erstellen. Der Aufruf von getindex oder setindex! auf dem zurückgegebenen Wert (oft ein SubArray) berechnet die Indizes, um das übergeordnete Array im laufenden Betrieb zuzugreifen oder zu ändern. Das Verhalten ist undefiniert, wenn die Form des übergeordneten Arrays nach dem Aufruf von view geändert wird, da es keine Grenzkontrolle für das übergeordnete Array gibt; z. B. kann es zu einem Segmentierungsfehler führen.

Einige unveränderliche übergeordnete Arrays (wie Bereiche) können in einigen Fällen einfach ein neues Array neu berechnen, anstatt ein SubArray zurückzugeben, wenn dies effizient ist und kompatible Semantiken bietet.

Beispiele

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> b = view(A, :, 1)
2-element view(::Matrix{Int64}, :, 1) mit eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) mit eltype Int64:
 0
 0

julia> A # Beachte, A hat sich geändert, obwohl wir b modifiziert haben
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # gibt einen Bereich zurück, da der Typ unveränderlich ist
3:4

@view A[inds...]

Transformiere den Indizierungs-Ausdruck A[inds...] in den entsprechenden view Aufruf.

Dies kann nur direkt auf einen einzelnen Indizierungs-Ausdruck angewendet werden und ist besonders hilfreich für Ausdrücke, die die speziellen Indizierungssyntaxen begin oder end wie A[begin, 2:end-1] enthalten (da diese von der normalen view Funktion nicht unterstützt werden).

Beachte, dass @view nicht als Ziel einer regulären Zuweisung verwendet werden kann (z. B. @view(A[1, 2:end]) = ...), noch würde die un-dekorierte indizierte Zuweisung (A[1, 2:end] = ...) oder die broadcastete indizierte Zuweisung (A[1, 2:end] .= ...) eine Kopie erstellen. Es kann jedoch nützlich sein, um aktualisierte broadcastete Zuweisungen wie @view(A[1, 2:end]) .+= 1 zu verwenden, da dies eine einfache Syntax für @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1 ist, und der Indizierungs-Ausdruck auf der rechten Seite würde ansonsten ohne das @view eine Kopie erstellen.

Siehe auch @views, um einen gesamten Block von Code auf die Verwendung von Views für nicht-skalare Indizierung umzustellen.

Beispiele

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> b = @view A[:, 1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

julia> fill!(b, 0)
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 0
 0

julia> A
2×2 Matrix{Int64}:
 0  2
 0  4

@views Ausdruck

Konvertiere jede Array-Slicing-Operation im gegebenen Ausdruck (der ein begin/end-Block, eine Schleife, eine Funktion usw. sein kann) so, dass eine Ansicht zurückgegeben wird. Skalare Indizes, Nicht-Array-Typen und explizite getindex-Aufrufe (im Gegensatz zu array[...]) sind nicht betroffen.

Ähnlich konvertiert @views String-Slices in SubString-Ansichten.

!!! Hinweis Das @views-Makro betrifft nur array[...]-Ausdrücke, die explizit im gegebenen Ausdruck erscheinen, nicht das Array-Slicing, das in von diesem Code aufgerufenen Funktionen auftritt.

!!! Kompatibilität "Julia 1.5" Die Verwendung von begin in einem Indexausdruck, um auf den ersten Index zu verweisen, wurde in Julia 1.4 implementiert, wurde jedoch erst ab Julia 1.5 von @views unterstützt.

Beispiele

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b ist eine Ansicht, kein Kopie
           b .= row      # weise jedem Element den Zeilenindex zu
       end

julia> A
3×3 Matrix{Float64}:
 1.0  1.0  1.0
 2.0  2.0  2.0
 3.0  3.0  3.0

parent(A)

Gibt das zugrunde liegende Elternobjekt der Ansicht zurück. Dieses Elternobjekt von Typen SubArray, SubString, ReshapedArray oder LinearAlgebra.Transpose ist das, was als Argument an view, reshape, transpose usw. während der Objekterstellung übergeben wurde. Wenn die Eingabe kein gewickeltes Objekt ist, wird die Eingabe selbst zurückgegeben. Wenn die Eingabe mehrfach gewickelt ist, wird nur der äußerste Wrapper entfernt.

Beispiele

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> V = view(A, 1:2, :)
2×2 view(::Matrix{Int64}, 1:2, :) mit eltype Int64:
 1  2
 3  4

julia> parent(V)
2×2 Matrix{Int64}:
 1  2
 3  4

parentindices(A)

Gibt die Indizes im parent zurück, die der Ansicht A entsprechen.

Beispiele

julia> A = [1 2; 3 4];

julia> V = view(A, 1, :)
2-element view(::Matrix{Int64}, 1, :) mit eltype Int64:
 1
 2

julia> parentindices(V)
(1, Base.Slice(Base.OneTo(2)))

selectdim(A, d::Integer, i)

Gibt eine Ansicht aller Daten von A zurück, bei denen der Index für die Dimension d gleich i ist.

Entspricht view(A,:,:,...,i,:,:,...), wobei i an der Position d steht.

Siehe auch: eachslice.

Beispiele

julia> A = [1 2 3 4; 5 6 7 8]
2×4 Matrix{Int64}:
 1  2  3  4
 5  6  7  8

julia> selectdim(A, 2, 3)
2-element view(::Matrix{Int64}, :, 3) with eltype Int64:
 3
 7

julia> selectdim(A, 2, 3:4)
2×2 view(::Matrix{Int64}, :, 3:4) with eltype Int64:
 3  4
 7  8

reinterpret(::Type{Out}, x::In)

Ändert die Typinterpretation der Binärdaten im isbits-Wert x in die des isbits-Typs Out. Die Größe (ohne Padding) von Out muss die gleiche sein wie die des Typs von x. Zum Beispiel interpretiert reinterpret(Float32, UInt32(7)) die 4 Bytes, die UInt32(7) entsprechen, als Float32. Beachten Sie, dass reinterpret(In, reinterpret(Out, x)) === x

julia> reinterpret(Float32, UInt32(7))
1.0f-44

julia> reinterpret(NTuple{2, UInt8}, 0x1234)
(0x34, 0x12)

julia> reinterpret(UInt16, (0x34, 0x12))
0x1234

julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
(0x0301, 0x02)

reinterpret(T::DataType, A::AbstractArray)

Konstruiere eine Ansicht des Arrays mit denselben binären Daten wie das gegebene Array, jedoch mit T als Elementtyp.

Diese Funktion funktioniert auch bei "faulen" Arrays, deren Elemente nicht berechnet werden, bis sie explizit abgerufen werden. Zum Beispiel funktioniert reinterpret auf dem Bereich 1:6 ähnlich wie auf dem dichten Vektor collect(1:6):

julia> reinterpret(Float32, UInt32[1 2 3 4 5])
1×5 reinterpret(Float32, ::Matrix{UInt32}):
 1.0f-45  3.0f-45  4.0f-45  6.0f-45  7.0f-45

julia> reinterpret(Complex{Int}, 1:6)
3-element reinterpret(Complex{Int64}, ::UnitRange{Int64}):
 1 + 2im
 3 + 4im
 5 + 6im

Wenn die Position der Padding-Bits zwischen T und eltype(A) nicht übereinstimmt, wird das resultierende Array schreibgeschützt oder leseschreibgeschützt sein, um zu verhindern, dass ungültige Bits geschrieben oder gelesen werden.

julia> a = reinterpret(Tuple{UInt8, UInt32}, UInt32[1, 2])
1-element reinterpret(Tuple{UInt8, UInt32}, ::Vector{UInt32}):
 (0x01, 0x00000002)

julia> a[1] = 3
ERROR: Padding des Typs Tuple{UInt8, UInt32} ist nicht kompatibel mit dem Typ UInt32.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # anzeigen wird einen Fehler verursachen

julia> b[1]
ERROR: Padding des Typs UInt32 ist nicht kompatibel mit dem Typ Tuple{UInt8, UInt32}.

reinterpret(reshape, T, A::AbstractArray{S}) -> B

Ändert die Typinterpretation von A, während eine "Kanaldimension" hinzugefügt oder konsumiert wird.

Wenn sizeof(T) = n*sizeof(S) für n>1, muss die erste Dimension von A die Größe n haben und B fehlt die erste Dimension von A. Umgekehrt, wenn sizeof(S) = n*sizeof(T) für n>1, erhält B eine neue erste Dimension der Größe n. Die Dimensionalität bleibt unverändert, wenn sizeof(T) == sizeof(S).

Beispiele

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> reinterpret(reshape, Complex{Int}, A)    # das Ergebnis ist ein Vektor
2-element reinterpret(reshape, Complex{Int64}, ::Matrix{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

julia> a = [(1,2,3), (4,5,6)]
2-element Vector{Tuple{Int64, Int64, Int64}}:
 (1, 2, 3)
 (4, 5, 6)

julia> reinterpret(reshape, Int, a)             # das Ergebnis ist eine Matrix
3×2 reinterpret(reshape, Int64, ::Vector{Tuple{Int64, Int64, Int64}}) with eltype Int64:
 1  4
 2  5
 3  6

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

Gibt ein Array mit denselben Daten wie A zurück, jedoch mit unterschiedlichen Dimensionen oder Anzahl der Dimensionen. Die beiden Arrays teilen sich die gleichen zugrunde liegenden Daten, sodass das Ergebnis veränderbar ist, wenn und nur wenn A veränderbar ist, und das Setzen von Elementen eines Arrays die Werte des anderen ändert.

Die neuen Dimensionen können entweder als Liste von Argumenten oder als Form-Tuple angegeben werden. Höchstens eine Dimension darf mit einem : angegeben werden, in diesem Fall wird ihre Länge so berechnet, dass ihr Produkt mit allen angegebenen Dimensionen gleich der Länge des ursprünglichen Arrays A ist. Die Gesamtanzahl der Elemente darf sich nicht ändern.

Beispiele

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

julia> reshape(A, (4, 4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reshape(A, 2, :)
2×8 Matrix{Int64}:
 1  3  5  7   9  11  13  15
 2  4  6  8  10  12  14  16

julia> reshape(1:6, 2, 3)
2×3 reshape(::UnitRange{Int64}, 2, 3) with eltype Int64:
 1  3  5
 2  4  6

dropdims(A; dims)

Gibt ein Array mit denselben Daten wie A zurück, jedoch mit den durch dims angegebenen Dimensionen entfernt. size(A,d) muss für jedes d in dims gleich 1 sein, und wiederholte Dimensionen oder Zahlen außerhalb von 1:ndims(A) sind verboten.

Das Ergebnis teilt sich die gleichen zugrunde liegenden Daten wie A, sodass das Ergebnis veränderlich ist, wenn und nur wenn A veränderlich ist, und das Setzen von Elementen eines das Werte des anderen verändert.

Siehe auch: reshape, vec.

Beispiele

julia> a = reshape(Vector(1:4),(2,2,1,1))
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 1  3
 2  4

julia> b = dropdims(a; dims=3)
2×2×1 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

julia> b[1,1,1] = 5; a
2×2×1×1 Array{Int64, 4}:
[:, :, 1, 1] =
 5  3
 2  4

vec(a::AbstractArray) -> AbstractVector

Formatiere das Array a als eindimensionalen Spaltenvektor. Gib a zurück, wenn es bereits ein AbstractVector ist. Das resultierende Array teilt sich die gleichen zugrunde liegenden Daten wie a, sodass es nur veränderbar ist, wenn a veränderbar ist, in welchem Fall die Modifikation des einen auch den anderen modifiziert.

Beispiele

julia> a = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> vec(a)
6-element Vector{Int64}:
 1
 4
 2
 5
 3
 6

julia> vec(1:3)
1:3

Siehe auch reshape, dropdims.

SubArray{T,N,P,I,L} <: AbstractArray{T,N}

N-dimensionale Ansicht in ein übergeordnetes Array (vom Typ P) mit einem Elementtyp T, eingeschränkt durch ein Tupel von Indizes (vom Typ I). L ist wahr für Typen, die schnelles lineares Indizieren unterstützen, und falsch andernfalls.

Konstruiere SubArrays mit der view Funktion.

cat(A...; dims)

Verkettet die Eingabearrays entlang der in dims angegebenen Dimensionen.

Entlang einer Dimension d in dims ist die Größe des Ausgabearrays sum(size(a,d) for a in A). In anderen Dimensionen sollten alle Eingabearrays die gleiche Größe haben, die auch die Größe des Ausgabearrays in diesen Dimensionen sein wird.

Wenn dims eine einzelne Zahl ist, werden die verschiedenen Arrays entlang dieser Dimension eng gepackt. Wenn dims eine iterable Struktur ist, die mehrere Dimensionen enthält, werden die Positionen entlang dieser Dimensionen gleichzeitig für jedes Eingabearray erhöht, wobei an anderen Stellen mit Null aufgefüllt wird. Dies ermöglicht es, block-diagonale Matrizen zu konstruieren, wie cat(matrices...; dims=(1,2)), und deren höherdimensionale Analogien.

Der Sonderfall dims=1 ist vcat, und dims=2 ist hcat. Siehe auch hvcat, hvncat, stack, repeat.

Das Schlüsselwort akzeptiert auch Val(dims).

Beispiele

Verkette zwei Arrays in verschiedenen Dimensionen:

julia> a = [1 2 3]
1×3 Matrix{Int64}:
 1  2  3

julia> b = [4 5 6]
1×3 Matrix{Int64}:
 4  5  6

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

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

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

Erweiterte Hilfe

Verkette 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

Verkette Arrays unterschiedlicher Größen:

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # dasselbe wie hcat
2×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

Konstruiere eine block-diagonale Matrix:

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # block-diagonal
4×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

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"

vcat(A...)

Verkettet Arrays oder Zahlen vertikal. Entspricht zu cat(A...; dims=1), und zur Syntax [a; b; c].

Um einen großen Vektor von Arrays zu verketten, ruft reduce(vcat, A) eine effiziente Methode auf, wenn A isa AbstractVector{<:AbstractVecOrMat} ist, anstatt paarweise zu arbeiten.

Siehe auch hcat, Iterators.flatten, stack.

Beispiele

julia> v = vcat([1,2], [3,4])
4-element Vector{Int64}:
 1
 2
 3
 4

julia> v == vcat(1, 2, [3,4])  # akzeptiert Zahlen
true

julia> v == [1; 2; [3,4]]  # Syntax für die gleiche Operation
true

julia> summary(ComplexF64[1; 2; [3,4]])  # Syntax zur Angabe des Elementtyps
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # sammelt faule Bereiche
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # Zeilenvektor und eine Matrix
([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.0

julia> vs = [[1, 2], [3, 4], [5, 6]];

julia> reduce(vcat, vs)  # effizienter als vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> ans == collect(Iterators.flatten(vs))
true

hcat(A...)

Verkettet Arrays oder Zahlen horizontal. Entspricht cat(A...; dims=2), und zur Syntax [a b c] oder [a;; b;; c].

Für einen großen Vektor von Arrays ruft reduce(hcat, A) eine effiziente Methode auf, wenn A isa AbstractVector{<:AbstractVecOrMat}. Für einen Vektor von Vektoren kann dies auch als stack(A) geschrieben werden.

Siehe auch vcat, hvcat.

Beispiele

julia> hcat([1,2], [3,4], [5,6])
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

julia> hcat(1, 2, [30 40], [5, 6, 7]')  # akzeptiert Zahlen
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # Syntax für die gleiche Operation
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # Syntax zur Angabe des eltype
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

julia> ms = [zeros(2,2), [1 2; 3 4], [50 60; 70 80]];

julia> reduce(hcat, ms)  # effizienter als hcat(ms...)
2×6 Matrix{Float64}:
 0.0  0.0  1.0  2.0  50.0  60.0
 0.0  0.0  3.0  4.0  70.0  80.0

julia> stack(ms) |> summary  # stimmt nicht überein bei einem Vektor von Matrizen
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # leere Vektoren, jeweils der Größe (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat mit leerer 2×0 Matrix
2×1 Matrix{Any}:
 1.1
 9.9

hvcat(blocks_per_row::Union{Tuple{Vararg{Int}}, Int}, values...)

Horizontale und vertikale Verkettung in einem Aufruf. Diese Funktion wird für die Blockmatrix-Syntax aufgerufen. Das erste Argument gibt die Anzahl der Argumente an, die in jeder Blockreihe verkettet werden sollen. Wenn das erste Argument eine einzelne Ganzzahl n ist, wird angenommen, dass alle Blockreihen n Blockspalten haben.

Beispiele

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c; d e f]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> hvcat((3,3), a,b,c,d,e,f)
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> [a b; c d; e f]
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6

julia> hvcat((2,2,2), a,b,c,d,e,f)
3×2 Matrix{Int64}:
 1  2
 3  4
 5  6
julia> hvcat((2,2,2), a,b,c,d,e,f) == hvcat(2, a,b,c,d,e,f)
true

hvncat(dim::Int, row_first, values...)
hvncat(dims::Tuple{Vararg{Int}}, row_first, values...)
hvncat(shape::Tuple{Vararg{Tuple}}, row_first, values...)

Horizontale, vertikale und n-dimensionale Verkettung vieler values in einem Aufruf.

Diese Funktion wird für die Blockmatrix-Syntax aufgerufen. Das erste Argument gibt entweder die Form der Verkettung an, ähnlich wie hvcat, als ein Tupel von Tupeln, oder die Dimensionen, die die Schlüsselanzahl der Elemente entlang jeder Achse angeben, und wird verwendet, um die Ausgabedimensionen zu bestimmen. Die dims-Form ist leistungsfähiger und wird standardmäßig verwendet, wenn die Verkettungsoperation die gleiche Anzahl von Elementen entlang jeder Achse hat (z. B. [a b; c d;;; e f ; g h]). Die shape-Form wird verwendet, wenn die Anzahl der Elemente entlang jeder Achse unausgewogen ist (z. B. [a b ; c]). Unaustarierte Syntax benötigt zusätzlichen Validierungsaufwand. Die dim-Form ist eine Optimierung für die Verkettung entlang nur einer Dimension. row_first gibt an, wie values angeordnet sind. Die Bedeutung der ersten und zweiten Elemente von shape wird ebenfalls basierend auf row_first vertauscht.

Beispiele

julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
(1, 2, 3, 4, 5, 6)

julia> [a b c;;; d e f]
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

julia> hvncat((2,1,3), false, a,b,c,d,e,f)
2×1×3 Array{Int64, 3}:
[:, :, 1] =
 1
 2

[:, :, 2] =
 3
 4

[:, :, 3] =
 5
 6

julia> [a b;;; c d;;; e f]
1×2×3 Array{Int64, 3}:
[:, :, 1] =
 1  2

[:, :, 2] =
 3  4

[:, :, 3] =
 5  6

julia> hvncat(((3, 3), (3, 3), (6,)), true, a, b, c, d, e, f)
1×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  2  3

[:, :, 2] =
 4  5  6

Beispiele zur Konstruktion der Argumente

[a b c ; d e f ;;;
 g h i ; j k l ;;;
 m n o ; p q r ;;;
 s t u ; v w x]
⇒ dims = (2, 3, 4)

[a b ; c ;;; d ;;;;]
 ___   _     _
 2     1     1 = Elemente in jeder Zeile (2, 1, 1)
 _______     _
 3           1 = Elemente in jeder Spalte (3, 1)
 _____________
 4             = Elemente in jedem 3D-Slice (4,)
 _____________
 4             = Elemente in jedem 4D-Slice (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) mit `row_first` = true

stack(iter; [dims])

Kombiniert eine Sammlung von Arrays (oder anderen iterierbaren Objekten) gleicher Größe zu einem größeren Array, indem sie entlang einer oder mehrerer neuer Dimensionen angeordnet werden.

Standardmäßig werden die Achsen der Elemente zuerst platziert, was size(result) = (size(first(iter))..., size(iter)...) ergibt. Dies hat die gleiche Reihenfolge der Elemente wie Iterators.flatten(iter).

Mit dem Schlüsselwort dims::Integer wird stattdessen das i-te Element von iter zur Scheibe selectdim(result, dims, i), sodass size(result, dims) == length(iter) gilt. In diesem Fall kehrt stack die Aktion von eachslice mit denselben dims um.

Die verschiedenen cat Funktionen kombinieren ebenfalls Arrays. Diese erweitern jedoch alle die bestehenden (möglicherweise trivialen) Dimensionen der Arrays, anstatt die Arrays entlang neuer Dimensionen zu platzieren. Sie akzeptieren auch Arrays als separate Argumente, anstatt als eine einzige Sammlung.

Beispiele

julia> vecs = (1:2, [30, 40], Float32[500, 600]);

julia> mat = stack(vecs)
2×3 Matrix{Float32}:
 1.0  30.0  500.0
 2.0  40.0  600.0

julia> mat == hcat(vecs...) == reduce(hcat, collect(vecs))
true

julia> vec(mat) == vcat(vecs...) == reduce(vcat, collect(vecs))
true

julia> stack(zip(1:4, 10:99))  # akzeptiert beliebige Iteratoren von Iteratoren
2×4 Matrix{Int64}:
  1   2   3   4
 10  11  12  13

julia> vec(ans) == collect(Iterators.flatten(zip(1:4, 10:99)))
true

julia> stack(vecs; dims=1)  # im Gegensatz zu jeder cat-Funktion ist die 1. Achse von vecs[1] die 2. Achse des Ergebnisses
3×2 Matrix{Float32}:
   1.0    2.0
  30.0   40.0
 500.0  600.0

julia> x = rand(3,4);

julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # Umkehrung von eachslice
true

Höherdimensionale Beispiele:

julia> A = rand(5, 7, 11);

julia> E = eachslice(A, dims=2);  # ein Vektor von Matrizen

julia> (element = size(first(E)), container = size(E))
(element = (5, 11), container = (7,))

julia> stack(E) |> size
(5, 11, 7)

julia> stack(E) == stack(E; dims=3) == cat(E...; dims=3)
true

julia> A == stack(E; dims=2)
true

julia> M = (fill(10i+j, 2, 3) for i in 1:5, j in 1:7);

julia> (element = size(first(M)), container = size(M))
(element = (2, 3), container = (5, 7))

julia> stack(M) |> size  # behält alle Dimensionen
(2, 3, 5, 7)

julia> stack(M; dims=1) |> size  # vec(container) entlang dims=1
(35, 2, 3)

julia> hvcat(5, M...) |> size  # hvcat platziert Matrizen nebeneinander
(14, 15)

stack(f, args...; [dims])

Wenden Sie eine Funktion auf jedes Element einer Sammlung an und stack das Ergebnis. Oder auf mehrere Sammlungen, die zipped zusammen.

Die Funktion sollte Arrays (oder Tupel oder andere Iteratoren) zurückgeben, die alle die gleiche Größe haben. Diese werden zu Schnitten des Ergebnisses, die entlang von dims (sofern angegeben) oder standardmäßig entlang der letzten Dimensionen getrennt sind.

Siehe auch mapslices, eachcol.

Beispiele

julia> stack(c -> (c, c-32), "julia")
2×5 Matrix{Char}:
 'j'  'u'  'l'  'i'  'a'
 'J'  'U'  'L'  'I'  'A'

julia> stack(eachrow([1 2 3; 4 5 6]), (10, 100); dims=1) do row, n
         vcat(row, row .* n, row ./ n)
       end
2×9 Matrix{Float64}:
 1.0  2.0  3.0   10.0   20.0   30.0  0.1   0.2   0.3
 4.0  5.0  6.0  400.0  500.0  600.0  0.04  0.05  0.06

vect(X...)

Erstellt einen Vector mit einem Elementtyp, der aus dem promote_typeof des Arguments berechnet wird, und enthält die Argumentliste.

Beispiele

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

circshift(A, shifts)

Zirkulär verschieben, d.h. die Daten in einem Array rotieren. Das zweite Argument ist ein Tupel oder Vektor, der die Menge angibt, um die in jeder Dimension verschoben werden soll, oder eine ganze Zahl, um nur in der ersten Dimension zu verschieben.

Siehe auch: circshift!, circcopy!, bitrotate, <<.

Beispiele

julia> b = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> circshift(b, (0,2))
4×4 Matrix{Int64}:
  9  13  1  5
 10  14  2  6
 11  15  3  7
 12  16  4  8

julia> circshift(b, (-1,0))
4×4 Matrix{Int64}:
 2  6  10  14
 3  7  11  15
 4  8  12  16
 1  5   9  13

julia> a = BitArray([true, true, false, false, true])
5-element BitVector:
 1
 1
 0
 0
 1

julia> circshift(a, 1)
5-element BitVector:
 1
 1
 1
 0
 0

julia> circshift(a, -1)
5-element BitVector:
 1
 0
 0
 1
 1

circshift!(dest, src, shifts)

Zirkulär verschieben, d.h. die Daten in src rotieren und das Ergebnis in dest speichern. shifts gibt die Menge an, um die in jeder Dimension verschoben werden soll.

Siehe auch circshift.

circcopy!(dest, src)

Kopiere src nach dest, indem jede Dimension modulo ihrer Länge indiziert wird. src und dest müssen die gleiche Größe haben, können jedoch in ihren Indizes versetzt sein; jede Versetzung führt zu einer (zirkulären) Umwicklung. Wenn die Arrays überlappende Indizes haben, dann stimmt dest im Bereich der Überlappung mit src überein.

Siehe auch: circshift.

Beispiele

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

julia> dest = OffsetArray{Int}(undef, (0:3,2:5))

julia> circcopy!(dest, src)
OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} mit Indizes 0:3×2:5:
 8  12  16  4
 5   9  13  1
 6  10  14  2
 7  11  15  3

julia> dest[1:3,2:4] == src[1:3,2:4]
true

findall(A)

Gibt einen Vektor I der true Indizes oder Schlüssel von A zurück. Wenn es keine solchen Elemente von A gibt, wird ein leeres Array zurückgegeben. Um nach anderen Arten von Werten zu suchen, übergeben Sie ein Prädikat als erstes Argument.

Indizes oder Schlüssel sind vom gleichen Typ wie die von keys(A) und pairs(A) zurückgegebenen.

Siehe auch: findfirst, searchsorted.

Beispiele

julia> A = [true, false, false, true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> findall(A)
2-element Vector{Int64}:
 1
 4

julia> A = [true false; false true]
2×2 Matrix{Bool}:
 1  0
 0  1

julia> findall(A)
2-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 2)

julia> findall(falses(3))
Int64[]

findall(f::Function, A)

Gibt einen Vektor I der Indizes oder Schlüssel von A zurück, wo f(A[I]) true zurückgibt. Wenn es keine solchen Elemente von A gibt, wird ein leeres Array zurückgegeben.

Indizes oder Schlüssel sind vom gleichen Typ wie die, die von keys(A) und pairs(A) zurückgegeben werden.

Beispiele

julia> x = [1, 3, 4]
3-element Vector{Int64}:
 1
 3
 4

julia> findall(isodd, x)
2-element Vector{Int64}:
 1
 2

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

julia> findall(!iszero, A)
4-element Vector{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

julia> d = Dict(:A => 10, :B => -1, :C => 0)
Dict{Symbol, Int64} mit 3 Einträgen:
  :A => 10
  :B => -1
  :C => 0

julia> findall(x -> x >= 0, d)
2-element Vector{Symbol}:
 :A
 :C

findfirst(A)

Gibt den Index oder Schlüssel des ersten true Wertes in A zurück. Gibt nothing zurück, wenn kein solcher Wert gefunden wird. Um nach anderen Arten von Werten zu suchen, übergeben Sie ein Prädikat als erstes Argument.

Indizes oder Schlüssel sind vom gleichen Typ wie die von keys(A) und pairs(A) zurückgegebenen.

Siehe auch: findall, findnext, findlast, searchsortedfirst.

Beispiele

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 0
 0
 1
 0

julia> findfirst(A)
3

julia> findfirst(falses(3)) # gibt nichts zurück, wird aber nicht im REPL ausgegeben

julia> A = [false false; true false]
2×2 Matrix{Bool}:
 0  0
 1  0

julia> findfirst(A)
CartesianIndex(2, 1)

findfirst(predicate::Function, A)

Gibt den Index oder Schlüssel des ersten Elements von A zurück, für das predicate true zurückgibt. Gibt nothing zurück, wenn es kein solches Element gibt.

Indizes oder Schlüssel sind vom gleichen Typ wie die, die von keys(A) und pairs(A) zurückgegeben werden.

Beispiele

julia> A = [1, 4, 2, 2]
4-element Vector{Int64}:
 1
 4
 2
 2

julia> findfirst(iseven, A)
2

julia> findfirst(x -> x>10, A) # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> findfirst(isequal(4), A)
2

julia> A = [1 4; 2 2]
2×2 Matrix{Int64}:
 1  4
 2  2

julia> findfirst(iseven, A)
CartesianIndex(2, 1)

findlast(A)

Gibt den Index oder Schlüssel des letzten true Wertes in A zurück. Gibt nothing zurück, wenn es keinen true Wert in A gibt.

Indizes oder Schlüssel sind vom gleichen Typ wie die, die von keys(A) und pairs(A) zurückgegeben werden.

Siehe auch: findfirst, findprev, findall.

Beispiele

julia> A = [true, false, true, false]
4-element Vector{Bool}:
 1
 0
 1
 0

julia> findlast(A)
3

julia> A = falses(2,2);

julia> findlast(A) # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> findlast(A)
CartesianIndex(2, 1)

findlast(predicate::Function, A)

Gibt den Index oder Schlüssel des letzten Elements von A zurück, für das predicate true zurückgibt. Gibt nothing zurück, wenn es kein solches Element gibt.

Indizes oder Schlüssel sind vom gleichen Typ wie die, die von keys(A) und pairs(A) zurückgegeben werden.

Beispiele

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

julia> findlast(isodd, A)
3

julia> findlast(x -> x > 5, A) # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> findlast(isodd, A)
CartesianIndex(2, 1)

findnext(A, i)

Finde den nächsten Index nach oder einschließlich i eines true-Elements von A, oder nothing, wenn nicht gefunden.

Indizes sind vom gleichen Typ wie die von keys(A) und pairs(A) zurückgegebenen.

Beispiele

julia> A = [false, false, true, false]
4-element Vector{Bool}:
 0
 0
 1
 0

julia> findnext(A, 1)
3

julia> findnext(A, 4) # gibt nothing zurück, wird aber nicht im REPL angezeigt

julia> A = [false false; true false]
2×2 Matrix{Bool}:
 0  0
 1  0

julia> findnext(A, CartesianIndex(1, 1))
CartesianIndex(2, 1)

findnext(predicate::Function, A, i)

Finde den nächsten Index nach oder einschließlich i eines Elements von A, für das predicate true zurückgibt, oder nothing, wenn nichts gefunden wurde. Dies funktioniert für Arrays, Strings und die meisten anderen Sammlungen, die getindex, keys(A) und nextind unterstützen.

Indizes sind vom gleichen Typ wie die, die von keys(A) und pairs(A) zurückgegeben werden.

Beispiele

julia> A = [1, 4, 2, 2];

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> A = [1 4; 2 2];

julia> findnext(isodd, A, CartesianIndex(1, 1))
CartesianIndex(1, 1)

julia> findnext(isspace, "a b c", 3)
4

findprev(A, i)

Finde den vorherigen Index vor oder einschließlich i eines true-Elements von A, oder nothing, wenn nichts gefunden wurde.

Indizes sind vom gleichen Typ wie die von keys(A) und pairs(A) zurückgegebenen.

Siehe auch: findnext, findfirst, findall.

Beispiele

julia> A = [false, false, true, true]
4-element Vector{Bool}:
 0
 0
 1
 1

julia> findprev(A, 3)
3

julia> findprev(A, 1) # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> A = [false false; true true]
2×2 Matrix{Bool}:
 0  0
 1  1

julia> findprev(A, CartesianIndex(2, 1))
CartesianIndex(2, 1)

findprev(predicate::Function, A, i)

Finde den vorherigen Index vor oder einschließlich i eines Elements von A, für das predicate true zurückgibt, oder nothing, wenn nichts gefunden wurde. Dies funktioniert für Arrays, Strings und die meisten anderen Sammlungen, die getindex, keys(A) und nextind unterstützen.

Indizes sind vom gleichen Typ wie die, die von keys(A) und pairs(A) zurückgegeben werden.

Beispiele

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

julia> findprev(isodd, A, 1) # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> findprev(isodd, A, 3)
3

julia> A = [4 6; 1 2]
2×2 Matrix{Int64}:
 4  6
 1  2

julia> findprev(isodd, A, CartesianIndex(1, 2))
CartesianIndex(2, 1)

julia> findprev(isspace, "a b c", 3)
2

permutedims(A::AbstractArray, perm)
permutedims(A::AbstractMatrix)

Permutieren Sie die Dimensionen (Achsen) des Arrays A. perm ist ein Tupel oder Vektor von ndims(A) Ganzzahlen, die die Permutation angeben.

Wenn A ein 2D-Array (AbstractMatrix) ist, dann ist perm standardmäßig (2,1), was die beiden Achsen von A (die Zeilen und Spalten der Matrix) vertauscht. Dies unterscheidet sich von transpose, da die Operation nicht rekursiv ist, was besonders nützlich für Arrays mit nicht-numerischen Werten ist (wo die rekursive transpose einen Fehler auslösen würde) und/oder 2D-Arrays, die keine linearen Operatoren darstellen.

Für 1D-Arrays siehe permutedims(v::AbstractVector), das eine 1-Zeilen-“Matrix” zurückgibt.

Siehe auch permutedims!, PermutedDimsArray, transpose, invperm.

Beispiele

2D-Arrays:

Im Gegensatz zu transpose kann permutedims verwendet werden, um Zeilen und Spalten von 2D-Arrays beliebiger nicht-numerischer Elemente, wie z.B. Strings, zu vertauschen:

julia> A = ["a" "b" "c"
            "d" "e" "f"]
2×3 Matrix{String}:
 "a"  "b"  "c"
 "d"  "e"  "f"

julia> permutedims(A)
3×2 Matrix{String}:
 "a"  "d"
 "b"  "e"
 "c"  "f"

Und permutedims liefert Ergebnisse, die sich von transpose für Matrizen unterscheiden, deren Elemente selbst numerische Matrizen sind:

julia> a = [1 2; 3 4];

julia> b = [5 6; 7 8];

julia> c = [9 10; 11 12];

julia> d = [13 14; 15 16];

julia> X = [[a] [b]; [c] [d]]
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]     [5 6; 7 8]
 [9 10; 11 12]  [13 14; 15 16]

julia> permutedims(X)
2×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [9 10; 11 12]
 [5 6; 7 8]  [13 14; 15 16]

julia> transpose(X)
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [9 11; 10 12]
 [5 7; 6 8]  [13 15; 14 16]

Mehrdimensionale Arrays

julia> A = reshape(Vector(1:8), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

julia> perm = (3, 1, 2); # die letzte Dimension zuerst setzen

julia> B = permutedims(A, perm)
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 5  6

[:, :, 2] =
 3  4
 7  8

julia> A == permutedims(B, invperm(perm)) # die inverse Permutation
true

Für jede Dimension i von B = permutedims(A, perm) wird die entsprechende Dimension von A perm[i] sein. Das bedeutet, dass die Gleichheit size(B, i) == size(A, perm[i]) gilt.

julia> A = randn(5, 7, 11, 13);

julia> perm = [4, 1, 3, 2];

julia> B = permutedims(A, perm);

julia> size(B)
(13, 5, 11, 7)

julia> size(A)[perm] == ans
true

permutedims(v::AbstractVector)

Formatiere den Vektor v in eine 1 × length(v) Zeilenmatrix um. Unterscheidet sich von transpose darin, dass die Operation nicht rekursiv ist, was besonders nützlich für Arrays mit nicht-numerischen Werten ist (wo das rekursive transpose einen Fehler auslösen könnte).

Beispiele

Im Gegensatz zu transpose kann permutedims auf Vektoren beliebiger nicht-numerischer Elemente angewendet werden, wie z.B. Strings:

julia> permutedims(["a", "b", "c"])
1×3 Matrix{String}:
 "a"  "b"  "c"

Für Vektoren von Zahlen funktioniert permutedims(v) ähnlich wie transpose(v), mit dem Unterschied, dass der Rückgabetyp anders ist (es verwendet reshape anstelle einer LinearAlgebra.Transpose-Ansicht, obwohl beide den Speicher mit dem ursprünglichen Array v teilen):

julia> v = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> p = permutedims(v)
1×4 Matrix{Int64}:
 1  2  3  4

julia> r = transpose(v)
1×4 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3  4

julia> p == r
true

julia> typeof(r)
Transpose{Int64, Vector{Int64}}

julia> p[1] = 5; r[2] = 6; # Mutieren von p oder r ändert auch v

julia> v # teilt den Speicher mit sowohl p als auch r
4-element Vector{Int64}:
 5
 6
 3
 4

Allerdings liefert permutedims Ergebnisse, die sich von transpose für Vektoren unterscheiden, deren Elemente selbst numerische Matrizen sind:

julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
2-element Vector{Matrix{Int64}}:
 [1 2; 3 4]
 [5 6; 7 8]

julia> permutedims(V)
1×2 Matrix{Matrix{Int64}}:
 [1 2; 3 4]  [5 6; 7 8]

julia> transpose(V)
1×2 transpose(::Vector{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 3; 2 4]  [5 7; 6 8]

permutedims!(dest, src, perm)

Permutieren Sie die Dimensionen des Arrays src und speichern Sie das Ergebnis im Array dest. perm ist ein Vektor, der eine Permutation der Länge ndims(src) angibt. Das vorab zugewiesene Array dest sollte size(dest) == size(src)[perm] haben und wird vollständig überschrieben. Es wird keine In-Place-Permutation unterstützt, und unerwartete Ergebnisse treten auf, wenn src und dest überlappende Speicherbereiche haben.

Siehe auch permutedims.

PermutedDimsArray(A, perm) -> B

Gegeben ein AbstractArray A, erstellen Sie eine Ansicht B, sodass die Dimensionen permutiert erscheinen. Ähnlich wie permutedims, jedoch ohne Kopieren ( B teilt den Speicher mit A).

Siehe auch permutedims, invperm.

Beispiele

julia> A = rand(3,5,4);

julia> B = PermutedDimsArray(A, (3,1,2));

julia> size(B)
(4, 3, 5)

julia> B[3,1,2] == A[1,2,3]
true

promote_shape(s1, s2)

Überprüfen Sie die Kompatibilität von zwei Array-Formen, wobei nachfolgende Singleton-Dimensionen erlaubt sind, und geben Sie die Form mit mehr Dimensionen zurück.

Beispiele

julia> a = fill(1, (3,4,1,1,1));

julia> b = fill(1, (3,4));

julia> promote_shape(a,b)
(Base.OneTo(3), Base.OneTo(4), Base.OneTo(1), Base.OneTo(1), Base.OneTo(1))

julia> promote_shape((2,3,1,4), (2, 3, 1, 4, 1))
(2, 3, 1, 4, 1)

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

Kumulative Operation op entlang der Dimension dims von A (wobei dims für Vektoren optional ist). Ein Anfangswert init kann optional durch ein Schlüsselwort-Argument bereitgestellt werden. Siehe auch accumulate!, um ein vorab zugewiesenes Ausgabearray zu verwenden, sowohl für die Leistung als auch um die Genauigkeit der Ausgabe zu steuern (z. B. um Überlauf zu vermeiden).

Für gängige Operationen gibt es spezialisierte Varianten von accumulate, siehe cumsum, cumprod. Für eine faule Version siehe Iterators.accumulate.

Beispiele

julia> accumulate(+, [1,2,3])
3-element Vector{Int64}:
 1
 3
 6

julia> 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) => 9

julia> accumulate(+, fill(1, 3, 4))
3×4 Matrix{Int64}:
 1  4  7  10
 2  5  8  11
 3  6  9  12

julia> 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

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

Kumulative Operation op auf A entlang der Dimension dims, wobei das Ergebnis in B gespeichert wird. Die Angabe von dims ist für Vektoren optional. Wenn das Schlüsselwort-Argument init angegeben wird, wird dessen Wert zur Instanziierung der Akkumulation verwendet.

Siehe auch accumulate, cumsum!, cumprod!.

Beispiele

julia> x = [1, 0, 2, 0, 3];

julia> y = rand(5);

julia> accumulate!(+, y, x);

julia> y
5-element Vector{Float64}:
 1.0
 1.0
 3.0
 3.0
 6.0

julia> 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  -3

julia> accumulate!(*, B, A, dims=2, init=10)
2×3 Matrix{Int64}:
 10   20    60
 40  200  1200

cumprod(A; dims::Integer)

Kumulative Produkt entlang der Dimension dim. Siehe auch cumprod!, um ein vorab zugewiesenes Ausgabearray zu verwenden, sowohl für die Leistung als auch um die Genauigkeit der Ausgabe zu steuern (z. B. um Überlauf zu vermeiden).

Beispiele

julia> a = Int8[1 2 3; 4 5 6];

julia> cumprod(a, dims=1)
2×3 Matrix{Int64}:
 1   2   3
 4  10  18

julia> cumprod(a, dims=2)
2×3 Matrix{Int64}:
 1   2    6
 4  20  120

cumprod(itr)

Kumulative Produkt eines Iterators.

Siehe auch cumprod!, accumulate, cumsum.

Beispiele

julia> cumprod(fill(1//2, 3))
3-element Vector{Rational{Int64}}:
 1//2
 1//4
 1//8

julia> cumprod((1, 2, 1, 3, 1))
(1, 2, 2, 6, 6)

julia> cumprod("julia")
5-element Vector{String}:
 "j"
 "ju"
 "jul"
 "juli"
 "julia"

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

Kumulative Produkt von A entlang der Dimension dims, wobei das Ergebnis in B gespeichert wird. Siehe auch cumprod.

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

Kumulative Produkt eines Vektors x, wobei das Ergebnis in y gespeichert wird. Siehe auch cumprod.

cumsum(A; dims::Integer)

Kumulative Summe entlang der Dimension dims. Siehe auch cumsum!, um ein vorab zugewiesenes Ausgabearray zu verwenden, sowohl für die Leistung als auch um die Genauigkeit der Ausgabe zu steuern (z. B. um Überlauf zu vermeiden).

Beispiele

julia> a = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> cumsum(a, dims=1)
2×3 Matrix{Int64}:
 1  2  3
 5  7  9

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

!!! Hinweis Der eltype des Rückgabearrays ist Int für vorzeichenbehaftete Ganzzahlen mit weniger als der Systemwortgröße und UInt für vorzeichenlose Ganzzahlen mit weniger als der Systemwortgröße. Um den eltype von Arrays mit kleinen vorzeichenbehafteten oder vorzeichenlosen Ganzzahlen zu erhalten, sollte accumulate(+, A) verwendet werden.

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

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

Im ersten Fall werden die Ganzzahlen auf die Systemwortgröße erweitert, und daher ist das Ergebnis `Int64[100, 128]`. Im letzteren Fall erfolgt keine solche Erweiterung, und der Ganzzahlüberlauf führt zu `Int8[100, -128]`.

cumsum(itr)

Kumulative Summe eines Iterators.

Siehe auch accumulate, um Funktionen anzuwenden, die nicht + sind.

Beispiele

julia> cumsum(1:3)
3-element Vector{Int64}:
 1
 3
 6

julia> 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]

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

Kumulative Summe von A entlang der Dimension dims, wobei das Ergebnis in B gespeichert wird. Siehe auch cumsum.

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

Endlicher Differenzenoperator auf einem Vektor oder einem mehrdimensionalen Array A. Im letzteren Fall muss die Dimension, auf der gearbeitet werden soll, mit dem Schlüsselwortargument dims angegeben werden.

Beispiele

julia> a = [2 4; 6 16]
2×2 Matrix{Int64}:
 2   4
 6  16

julia> diff(a, dims=2)
2×1 Matrix{Int64}:
  2
 10

julia> diff(vec(a))
3-element Vector{Int64}:
  4
 -2
 12

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

Konstruiere ein Array, indem das Array A eine gegebene Anzahl von Malen in jeder Dimension wiederholt wird, wie durch counts angegeben.

Siehe auch: fill, Iterators.repeated, Iterators.cycle.

Beispiele

julia> repeat([1, 2, 3], 2)
6-element Vector{Int64}:
 1
 2
 3
 1
 2
 3

julia> repeat([1, 2, 3], 2, 3)
6×3 Matrix{Int64}:
 1  1  1
 2  2  2
 3  3  3
 1  1  1
 2  2  2
 3  3  3

repeat(A::AbstractArray; inner=ntuple(Returns(1), ndims(A)), outer=ntuple(Returns(1), ndims(A)))

Konstruiere ein Array, indem die Einträge von A wiederholt werden. Das i-te Element von inner gibt an, wie oft die einzelnen Einträge der i-ten Dimension von A wiederholt werden sollen. Das i-te Element von outer gibt an, wie oft ein Abschnitt entlang der i-ten Dimension von A wiederholt werden soll. Wenn inner oder outer weggelassen werden, erfolgt keine Wiederholung.

Beispiele

julia> repeat(1:2, inner=2)
4-element Vector{Int64}:
 1
 1
 2
 2

julia> repeat(1:2, outer=2)
4-element Vector{Int64}:
 1
 2
 1
 2

julia> repeat([1 2; 3 4], inner=(2, 1), outer=(1, 3))
4×6 Matrix{Int64}:
 1  2  1  2  1  2
 1  2  1  2  1  2
 3  4  3  4  3  4
 3  4  3  4  3  4

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

Wiederhole einen String r Mal. Dies kann als s^r geschrieben werden.

Siehe auch ^.

Beispiele

julia> repeat("ha", 3)
"hahaha"

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

Wiederhole ein Zeichen r Mal. Dies kann auch erreicht werden, indem man c^r aufruft.

Beispiele

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

rot180(A)

Drehe die Matrix A um 180 Grad.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rot180(a)
2×2 Matrix{Int64}:
 4  3
 2  1

rot180(A, k)

Drehe die Matrix A um 180 Grad eine ganze Zahl k Mal. Wenn k gerade ist, entspricht dies einer Kopie.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rot180(a,1)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rot180(a,2)
2×2 Matrix{Int64}:
 1  2
 3  4

rotl90(A)

Drehe die Matrix A um 90 Grad nach links.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotl90(a)
2×2 Matrix{Int64}:
 2  4
 1  3

rotl90(A, k)

Drehen Sie die Matrix A um 90 Grad gegen den Uhrzeigersinn eine ganze Zahl k Mal. Wenn k ein Vielfaches von vier (einschließlich null) ist, entspricht dies einer copy.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotl90(a,1)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotl90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotl90(a,3)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotl90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4

rotr90(A)

Drehe die Matrix A um 90 Grad nach rechts.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotr90(a)
2×2 Matrix{Int64}:
 3  1
 4  2

rotr90(A, k)

Drehen Sie die Matrix A um 90 Grad im Uhrzeigersinn eine ganze Zahl k Mal. Wenn k ein Vielfaches von vier (einschließlich null) ist, entspricht dies einer copy.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rotr90(a,1)
2×2 Matrix{Int64}:
 3  1
 4  2

julia> rotr90(a,2)
2×2 Matrix{Int64}:
 4  3
 2  1

julia> rotr90(a,3)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> rotr90(a,4)
2×2 Matrix{Int64}:
 1  2
 3  4

mapslices(f, A; dims)

Transformiere die angegebenen Dimensionen des Arrays A, indem eine Funktion f auf jede Scheibe der Form A[..., :, ..., :, ...] angewendet wird, mit einem Doppelpunkt an jeder d in dims. Die Ergebnisse werden entlang der verbleibenden Dimensionen zusammengefügt.

Zum Beispiel, wenn dims = [1,2] und A 4-dimensional ist, dann wird f auf x = A[:,:,i,j] für alle i und j aufgerufen, und f(x) wird zu R[:,:,i,j] im Ergebnis R.

Siehe auch eachcol oder eachslice, verwendet mit map oder stack.

Beispiele

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) mit eltype Int64:
[:, :, 1] =
 1  3  5  7   9
 2  4  6  8  10

[:, :, 2] =
 11  13  15  17  19
 12  14  16  18  20

[:, :, 3] =
 21  23  25  27  29
 22  24  26  28  30

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # gibt eine 1×4 Matrix zurück

julia> B = mapslices(f, A, dims=(1,2))
1×4×3 Array{Int64, 3}:
[:, :, 1] =
 1  1  1  1

[:, :, 2] =
 11  11  11  11

[:, :, 3] =
 21  21  21  21

julia> f2(x::AbstractMatrix) = fill(x[1,1], 1,4);

julia> B == stack(f2, eachslice(A, dims=3))
true

julia> g(x) = x[begin] // x[end-1];  # gibt eine Zahl zurück

julia> mapslices(g, A, dims=[1,3])
1×5×1 Array{Rational{Int64}, 3}:
[:, :, 1] =
 1//21  3//23  1//5  7//27  9//29

julia> map(g, eachslice(A, dims=2))
5-element Vector{Rational{Int64}}:
 1//21
 3//23
 1//5
 7//27
 9//29

julia> mapslices(sum, A; dims=(1,3)) == sum(A; dims=(1,3))
true

Beachte, dass in eachslice(A; dims=2) die angegebene Dimension diejenige ist, ohne einen Doppelpunkt in der Scheibe. Dies ist view(A,:,i,:), während mapslices(f, A; dims=(1,3)) A[:,i,:] verwendet. Die Funktion f kann Werte in der Scheibe ändern, ohne A zu beeinflussen.

eachrow(A::AbstractVecOrMat) <: AbstractVector

Erstellt ein RowSlices Objekt, das ein Vektor von Zeilen der Matrix oder des Vektors A ist. Zeilen-Slices werden als AbstractVector Ansichten von A zurückgegeben.

Für das Gegenteil siehe stack(rows; dims=1).

Siehe auch eachcol, eachslice und mapslices.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> s = eachrow(a)
2-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2]
 [3, 4]

julia> s[1]
2-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2

eachcol(A::AbstractVecOrMat) <: AbstractVector

Erstellt ein ColumnSlices Objekt, das ein Vektor von Spalten der Matrix oder des Vektors A ist. Spaltenausschnitte werden als AbstractVector Ansichten von A zurückgegeben.

Für das Gegenteil siehe stack(cols) oder reduce(hcat, cols).

Siehe auch eachrow, eachslice und mapslices.

Beispiele

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> s = eachcol(a)
2-element ColumnSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}}:
 [1, 3]
 [2, 4]

julia> s[1]
2-element view(::Matrix{Int64}, :, 1) with eltype Int64:
 1
 3

eachslice(A::AbstractArray; dims, drop=true)

Erstellt ein Slices Objekt, das ein Array von Schnitten über die Dimensionen dims von A ist und Ansichten zurückgibt, die alle Daten aus den anderen Dimensionen in A auswählen. dims kann entweder eine ganze Zahl oder ein Tupel von ganzen Zahlen sein.

Wenn drop = true (der Standard), werden die äußeren Slices die inneren Dimensionen verwerfen, und die Anordnung der Dimensionen entspricht denen in dims. Wenn drop = false, haben die Slices die gleiche Dimensionalität wie das zugrunde liegende Array, wobei die inneren Dimensionen die Größe 1 haben.

Siehe stack(slices; dims) für die Umkehrung von eachslice(A; dims::Integer).

Siehe auch eachrow, eachcol, mapslices und selectdim.

Beispiele

julia> m = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> s = eachslice(m, dims=1)
3-element RowSlices{Matrix{Int64}, Tuple{Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

julia> s[1]
3-element view(::Matrix{Int64}, 1, :) with eltype Int64:
 1
 2
 3

julia> eachslice(m, dims=1, drop=false)
3×1 Slices{Matrix{Int64}, Tuple{Int64, Colon}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, SubArray{Int64, 1, Matrix{Int64}, Tuple{Int64, Base.Slice{Base.OneTo{Int64}}}, true}, 2}:
 [1, 2, 3]
 [4, 5, 6]
 [7, 8, 9]

invperm(v)

Gibt die inverse Permutation von v zurück. Wenn B = A[v], dann gilt A == B[invperm(v)].

Siehe auch sortperm, invpermute!, isperm, permutedims.

Beispiele

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
 2

julia> 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)

isperm(v) -> Bool

Gibt true zurück, wenn v eine gültige Permutation ist.

Beispiele

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

Permutieren Sie den Vektor v in-place gemäß der Permutation p. Es wird keine Überprüfung durchgeführt, um zu verifizieren, dass p eine Permutation ist.

Um eine neue Permutation zurückzugeben, verwenden Sie v[p]. Dies ist im Allgemeinen schneller als permute!(v, p); es ist sogar schneller, in ein vorab zugewiesenes Ausgabearray mit u .= @view v[p] zu schreiben. (Obwohl permute! v in-place überschreibt, erfordert es intern einige Zuweisungen, um nachzuhalten, welche Elemente verschoben wurden.)

Siehe auch invpermute!.

Beispiele

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> permute!(A, perm);

julia> A
4-element Vector{Int64}:
 1
 4
 3
 1

invpermute!(v, p)

Wie permute!, aber die Inverse der gegebenen Permutation wird angewendet.

Beachten Sie, dass es schneller ist, ein vorab zugewiesenes Ausgabearray zu verwenden (z. B. u = similar(v)), anstatt u[p] = v zu verwenden. (invpermute! allokiert intern eine Kopie der Daten.)

Beispiele

julia> A = [1, 1, 3, 4];

julia> perm = [2, 4, 3, 1];

julia> invpermute!(A, perm);

julia> A
4-element Vector{Int64}:
 4
 1
 3
 1

reverse(A; dims=:)

Kehrt A entlang der Dimension dims um, die eine ganze Zahl (eine einzelne Dimension), ein Tupel von ganzen Zahlen (ein Tupel von Dimensionen) oder : (um entlang aller Dimensionen umzukehren, die Standardoption) sein kann. Siehe auch reverse! für die Umkehrung in-place.

Beispiele

julia> b = Int64[1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> reverse(b, dims=2)
2×2 Matrix{Int64}:
 2  1
 4  3

julia> reverse(b)
2×2 Matrix{Int64}:
 4  3
 2  1

reverseind(v, i)

Gegeben einen Index i in reverse(v), gib den entsprechenden Index in v zurück, sodass v[reverseind(v,i)] == reverse(v)[i]. (Dies kann nicht trivial sein, wenn v nicht-ASCII-Zeichen enthält.)

Beispiele

julia> s = "Julia🚀"
"Julia🚀"

julia> r = reverse(s)
"🚀ailuJ"

julia> for i in eachindex(s)
           print(r[reverseind(r, i)])
       end
Julia🚀

reverse!(v [, start=firstindex(v) [, stop=lastindex(v) ]]) -> v

In-place-Version von reverse.

Beispiele

julia> A = Vector(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> reverse!(A);

julia> A
5-element Vector{Int64}:
 5
 4
 3
 2
 1

reverse!(A; dims=:)

Wie reverse, aber arbeitet in-place in A.