Arrays

AbstractArray{T,N}

Supertype pour les tableaux N-dimensionnels (ou types similaires à des tableaux) avec des éléments de type T. Array et d'autres types sont des sous-types de cela. Voir la section du manuel sur l'interface AbstractArray.

Voir aussi : AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

Supertype pour les tableaux unidimensionnels (ou types similaires aux tableaux) avec des éléments de type T. Alias pour AbstractArray{T,1}.

AbstractMatrix{T}

Supertype pour les tableaux bidimensionnels (ou types similaires à des tableaux) avec des éléments de type T. Alias pour AbstractArray{T,2}.

AbstractVecOrMat{T}

Type d'union de AbstractVector{T} et AbstractMatrix{T}.

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

Tableau dense de dimension N avec des éléments de type T.

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

Construit un tableau N-dimensionnel non initialisé Array contenant des éléments de type T. N peut être fourni explicitement, comme dans Array{T,N}(undef, dims), ou être déterminé par la longueur ou le nombre de dims. dims peut être un tuple ou une série d'arguments entiers correspondant aux longueurs dans chaque dimension. Si le rang N est fourni explicitement, il doit correspondre à la longueur ou au nombre de dims. Ici, undef est le UndefInitializer.

Exemples

julia> A = Array{Float64, 2}(undef, 2, 3) # N donné explicitement
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 déterminé par l'entrée
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # utilise typeof(B), et la taille donné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}(rien, dims)
Array{T,N}(rien, dims)

Construisez un tableau Array N-dimensionnel contenant des éléments de type T, initialisé avec des entrées nothing. Le type d'élément T doit être capable de contenir ces valeurs, c'est-à-dire Nothing <: T.

Exemples

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

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

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

Construit un tableau N-dimensionnel Array contenant des éléments de type T, initialisé avec des entrées missing. Le type d'élément T doit être capable de contenir ces valeurs, c'est-à-dire Missing <: T.

Exemples

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

Type singleton utilisé dans l'initialisation de tableau, indiquant que l'appelant du constructeur de tableau souhaite un tableau non initialisé. Voir aussi undef, un alias pour UndefInitializer().

Exemples

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

undef

Alias pour UndefInitializer(), qui construit une instance du type singleton UndefInitializer, utilisé dans l'initialisation de tableau pour indiquer que l'appelant du constructeur de tableau souhaite un tableau non initialisé.

Voir aussi : missing, similar.

Exemples

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

Vector{T} <: AbstractVector{T}

Tableau dense unidimensionnel avec des éléments de type T, souvent utilisé pour représenter un vecteur mathématique. Alias pour Array{T,1}.

Voir aussi empty, similar et zero pour créer des vecteurs.

Vector{T}(undef, n)

Construit un Vector{T} non initialisé de longueur n.

Exemples

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

Vector{T}(rien, m)

Construit un Vector{T} de longueur m, initialisé avec des entrées rien. Le type d'élément T doit être capable de contenir ces valeurs, c'est-à-dire Nothing <: T.

Exemples

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

Vector{T}(missing, m)

Construit un Vector{T} de longueur m, initialisé avec des entrées missing. Le type d'élément T doit être capable de contenir ces valeurs, c'est-à-dire Missing <: T.

Exemples

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

Matrix{T} <: AbstractMatrix{T}

Tableau dense à deux dimensions avec des éléments de type T, souvent utilisé pour représenter une matrice mathématique. Alias pour Array{T,2}.

Voir aussi fill, zeros, undef et similar pour créer des matrices.

Matrix{T}(undef, m, n)

Construit un Matrix{T} non initialisé de taille m×n.

Exemples

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}(rien, m, n)

Construire une Matrix{T} de taille m×n, initialisée avec des entrées rien. Le type d'élément T doit être capable de contenir ces valeurs, c'est-à-dire Nothing <: T.

Exemples

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

Matrix{T}(missing, m, n)

Construit une Matrix{T} de taille m×n, initialisée avec des entrées missing. Le type d'élément T doit être capable de contenir ces valeurs, c'est-à-dire Missing <: T.

Exemples

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

VecOrMat{T}

Type d'union de Vector{T} et Matrix{T} qui permet aux fonctions d'accepter soit une matrice, soit un vecteur.

Exemples

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}

Tableau dense de dimension N avec des éléments de type T. Les éléments d'un tableau dense sont stockés de manière contiguë en mémoire.

DenseVector{T}

Tableau unidimensionnel DenseArray avec des éléments de type T. Alias pour DenseArray{T,1}.

DenseMatrix{T}

Tableau à deux dimensions DenseArray avec des éléments de type T. Alias pour DenseArray{T,2}.

DenseVecOrMat{T}

Type union de DenseVector{T} et DenseMatrix{T}.

StridedArray{T, N}

Un Union codé en dur des types de tableau courants qui suivent l' interface de tableau stridé, avec des éléments de type T et N dimensions.

Si A est un StridedArray, alors ses éléments sont stockés en mémoire avec des décalages, qui peuvent varier entre les dimensions mais sont constants au sein d'une dimension. Par exemple, A pourrait avoir un pas de 2 dans la dimension 1, et un pas de 3 dans la dimension 2. Incrémenter A le long de la dimension d saute en mémoire de [stride(A, d)] emplacements. Les tableaux stridés sont particulièrement importants et utiles car ils peuvent parfois être passés directement comme pointeurs à des bibliothèques de langages étrangers comme BLAS.

StridedVector{T}

Unidimensionnel StridedArray avec des éléments de type T.

StridedMatrix{T}

Tableau à deux dimensions StridedArray avec des éléments de type T.

StridedVecOrMat{T}

Type d'union de StridedVector et StridedMatrix avec des éléments de type T.

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

Taille fixe DenseVector{T}.

kind peut actuellement être soit :not_atomic soit :atomic. Pour des détails sur ce que cela implique, voir AtomicMemory

addrspace ne peut actuellement être défini que sur Core.CPU. Il est conçu pour permettre l'extension par d'autres systèmes tels que les GPU, qui pourraient définir des valeurs telles que :

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

La sémantique exacte de ces autres addrspaces est définie par le backend spécifique, mais générera une erreur si l'utilisateur tente d'y accéder sur le CPU.

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

Vecteur dense de taille fixe DenseVector{T}.

`memoryref(::GenericMemory)`

Construit un GenericMemoryRef à partir d'un objet mémoire. Cela ne échoue pas, mais la mémoire résultante pointera hors limites si et seulement si la mémoire est vide.

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

Construit un GenericMemoryRef à partir d'un objet mémoire et d'un index de décalage (basé sur 1) qui peut également être négatif. Cela renvoie toujours un objet dans les limites, et générera une erreur si cela n'est pas possible (car l'index entraînerait un décalage hors limites de la mémoire sous-jacente).

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

Un AbstractArray de tranches dans un tableau parent sur des dimensions spécifiées, retournant des vues qui sélectionnent toutes les données des autres dimensions.

Celles-ci devraient généralement être construites par eachslice, eachcol ou eachrow.

parent(s::Slices) renverra le tableau parent.

RowSlices{M,AX,S}

Un cas spécial de Slices qui est un vecteur de tranches de lignes d'une matrice, tel que construit par eachrow.

parent peut être utilisé pour obtenir la matrice sous-jacente.

ColumnSlices{M,AX,S}

Un cas spécial de Slices qui est un vecteur de tranches de colonnes d'une matrice, tel que construit par eachcol.

parent peut être utilisé pour obtenir la matrice sous-jacente.

getindex(type[, elements...])

Construit un tableau 1-d du type spécifié. Cela s'appelle généralement avec la syntaxe Type[]. Les valeurs des éléments peuvent être spécifiées en utilisant Type[a,b,c,...].

Exemples

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

Crée un Array, avec le type d'élément T, de tous les zéros avec une taille spécifiée par dims. Voir aussi fill, ones, zero.

Exemples

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

Crée un Array, avec le type d'élément T, de tous les uns avec une taille spécifiée par dims. Voir aussi fill, zeros.

Exemples

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}

Tableau booléen N-dimensionnel économe en espace, utilisant juste un bit pour chaque valeur booléenne.

Les BitArray regroupent jusqu'à 64 valeurs dans chaque 8 octets, résultant en une efficacité d'espace de 8x par rapport à Array{Bool, N} et permettant à certaines opérations de fonctionner sur 64 valeurs à la fois.

Par défaut, Julia renvoie des BitArrays à partir des opérations de diffusion qui génèrent des éléments booléens (y compris les comparaisons avec point comme .==) ainsi qu'à partir des fonctions trues et falses.

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

Construit un BitArray undef avec les dimensions données. Comporte de manière identique au constructeur Array. Voir undef.

Exemples

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)

Construit un BitArray généré par l'objet itérable donné. La forme est déduite de l'objet itr.

Exemples

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)

Crée un BitArray avec toutes les valeurs définies sur true.

Exemples

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

falses(dims)

Crée un BitArray avec toutes les valeurs définies sur false.

Exemples

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

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

Créez un tableau de taille dims avec chaque emplacement défini sur value.

Par exemple, fill(1.0, (5,5)) renvoie un tableau 5×5 de flottants, avec 1.0 dans chaque emplacement du tableau.

Les longueurs de dimension dims peuvent être spécifiées soit comme un tuple, soit comme une séquence d'arguments. Un tuple de longueur N ou N arguments suivant le value spécifient un tableau de dimension N. Ainsi, un idiome courant pour créer un tableau de dimension zéro avec son seul emplacement défini sur x est fill(x).

Chaque emplacement du tableau renvoyé est défini sur (et est donc === à) la value qui a été passée ; cela signifie que si la value est elle-même modifiée, tous les éléments du tableau fillé refléteront cette modification car ils sont toujours cette même value. Cela n'est pas un problème avec fill(1.0, (5,5)) car la value 1.0 est immuable et ne peut pas elle-même être modifiée, mais cela peut être inattendu avec des valeurs mutables comme — le plus souvent — des tableaux. Par exemple, fill([], 3) place le même tableau vide dans les trois emplacements du vecteur renvoyé :

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]

Pour créer un tableau de nombreux tableaux intérieurs indépendants, utilisez une compréhension à la place. Cela crée un nouveau tableau distinct à chaque itération de la boucle :

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

Voir aussi : fill!, zeros, ones, similar.

Exemples

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) # définit les deux éléments sur le même vecteur [0.0, 0.0]
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # modifie la valeur remplie pour être [42.0, 0.0]

julia> A # A[1] et A[2] sont le même vecteur
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

Remplissez le tableau A avec la valeur x. Si x est une référence d'objet, tous les éléments référenceront le même objet. fill!(A, Foo()) renverra A rempli avec le résultat de l'évaluation de Foo() une fois.

Exemples

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)

Retourne un tuple vide, ().

empty(v::AbstractVector, [eltype])

Crée un vecteur vide similaire à v, en changeant éventuellement le eltype.

Voir aussi : empty!, isempty, isassigned.

Exemples

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

Crée un conteneur AbstractDict vide qui peut accepter des indices de type index_type et des valeurs de type value_type. Les deuxième et troisième arguments sont optionnels et par défaut au keytype et valtype de l'entrée, respectivement. (Si l'un des deux types est spécifié, il est supposé être le value_type, et le index_type par défaut est keytype(a)).

Les sous-types AbstractDict personnalisés peuvent choisir quel type de dictionnaire spécifique est le mieux adapté à retourner pour les types d'index et de valeur donnés, en se spécialisant sur la signature à trois arguments. La valeur par défaut est de retourner un Dict vide.

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

Créez un tableau mutable non initialisé avec le type d'élément, le type d'index et la taille donnés, basé sur la source SparseMatrixCSC donnée. La nouvelle matrice creuse maintient la structure de la matrice creuse originale, sauf dans le cas où les dimensions de la matrice de sortie sont différentes de la sortie.

La matrice de sortie a des zéros aux mêmes emplacements que l'entrée, mais des valeurs non initialisées pour les emplacements non nuls.

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

Crée un tableau mutable non initialisé avec le type d'élément et la taille donnés, basé sur le tableau source donné. Les deuxième et troisième arguments sont tous deux optionnels, par défaut au eltype et à la size du tableau donné. Les dimensions peuvent être spécifiées soit comme un seul argument tuple, soit comme une série d'arguments entiers.

Les sous-types d'AbstractArray personnalisés peuvent choisir quel type de tableau spécifique est le mieux adapté à retourner pour le type d'élément et la dimensionnalité donnés. S'ils ne spécialisent pas cette méthode, le défaut est un Array{element_type}(undef, dims...).

Par exemple, similar(1:10, 1, 4) retourne un Array{Int,2} non initialisé puisque les plages ne sont ni mutables ni supportent 2 dimensions :

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

Inversement, similar(trues(10,10), 2) retourne un BitVector non initialisé avec deux éléments puisque les BitArrays sont à la fois mutables et peuvent supporter des tableaux unidimensionnels :

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

Cependant, puisque les BitArrays ne peuvent stocker que des éléments de type Bool, si vous demandez un type d'élément différent, cela créera un Array régulier à la place :

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

Voir aussi : undef, isassigned.

similar(storagetype, axes)

Crée un tableau mutable non initialisé analogue à celui spécifié par storagetype, mais avec axes spécifié par le dernier argument.

Exemples :

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

crée un tableau qui "agit comme" un Array{Int} (et qui pourrait en effet être soutenu par un), mais qui est indexé de manière identique à A. Si A a un indexage conventionnel, cela sera identique à Array{Int}(undef, size(A)), mais si A a un indexage non conventionnel, alors les indices du résultat correspondront à ceux de A.

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

créerait un tableau logique unidimensionnel dont les indices correspondent à ceux des colonnes de A.

ndims(A::AbstractArray) -> Integer

Retourne le nombre de dimensions de A.

Voir aussi : size, axes.

Exemples

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

Renvoie un tuple contenant les dimensions de A. En option, vous pouvez spécifier une dimension pour obtenir uniquement la longueur de cette dimension.

Notez que size peut ne pas être défini pour les tableaux avec des indices non standards, auquel cas axes peut être utile. Voir le chapitre du manuel sur les tableaux avec des indices personnalisés.

Voir aussi : length, ndims, eachindex, sizeof.

Exemples

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

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

julia> size(A, 2)
3

axes(A)

Retourne le tuple des indices valides pour le tableau A.

Voir aussi : size, keys, eachindex.

Exemples

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

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

axes(A, d)

Renvoie la plage valide d'indices pour le tableau A le long de la dimension d.

Voir aussi size, et le chapitre du manuel sur les tableaux avec des indices personnalisés.

Exemples

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

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

julia> axes(A, 4) == 1:1  # toutes les dimensions d > ndims(A) ont une taille de 1
true

Remarque d'utilisation

Chacun des indices doit être un AbstractUnitRange{<:Integer}, mais en même temps peut être un type qui utilise des indices personnalisés. Donc, par exemple, si vous avez besoin d'un sous-ensemble, utilisez des constructions d'indexation généralisées comme begin/end ou firstindex/lastindex:

ix = axes(v, 1)
ix[2:end]          # fonctionnera par exemple pour Vector, mais peut échouer en général
ix[(begin+1):end]  # fonctionne pour des index généralisés

length(A::AbstractArray)

Retourne le nombre d'éléments dans le tableau, par défaut prod(size(A)).

Exemples

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

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

keys(a::AbstractArray)

Renvoie un tableau efficace décrivant tous les indices valides pour a disposés dans la forme de a lui-même.

Les clés des tableaux unidimensionnels (vecteurs) sont des entiers, tandis que tous les autres tableaux N-dimensionnels utilisent CartesianIndex pour décrire leurs emplacements. Souvent, les types de tableaux spéciaux LinearIndices et CartesianIndices sont utilisés pour représenter efficacement ces tableaux d'entiers et de CartesianIndex, respectivement.

Notez que les keys d'un tableau peuvent ne pas être le type d'index le plus efficace ; pour des performances maximales, utilisez plutôt eachindex.

Exemples

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

Créez un objet itérable pour visiter chaque index d'un AbstractArray A de manière efficace. Pour les types de tableau qui ont opté pour un indexation linéaire rapide (comme Array), c'est simplement l'intervalle 1:length(A) s'ils utilisent une indexation basée sur 1. Pour les types de tableau qui n'ont pas opté pour une indexation linéaire rapide, un intervalle cartésien spécialisé est généralement renvoyé pour indexer efficacement le tableau avec des indices spécifiés pour chaque dimension.

En général, eachindex accepte des itérables arbitraires, y compris des chaînes de caractères et des dictionnaires, et renvoie un objet itérateur prenant en charge des types d'index arbitraires (par exemple, des indices non uniformément espacés ou non entiers).

Si A est AbstractArray, il est possible de spécifier explicitement le style des indices qui doivent être renvoyés par eachindex en passant une valeur ayant le type IndexStyle comme premier argument (typiquement IndexLinear() si des indices linéaires sont requis ou IndexCartesian() si un intervalle cartésien est souhaité).

Si vous fournissez plus d'un argument AbstractArray, eachindex créera un objet itérable qui est rapide pour tous les arguments (typiquement un UnitRange si toutes les entrées ont une indexation linéaire rapide, un CartesianIndices sinon). Si les tableaux ont des tailles et/ou des dimensions différentes, une exception DimensionMismatch sera levée.

Voir aussi pairs(A) pour itérer sur les indices et les valeurs ensemble, et axes(A, 2) pour des indices valides le long d'une dimension.

Exemples

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

julia> for i in eachindex(A) # indexation linéaire
           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)) # indexation cartésienne
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle spécifie le "style d'indexation natif" pour le tableau A. Lorsque vous définissez un nouveau type AbstractArray, vous pouvez choisir d'implémenter soit l'indexation linéaire (avec IndexLinear) soit l'indexation cartésienne. Si vous décidez d'implémenter uniquement l'indexation linéaire, vous devez alors définir ce trait pour votre type de tableau :

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

La valeur par défaut est IndexCartesian().

La machinerie d'indexation interne de Julia recalculera automatiquement (et de manière invisible) toutes les opérations d'indexation dans le style préféré. Cela permet aux utilisateurs d'accéder aux éléments de votre tableau en utilisant n'importe quel style d'indexation, même lorsque des méthodes explicites n'ont pas été fournies.

Si vous définissez les deux styles d'indexation pour votre AbstractArray, ce trait peut être utilisé pour sélectionner le style d'indexation le plus performant. Certaines méthodes vérifient ce trait sur leurs entrées et dispatchent vers différents algorithmes en fonction du modèle d'accès le plus efficace. En particulier, eachindex crée un itérateur dont le type dépend du paramètre de ce trait.

IndexLinear()

Sous-type de IndexStyle utilisé pour décrire les tableaux qui sont indexés de manière optimale par un index linéaire.

Un style d'indexation linéaire utilise un index entier pour décrire la position dans le tableau (même s'il s'agit d'un tableau multidimensionnel) et un ordre de colonne est utilisé pour accéder efficacement aux éléments. Cela signifie que la demande de eachindex à partir d'un tableau qui est IndexLinear renverra une simple plage unidimensionnelle, même s'il est multidimensionnel.

Un tableau personnalisé qui signale son IndexStyle comme IndexLinear n'a besoin d'implémenter l'indexation (et l'assignation indexée) qu'avec un seul index Int ; toutes les autres expressions d'indexation — y compris les accès multidimensionnels — seront recomputées à l'index linéaire. Par exemple, si A était une matrice personnalisée 2×3 avec indexation linéaire, et que nous référencions A[1, 3], cela serait recomputé à l'index linéaire équivalent et appellerait A[5] puisque 1 + 2*(3 - 1) = 5.

Voir aussi IndexCartesian.

IndexCartesian()

Sous-type de IndexStyle utilisé pour décrire les tableaux qui sont indexés de manière optimale par un index cartésien. C'est le comportement par défaut pour les nouveaux sous-types personnalisés AbstractArray.

Un style d'indexation cartésien utilise plusieurs indices entiers pour décrire la position dans un tableau multidimensionnel, avec exactement un indice par dimension. Cela signifie que demander eachindex à partir d'un tableau qui est IndexCartesian renverra une plage de CartesianIndices.

Un tableau personnalisé de dimension N qui rapporte son IndexStyle comme IndexCartesian doit implémenter l'indexation (et l'assignation indexée) avec exactement N indices Int ; toutes les autres expressions d'indexation — y compris l'indexation linéaire — seront recalculées à l'emplacement cartésien équivalent. Par exemple, si A était une matrice personnalisée 2×3 avec indexation cartésienne, et que nous référencions A[5], cela serait recalculé à l'indice cartésien équivalent et appellerait A[1, 3] puisque 5 = 1 + 2*(3 - 1).

Il est significativement plus coûteux de calculer des indices cartésiens à partir d'un indice linéaire que d'aller dans l'autre sens. La première opération nécessite une division — une opération très coûteuse — tandis que la seconde n'utilise que la multiplication et l'addition et est essentiellement gratuite. Cette asymétrie signifie qu'il est beaucoup plus coûteux d'utiliser l'indexation linéaire avec un tableau IndexCartesian qu'il ne l'est d'utiliser l'indexation cartésienne avec un tableau IndexLinear.

Voir aussi IndexLinear.

conj!(A)

Transforme un tableau en son conjugué complexe sur place.

Voir aussi conj.

Exemples

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)

Retourne la distance en mémoire (en nombre d'éléments) entre les éléments adjacents dans la dimension k.

Voir aussi : strides.

Exemples

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

Renvoie un tuple des pas de mémoire dans chaque dimension.

Voir aussi : stride.

Exemples

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

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

broadcast(f, As...)

Diffuser la fonction f sur les tableaux, tuples, collections, Refs et/ou scalaires As.

Le broadcasting applique la fonction f sur les éléments des arguments de conteneur et les scalaires eux-mêmes dans As. Les dimensions singleton et manquantes sont étendues pour correspondre aux étendues des autres arguments en répétant virtuellement la valeur. Par défaut, seuls un nombre limité de types sont considérés comme des scalaires, y compris les Numbers, Strings, Symbols, Types, Functions et quelques singleton courants comme missing et nothing. Tous les autres arguments sont itérés ou indexés élément par élément.

Le type de conteneur résultant est établi par les règles suivantes :

• Si tous les arguments sont des scalaires ou des tableaux à zéro dimension, il retourne un scalaire non enveloppé.
• Si au moins un argument est un tuple et que tous les autres sont des scalaires ou des tableaux à zéro dimension, il retourne un tuple.
• Toutes les autres combinaisons d'arguments par défaut retournent un Array, mais les types de conteneurs personnalisés peuvent définir leur propre implémentation et des règles de promotion pour personnaliser le résultat lorsqu'ils apparaissent comme arguments.

Une syntaxe spéciale existe pour le broadcasting : f.(args...) est équivalent à broadcast(f, args...), et les appels imbriqués f.(g.(args...)) sont fusionnés en une seule boucle de broadcasting.

Exemples

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

Comme broadcast, mais stocke le résultat de broadcast(f, As...) dans le tableau dest. Notez que dest est uniquement utilisé pour stocker le résultat et ne fournit pas d'arguments à f à moins qu'il ne soit également listé dans les As, comme dans broadcast!(f, A, A, B) pour effectuer A[:] = broadcast(f, A, B).

Exemples

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

Convertir chaque appel de fonction ou opérateur dans expr en un "appel avec point" (par exemple, convertir f(x) en f.(x)), et convertir chaque affectation dans expr en une "affectation avec point" (par exemple, convertir += en .+=).

Si vous souhaitez éviter d'ajouter des points pour des appels de fonction sélectionnés dans expr, insérez ces appels de fonction avec $. Par exemple, @. sqrt(abs($sort(x))) est équivalent à sqrt.(abs.(sort(x))) (pas de point pour sort).

(@. est équivalent à un appel à @__dot__.)

Exemples

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 est un type abstrait et une fonction de trait utilisée pour déterminer le comportement des objets lors de la diffusion. BroadcastStyle(typeof(x)) renvoie le style associé à x. Pour personnaliser le comportement de diffusion d'un type, on peut déclarer un style en définissant une paire type/méthode

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

On écrit ensuite des méthode(s) (au moins similar) opérant sur Broadcasted{MyContainerStyle}. Il existe également plusieurs sous-types pré-définis de BroadcastStyle que vous pouvez exploiter ; consultez le chapitre Interfaces pour plus d'informations.

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle est le supertype abstrait pour tout style associé à un type AbstractArray. Le paramètre N est la dimensionnalité, ce qui peut être utile pour les types AbstractArray qui ne prennent en charge que des dimensionnalités spécifiques :

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

Pour les types AbstractArray qui prennent en charge une dimensionnalité arbitraire, N peut être défini sur Any :

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

Dans les cas où vous souhaitez pouvoir mélanger plusieurs AbstractArrayStyles et suivre la dimensionnalité, votre style doit prendre en charge un constructeur Val :

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

Notez que si deux ou plusieurs sous-types AbstractArrayStyle entrent en conflit, le mécanisme de diffusion reviendra à produire des Arrays. Si cela est indésirable, vous devrez peut-être définir des règles binaires BroadcastStyle pour contrôler le type de sortie.

Voir aussi Broadcast.DefaultArrayStyle.

Broadcast.ArrayStyle{MyArrayType}() est un BroadcastStyle indiquant qu'un objet se comporte comme un tableau pour le broadcasting. Il présente un moyen simple de construire des Broadcast.AbstractArrayStyles pour des types de conteneurs AbstractArray spécifiques. Les styles de broadcasting créés de cette manière perdent la trace de la dimensionnalité ; si le suivi est important pour votre type, vous devriez créer votre propre Broadcast.AbstractArrayStyle.

Broadcast.DefaultArrayStyle{N}() est un BroadcastStyle indiquant qu'un objet se comporte comme un tableau N-dimensionnel pour le broadcasting. Plus précisément, DefaultArrayStyle est utilisé pour tout type AbstractArray qui n'a pas défini de style spécialisé, et en l'absence de remplacements d'autres arguments de broadcast, le type de sortie résultant est Array. Lorsqu'il y a plusieurs entrées pour broadcast, DefaultArrayStyle "perd" face à tout autre Broadcast.ArrayStyle.

Broadcast.broadcastable(x)

Retourne soit x soit un objet comme x tel qu'il supporte axes, l'indexation, et son type supporte ndims.

Si x supporte l'itération, la valeur retournée doit avoir les mêmes comportements d'axes et d'indexation que collect(x).

Si x n'est pas un AbstractArray mais qu'il supporte axes, l'indexation, et que son type supporte ndims, alors broadcastable(::typeof(x)) peut être implémenté pour retourner simplement lui-même. De plus, si x définit son propre BroadcastStyle, alors il doit définir sa méthode broadcastable pour retourner lui-même afin que le style personnalisé ait un effet.

Exemples

julia> Broadcast.broadcastable([1,2,3]) # comme `identity` puisque les tableaux supportent déjà axes et indexation
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Les types ne supportent pas axes, indexation, ou itération mais sont couramment utilisés comme scalaires
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Les chaînes rompent la convention de correspondance d'itération et agissent comme un scalaire à la place
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

Déterminez les axes de résultat pour le broadcasting à travers toutes les valeurs dans 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

Décide quel BroadcastStyle utiliser pour un nombre quelconque d'arguments de valeur. Utilise BroadcastStyle pour obtenir le style de chaque argument, et utilise result_style pour combiner les styles.

Exemples

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

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

Prend un ou deux BroadcastStyle et les combine en utilisant BroadcastStyle pour déterminer un BroadcastStyle commun.

Exemples

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

Retourne un sous-ensemble du tableau A tel que sélectionné par les indices inds.

Chaque indice peut être de n'importe quel type d'indice supporté, tel qu'un Integer, CartesianIndex, plage, ou tableau d'indices supportés. Un : peut être utilisé pour sélectionner tous les éléments le long d'une dimension spécifique, et un tableau booléen (par exemple un Array{Bool} ou un BitArray) peut être utilisé pour filtrer les éléments où l'indice correspondant est true.

Lorsque inds sélectionne plusieurs éléments, cette fonction retourne un tableau nouvellement alloué. Pour indexer plusieurs éléments sans faire de copie, utilisez view à la place.

Voir la section du manuel sur l'indexation des tableaux pour plus de détails.

Exemples

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

Stockez des valeurs du tableau X dans un sous-ensemble de A tel que spécifié par inds. La syntaxe A[inds...] = X est équivalente à (setindex!(A, X, inds...); X).

Exemples

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)

Renvoie l'index après i dans A. L'index retourné est souvent équivalent à i + 1 pour un entier i. Cette fonction peut être utile pour du code générique.

Voir aussi : prevind.

Exemples

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

julia> nextind(x, 1) # résultat valide
2

julia> nextind(x, 4) # résultat invalide
5

julia> nextind(x, CartesianIndex(1, 1)) # résultat valide
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # résultat invalide
CartesianIndex(1, 3)

prevind(A, i)

Retourne l'index avant i dans A. L'index retourné est souvent équivalent à i - 1 pour un entier i. Cette fonction peut être utile pour du code générique.

Voir aussi : nextind.

Exemples

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

julia> prevind(x, 4) # résultat valide
3

julia> prevind(x, 1) # résultat invalide
0

julia> prevind(x, CartesianIndex(2, 2)) # résultat valide
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # résultat invalide
CartesianIndex(2, 0)

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

Copie le bloc de src dans la plage de Rsrc vers le bloc de dest dans la plage de Rdest. Les tailles des deux régions doivent correspondre.

Exemples

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

Copie en place copy de src dans dst, en supprimant tout élément préexistant dans dst. Si dst et src sont du même type, dst == src doit être vrai après l'appel. Si dst et src sont des tableaux multidimensionnels, ils doivent avoir des axes égaux.

Voir aussi copyto!.

isassigned(array, i) -> Bool

Testez si le tableau donné a une valeur associée à l'index i. Retournez false si l'index est hors limites ou a une référence indéfinie.

Exemples

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

Les deux-points (:) sont utilisés pour signifier l'indexation d'objets ou de dimensions entiers à la fois.

Très peu d'opérations sont définies directement sur les deux-points ; au lieu de cela, ils sont convertis par to_indices en un type de vecteur interne (Base.Slice) pour représenter la collection d'indices qu'ils couvrent avant d'être utilisés.

L'instance singleton de Colon est également une fonction utilisée pour construire des plages ; voir :.

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

Créez un index multidimensionnel I, qui peut être utilisé pour indexer un tableau multidimensionnel A. En particulier, A[I] est équivalent à A[i,j,k...]. On peut mélanger librement des indices entiers et des indices CartesianIndex ; par exemple, A[Ipre, i, Ipost] (où Ipre et Ipost sont des indices CartesianIndex et i est un Int) peut être une expression utile lors de l'écriture d'algorithmes qui fonctionnent le long d'une seule dimension d'un tableau de dimensionnalité arbitraire.

Un CartesianIndex est parfois produit par eachindex, et toujours lors de l'itération avec des CartesianIndices explicites.

Un I::CartesianIndex est traité comme un "scalaire" (pas un conteneur) pour broadcast. Pour itérer sur les composants d'un CartesianIndex, convertissez-le en tuple avec Tuple(I).

Exemples

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

Définissez une région R s'étendant sur une plage rectangulaire multidimensionnelle d'indices entiers. Ceux-ci sont le plus souvent rencontrés dans le contexte de l'itération, où for I in R ... end renverra des indices CartesianIndex I équivalents aux boucles imbriquées

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

Par conséquent, ceux-ci peuvent être utiles pour écrire des algorithmes qui fonctionnent dans des dimensions arbitraires.

CartesianIndices(A::AbstractArray) -> R

Par commodité, la construction d'un CartesianIndices à partir d'un tableau crée une plage de ses indices.

Exemples

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

Conversion entre indices linéaires et cartésiens

La conversion d'un indice linéaire à un indice cartésien exploite le fait qu'un CartesianIndices est un AbstractArray et peut être indexé linéairement :

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)

Diffusion

CartesianIndices prend en charge l'arithmétique de diffusion (+ et -) avec un 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))

Pour la conversion d'un indice cartésien à un indice linéaire, voir LinearIndices.

Dims{N}

Un NTuple de N Ints utilisé pour représenter les dimensions d'un AbstractArray.

LinearIndices(A::AbstractArray)

Retourne un tableau LinearIndices avec la même forme et les mêmes axes que A, contenant l'indice linéaire de chaque entrée dans A. L'indexation de ce tableau avec des indices cartésiens permet de les mapper à des indices linéaires.

Pour les tableaux avec une indexation conventionnelle (les indices commencent à 1), ou tout tableau multidimensionnel, les indices linéaires varient de 1 à length(A). Cependant, pour les AbstractVector, les indices linéaires sont axes(A, 1), et ne commencent donc pas à 1 pour les vecteurs avec une indexation non conventionnelle.

Appeler cette fonction est la manière "sûre" d'écrire des algorithmes qui exploitent l'indexation linéaire.

Exemples

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

Retourne un tableau LinearIndices avec la forme spécifiée ou les axes.

Exemples

Le but principal de ce constructeur est la conversion intuitive de l'indexation cartésienne à l'indexation linéaire :

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)

Convertir le tuple I en un tuple d'indices à utiliser pour indexer le tableau A.

Le tuple retourné ne doit contenir que des Ints ou des AbstractArrays d'indices scalaires qui sont supportés par le tableau A. Il renverra une erreur en rencontrant un type d'index nouveau qu'il ne sait pas traiter.

Pour les types d'index simples, il se réfère à la fonction non exportée Base.to_index(A, i) pour traiter chaque index i. Bien que cette fonction interne ne soit pas destinée à être appelée directement, Base.to_index peut être étendue par des types de tableaux ou d'index personnalisés pour fournir des comportements d'indexation personnalisés.

Des types d'index plus compliqués peuvent nécessiter plus de contexte sur la dimension dans laquelle ils indexent. Pour prendre en charge ces cas, to_indices(A, I) appelle to_indices(A, axes(A), I), qui parcourt ensuite de manière récursive à la fois le tuple donné d'indices et les indices dimensionnels de A en tandem. Ainsi, tous les types d'index ne sont pas garantis de se propager à Base.to_index.

Exemples

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)) # pas de vérification des limites
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # index exotique
(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)) # pas de vérification de forme
(1, 2)

checkbounds(Bool, A, I...)

Retourne true si les indices spécifiés I sont dans les limites pour le tableau donné A. Les sous-types de AbstractArray devraient spécialiser cette méthode s'ils ont besoin de fournir des comportements de vérification des limites personnalisés ; cependant, dans de nombreux cas, on peut se fier aux indices de A et à checkindex.

Voir aussi checkindex.

Exemples

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

Lance une erreur si les indices spécifiés I ne sont pas dans les limites du tableau donné A.

checkindex(Bool, inds::AbstractUnitRange, index)

Retourne true si l'index donné est dans les limites de inds. Les types personnalisés qui souhaitent se comporter comme des indices pour tous les tableaux peuvent étendre cette méthode afin de fournir une implémentation de vérification des limites spécialisée.

Voir aussi checkbounds.

Exemples

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

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

elsize(type)

Calcule le pas mémoire en octets entre les éléments consécutifs de eltype stockés à l'intérieur du type donné, si les éléments du tableau sont stockés de manière dense avec un pas linéaire uniforme.

Exemples

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

view(A, inds...)

Comme getindex, mais renvoie un tableau léger qui référence paresseusement (ou est effectivement une vue sur) le tableau parent A à l'index ou aux indices donnés inds au lieu d'extraire les éléments de manière anticipée ou de construire un sous-ensemble copié. Appeler getindex ou setindex! sur la valeur renvoyée (souvent un SubArray) calcule les indices pour accéder ou modifier le tableau parent à la volée. Le comportement est indéfini si la forme du tableau parent est modifiée après l'appel de view car il n'y a pas de vérification de limite pour le tableau parent ; par exemple, cela peut provoquer une erreur de segmentation.

Certains tableaux parents immuables (comme les plages) peuvent choisir de simplement recalculer un nouveau tableau dans certaines circonstances au lieu de renvoyer un SubArray si cela est efficace et fournit une sémantique compatible.

Exemples

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 # Notez que A a changé même si nous avons modifié b
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # renvoie une plage car le type est immuable
3:4

@view A[inds...]

Transformez l'expression d'indexation A[inds...] en l'appel équivalent view.

Cela ne peut être appliqué directement qu'à une seule expression d'indexation et est particulièrement utile pour les expressions qui incluent les syntaxes d'indexation spéciales begin ou end comme A[begin, 2:end-1] (car celles-ci ne sont pas prises en charge par la fonction normale view).

Notez que @view ne peut pas être utilisé comme cible d'une affectation régulière (par exemple, @view(A[1, 2:end]) = ...), ni l'affectation indexée non décorée A[1, 2:end] = ... ou l'affectation indexée diffusée (A[1, 2:end] .= ...) ne ferait une copie. Cependant, cela peut être utile pour mettre à jour des affectations diffusées comme @view(A[1, 2:end]) .+= 1 car c'est une syntaxe simple pour @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1, et l'expression d'indexation du côté droit ferait autrement une copie sans le @view.

Voir aussi @views pour passer un bloc entier de code à utiliser des vues pour l'indexation non scalaire.

Exemples

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 expression

Convertir chaque opération de découpage de tableau dans l'expression donnée (qui peut être un bloc begin/end, une boucle, une fonction, etc.) pour retourner une vue. Les indices scalaires, les types non-tableau et les appels explicites de getindex (par opposition à array[...]) ne sont pas affectés.

De même, @views convertit les tranches de chaînes en vues de SubString.

Exemples

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b est une vue, pas une copie
           b .= row      # assigner chaque élément à l'indice de ligne
       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)

Retourne l'objet parent sous-jacent de la vue. Ce parent d'objets de types SubArray, SubString, ReshapedArray ou LinearAlgebra.Transpose est ce qui a été passé comme argument à view, reshape, transpose, etc. lors de la création de l'objet. Si l'entrée n'est pas un objet enveloppé, retourne l'entrée elle-même. Si l'entrée est enveloppée plusieurs fois, seule l'enveloppe la plus externe sera supprimée.

Exemples

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, :) with eltype Int64:
 1  2
 3  4

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

parentindices(A)

Retourne les indices dans le parent qui correspondent à la vue A.

Exemples

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

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

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

selectdim(A, d::Integer, i)

Renvoie une vue de toutes les données de A où l'index pour la dimension d est égal à i.

Équivalent à view(A,:,:,...,i,:,:,...) où i est en position d.

Voir aussi : eachslice.

Exemples

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)

Changez l'interprétation de type des données binaires dans la valeur isbits x à celle du type isbits Out. La taille (en ignorant le remplissage) de Out doit être la même que celle du type de x. Par exemple, reinterpret(Float32, UInt32(7)) interprète les 4 octets correspondant à UInt32(7) comme un Float32. Notez que 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)

Construit une vue de l'array avec les mêmes données binaires que l'array donné, mais avec T comme type d'élément.

Cette fonction fonctionne également sur les arrays "paresseux" dont les éléments ne sont pas calculés tant qu'ils ne sont pas explicitement récupérés. Par exemple, reinterpret sur la plage 1:6 fonctionne de manière similaire à sur le vecteur dense 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

Si l'emplacement des bits de remplissage ne s'aligne pas entre T et eltype(A), l'array résultant sera en lecture seule ou en écriture seule, pour empêcher des bits invalides d'être écrits ou lus, respectivement.

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 of type Tuple{UInt8, UInt32} is not compatible with type UInt32.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # showing will error

julia> b[1]
ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.

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

Changez l'interprétation de type de A tout en consommant ou en ajoutant une "dimension de canal."

Si sizeof(T) = n*sizeof(S) pour n>1, la première dimension de A doit avoir une taille de n et B n'a pas la première dimension de A. Inversement, si sizeof(S) = n*sizeof(T) pour n>1, B obtient une nouvelle première dimension de taille n. La dimensionnalité reste inchangée si sizeof(T) == sizeof(S).

Exemples

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

julia> reinterpret(reshape, Complex{Int}, A)    # le résultat est un vecteur
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)             # le résultat est une matrice
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

Renvoie un tableau avec les mêmes données que A, mais avec des tailles de dimensions ou un nombre de dimensions différents. Les deux tableaux partagent les mêmes données sous-jacentes, de sorte que le résultat est mutable si et seulement si A est mutable, et que la modification des éléments de l'un altère les valeurs de l'autre.

Les nouvelles dimensions peuvent être spécifiées soit sous forme d'une liste d'arguments, soit sous forme d'un tuple de forme. Au maximum une dimension peut être spécifiée avec un :, auquel cas sa longueur est calculée de sorte que son produit avec toutes les dimensions spécifiées soit égal à la longueur du tableau original A. Le nombre total d'éléments ne doit pas changer.

Exemples

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)

Renvoie un tableau avec les mêmes données que A, mais avec les dimensions spécifiées par dims supprimées. size(A,d) doit être égal à 1 pour chaque d dans dims, et les dimensions répétées ou les nombres en dehors de 1:ndims(A) sont interdits.

Le résultat partage les mêmes données sous-jacentes que A, de sorte que le résultat est mutable si et seulement si A est mutable, et que la modification des éléments de l'un altère les valeurs de l'autre.

Voir aussi : reshape, vec.

Exemples

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

Reshape le tableau a en un vecteur colonne unidimensionnel. Retourne a s'il est déjà un AbstractVector. Le tableau résultant partage les mêmes données sous-jacentes que a, donc il ne sera mutable que si a est mutable, auquel cas modifier l'un modifiera également l'autre.

Exemples

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

Voir aussi reshape, dropdims.

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

Vue N-dimensionnelle dans un tableau parent (de type P) avec un type d'élément T, restreint par un tuple d'indices (de type I). L est vrai pour les types qui supportent l'indexation linéaire rapide, et faux sinon.

Construisez des SubArrays en utilisant la fonction view.

cat(A...; dims)

Concaténer les tableaux d'entrée le long des dimensions spécifiées dans dims.

Le long d'une dimension d in dims, la taille du tableau de sortie est sum(size(a,d) for a in A). Le long des autres dimensions, tous les tableaux d'entrée doivent avoir la même taille, qui sera également la taille du tableau de sortie le long de ces dimensions.

Si dims est un seul nombre, les différents tableaux sont étroitement regroupés le long de cette dimension. Si dims est un itérable contenant plusieurs dimensions, les positions le long de ces dimensions sont augmentées simultanément pour chaque tableau d'entrée, remplissant de zéros ailleurs. Cela permet de construire des matrices diagonales par blocs comme cat(matrices...; dims=(1,2)), et leurs analogues de dimensions supérieures.

Le cas particulier dims=1 est vcat, et dims=2 est hcat. Voir aussi hvcat, hvncat, stack, repeat.

Le mot-clé accepte également Val(dims).

Exemples

Concaténer deux tableaux dans différentes dimensions :

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

Aide Étendue

Concaténer des tableaux 3D :

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

Concaténer des tableaux de tailles différentes :

julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # même que 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

Construire une matrice diagonale par blocs :

julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # diagonale par blocs
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...)

Concaténer des tableaux ou des nombres verticalement. Équivalent à cat(A...; dims=1), et à la syntaxe [a; b; c].

Pour concaténer un grand vecteur de tableaux, reduce(vcat, A) appelle une méthode efficace lorsque A isa AbstractVector{<:AbstractVecOrMat}, plutôt que de travailler par paires.

Voir aussi hcat, Iterators.flatten, stack.

Exemples

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

julia> v == vcat(1, 2, [3,4])  # accepte les nombres
true

julia> v == [1; 2; [3,4]]  # syntaxe pour la même opération
true

julia> summary(ComplexF64[1; 2; [3,4]])  # syntaxe pour fournir le type d'élément
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # collecte des plages paresseuses
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # vecteur ligne et une matrice
([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)  # plus efficace que vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

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

hcat(A...)

Concaténer des tableaux ou des nombres horizontalement. Équivalent à cat(A...; dims=2), et à la syntaxe [a b c] ou [a;; b;; c].

Pour un grand vecteur de tableaux, reduce(hcat, A) appelle une méthode efficace lorsque A isa AbstractVector{<:AbstractVecOrMat}. Pour un vecteur de vecteurs, cela peut également être écrit stack(A).

Voir aussi vcat, hvcat.

Exemples

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]')  # accepte les nombres
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # syntaxe pour la même opération
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # syntaxe pour fournir le type d'élément
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)  # plus efficace que 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  # désaccord sur un vecteur de matrices
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # vecteurs vides, chacun de taille (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat avec une matrice 2×0 vide
2×1 Matrix{Any}:
 1.1
 9.9

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

Concaténation horizontale et verticale en un seul appel. Cette fonction est appelée pour la syntaxe de matrice de blocs. Le premier argument spécifie le nombre d'arguments à concaténer dans chaque ligne de blocs. Si le premier argument est un seul entier n, alors toutes les lignes de blocs sont supposées avoir n colonnes de blocs.

Exemples

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

Concaténation horizontale, verticale et n-dimensionnelle de plusieurs values en un seul appel.

Cette fonction est appelée pour la syntaxe de matrice bloc. Le premier argument spécifie soit la forme de la concaténation, similaire à hvcat, sous forme de tuple de tuples, soit les dimensions qui spécifient le nombre clé d'éléments le long de chaque axe, et est utilisé pour déterminer les dimensions de sortie. La forme dims est plus performante et est utilisée par défaut lorsque l'opération de concaténation a le même nombre d'éléments le long de chaque axe (par exemple, [a b; c d;;; e f ; g h]). La forme shape est utilisée lorsque le nombre d'éléments le long de chaque axe est déséquilibré (par exemple, [a b ; c]). La syntaxe déséquilibrée nécessite une surcharge de validation supplémentaire. La forme dim est une optimisation pour la concaténation le long d'une seule dimension. row_first indique comment les values sont ordonnés. La signification des premier et deuxième éléments de shape est également échangée en fonction de row_first.

Exemples

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

Exemples pour la construction des arguments

[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 = éléments dans chaque ligne (2, 1, 1)
 _______     _
 3           1 = éléments dans chaque colonne (3, 1)
 _____________
 4             = éléments dans chaque tranche 3d (4,)
 _____________
 4             = éléments dans chaque tranche 4d (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) avec `row_first` = true

stack(iter; [dims])

Combinez une collection de tableaux (ou d'autres objets itérables) de taille égale en un tableau plus grand, en les arrangeant le long d'une ou plusieurs nouvelles dimensions.

Par défaut, les axes des éléments sont placés en premier, donnant size(result) = (size(first(iter))..., size(iter)...). Cela a le même ordre d'éléments que Iterators.flatten(iter).

Avec le mot-clé dims::Integer, au lieu de cela, le i-ème élément de iter devient la tranche selectdim(result, dims, i), de sorte que size(result, dims) == length(iter). Dans ce cas, stack inverse l'action de eachslice avec les mêmes dims.

Les diverses fonctions cat combinent également des tableaux. Cependant, celles-ci étendent toutes les dimensions existantes (possiblement triviales) des tableaux, plutôt que de placer les tableaux le long de nouvelles dimensions. Elles acceptent également des tableaux en tant qu'arguments séparés, plutôt qu'une seule collection.

Exemples

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))  # accepte n'importe quel itérateur d'itérateurs
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)  # contrairement à toute fonction cat, le 1er axe de vecs[1] est le 2ème axe du résultat
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)  # inverse de eachslice
true

Exemples de dimensions supérieures :

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

julia> E = eachslice(A, dims=2);  # un vecteur de matrices

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  # garde toutes les dimensions
(2, 3, 5, 7)

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

julia> hvcat(5, M...) |> size  # hvcat met les matrices côte à côte
(14, 15)

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

Appliquez une fonction à chaque élément d'une collection, et stack le résultat. Ou à plusieurs collections, zipées ensemble.

La fonction doit retourner des tableaux (ou des tuples, ou d'autres itérateurs) tous de la même taille. Ceux-ci deviennent des tranches du résultat, chacune séparée le long de dims (si donné) ou par défaut le long des dernières dimensions.

Voir aussi mapslices, eachcol.

Exemples

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

Crée un Vector avec un type d'élément calculé à partir du promote_typeof de l'argument, contenant la liste des arguments.

Exemples

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

circshift(A, shifts)

Déplace circulairement, c'est-à-dire fait pivoter, les données dans un tableau. Le deuxième argument est un tuple ou un vecteur indiquant le montant à déplacer dans chaque dimension, ou un entier pour déplacer uniquement dans la première dimension.

Voir aussi : circshift!, circcopy!, bitrotate, <<.

Exemples

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)

Effectuer un décalage circulaire, c'est-à-dire une rotation, des données dans src, en stockant le résultat dans dest. shifts spécifie le montant à décaler dans chaque dimension.

Voir aussi circshift.

circcopy!(dest, src)

Copie src dans dest, en indexant chaque dimension modulo sa longueur. src et dest doivent avoir la même taille, mais peuvent être décalés dans leurs indices ; tout décalage entraîne un retour circulaire. Si les tableaux ont des indices qui se chevauchent, alors sur le domaine du chevauchement, dest est identique à src.

Voir aussi : circshift.

Exemples

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}} with indices 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)

Retourne un vecteur I des indices ou clés true de A. S'il n'y a pas d'éléments de A, retourne un tableau vide. Pour rechercher d'autres types de valeurs, passez un prédicat comme premier argument.

Les indices ou clés sont du même type que ceux retournés par keys(A) et pairs(A).

Voir aussi : findfirst, searchsorted.

Exemples

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)

Renvoie un vecteur I des indices ou des clés de A où f(A[I]) renvoie true. S'il n'y a pas d'éléments de A correspondant, renvoie un tableau vide.

Les indices ou clés sont du même type que ceux renvoyés par keys(A) et pairs(A).

Exemples

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} with 3 entries:
  :A => 10
  :B => -1
  :C => 0

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

findfirst(A)

Renvoie l'index ou la clé de la première valeur true dans A. Renvoie nothing si aucune valeur de ce type n'est trouvée. Pour rechercher d'autres types de valeurs, passez un prédicat comme premier argument.

Les indices ou clés sont du même type que ceux retournés par keys(A) et pairs(A).

Voir aussi : findall, findnext, findlast, searchsortedfirst.

Exemples

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # renvoie nothing, mais n'est pas affiché dans le REPL

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

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

findfirst(predicate::Function, A)

Renvoie l'indice ou la clé du premier élément de A pour lequel predicate renvoie true. Renvoie nothing s'il n'y a pas un tel élément.

Les indices ou clés sont du même type que ceux renvoyés par keys(A) et pairs(A).

Exemples

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) # renvoie nothing, mais n'est pas affiché dans le REPL

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)

Renvoie l'indice ou la clé de la dernière valeur true dans A. Renvoie nothing s'il n'y a pas de valeur true dans A.

Les indices ou clés sont du même type que ceux retournés par keys(A) et pairs(A).

Voir aussi : findfirst, findprev, findall.

Exemples

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) # renvoie nothing, mais pas affiché dans le REPL

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

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

findlast(predicate::Function, A)

Retourne l'indice ou la clé du dernier élément de A pour lequel predicate retourne true. Retourne nothing s'il n'y a pas un tel élément.

Les indices ou clés sont du même type que ceux retournés par keys(A) et pairs(A).

Exemples

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) # retourne nothing, mais n'est pas affiché dans le REPL

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

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

findnext(A, i)

Trouver l'index suivant après ou incluant i d'un élément true de A, ou nothing si non trouvé.

Les indices sont du même type que ceux retournés par keys(A) et pairs(A).

Exemples

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

julia> findnext(A, 1)
3

julia> findnext(A, 4) # retourne nothing, mais n'est pas affiché dans le REPL

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)

Trouve l'index suivant après ou incluant i d'un élément de A pour lequel predicate renvoie true, ou nothing si non trouvé. Cela fonctionne pour les tableaux, les chaînes de caractères et la plupart des autres collections qui supportent getindex, keys(A), et nextind.

Les indices sont du même type que ceux retournés par keys(A) et pairs(A).

Exemples

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # renvoie nothing, mais n'est pas imprimé dans le REPL

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)

Trouver l'indice précédent avant ou incluant i d'un élément true de A, ou nothing s'il n'est pas trouvé.

Les indices sont du même type que ceux retournés par keys(A) et pairs(A).

Voir aussi : findnext, findfirst, findall.

Exemples

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

julia> findprev(A, 3)
3

julia> findprev(A, 1) # retourne nothing, mais n'est pas affiché dans le REPL

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)

Trouve l'indice précédent avant ou incluant i d'un élément de A pour lequel predicate renvoie true, ou nothing si non trouvé. Cela fonctionne pour les tableaux, les chaînes de caractères et la plupart des autres collections qui supportent getindex, keys(A), et nextind.

Les indices sont du même type que ceux retournés par keys(A) et pairs(A).

Exemples

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

julia> findprev(isodd, A, 1) # renvoie nothing, mais pas imprimé dans le REPL

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)

Permute les dimensions (axes) du tableau A. perm est un tuple ou un vecteur de ndims(A) entiers spécifiant la permutation.

Si A est un tableau 2d (AbstractMatrix), alors perm par défaut est (2,1), échangeant les deux axes de A (les lignes et les colonnes de la matrice). Cela diffère de transpose en ce sens que l'opération n'est pas récursive, ce qui est particulièrement utile pour les tableaux de valeurs non numériques (où le transpose récursif provoquerait une erreur) et/ou les tableaux 2d qui ne représentent pas des opérateurs linéaires.

Pour les tableaux 1d, voir permutedims(v::AbstractVector), qui retourne une "matrice" à 1 ligne.

Voir aussi permutedims!, PermutedDimsArray, transpose, invperm.

Exemples

Tableaux 2d :

Contrairement à transpose, permutedims peut être utilisé pour échanger les lignes et les colonnes de tableaux 2d d'éléments non numériques arbitraires, tels que des chaînes :

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"

Et permutedims produit des résultats qui diffèrent de transpose pour les matrices dont les éléments sont eux-mêmes des matrices numériques :

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]

Tableaux multi-dimensionnels

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); # mettre la dernière dimension en premier

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)) # la permutation inverse
true

Pour chaque dimension i de B = permutedims(A, perm), sa dimension correspondante de A sera perm[i]. Cela signifie que l'égalité size(B, i) == size(A, perm[i]) est vraie.

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)

Reshape le vecteur v en une matrice ligne 1 × length(v). Diffère de transpose en ce sens que l'opération n'est pas récursive, ce qui est particulièrement utile pour les tableaux de valeurs non numériques (où le transpose récursif pourrait provoquer une erreur).

Exemples

Contrairement à transpose, permutedims peut être utilisé sur des vecteurs d'éléments non numériques arbitraires, tels que des chaînes de caractères :

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

Pour les vecteurs de nombres, permutedims(v) fonctionne de manière similaire à transpose(v), sauf que le type de retour diffère (il utilise reshape plutôt qu'une vue LinearAlgebra.Transpose, bien que les deux partagent la mémoire avec le tableau original v) :

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; # muter p ou r change également v

julia> v # partage la mémoire avec p et r
4-element Vector{Int64}:
 5
 6
 3
 4

Cependant, permutedims produit des résultats qui diffèrent de transpose pour les vecteurs dont les éléments sont eux-mêmes des matrices numériques :

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)

Permute les dimensions du tableau src et stocke le résultat dans le tableau dest. perm est un vecteur spécifiant une permutation de longueur ndims(src). Le tableau préalloué dest doit avoir size(dest) == size(src)[perm] et est complètement écrasé. Aucune permutation en place n'est supportée et des résultats inattendus se produiront si src et dest ont des régions de mémoire qui se chevauchent.

Voir aussi permutedims.

PermutedDimsArray(A, perm) -> B

Étant donné un AbstractArray A, créez une vue B telle que les dimensions semblent être permutées. Semblable à permutedims, sauf qu'aucune copie n'est effectuée (B partage le stockage avec A).

Voir aussi permutedims, invperm.

Exemples

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)

Vérifiez la compatibilité de deux formes de tableau, en permettant des dimensions singleton finales, et renvoyez la forme qui a le plus de dimensions.

Exemples

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

Opération cumulative op le long de la dimension dims de A (fournissant dims est optionnel pour les vecteurs). Une valeur initiale init peut être fournie en option par un argument clé. Voir aussi accumulate! pour utiliser un tableau de sortie préalloué, tant pour la performance que pour contrôler la précision de la sortie (par exemple, pour éviter un débordement).

Pour les opérations courantes, il existe des variantes spécialisées de accumulate, voir cumsum, cumprod. Pour une version paresseuse, voir Iterators.accumulate.

Exemples

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

Opération cumulative op sur A le long de la dimension dims, stockant le résultat dans B. Fournir dims est optionnel pour les vecteurs. Si l'argument clé init est donné, sa valeur est utilisée pour instancier l'accumulation.

Voir aussi accumulate, cumsum!, cumprod!.

Exemples

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)

Produit cumulatif le long de la dimension dim. Voir aussi cumprod! pour utiliser un tableau de sortie préalloué, à la fois pour des performances et pour contrôler la précision de la sortie (par exemple, pour éviter le débordement).

Exemples

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)

Produit cumulatif d'un itérateur.

Voir aussi cumprod!, accumulate, cumsum.

Exemples

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)

Produit cumulatif de A le long de la dimension dims, stockant le résultat dans B. Voir aussi cumprod.

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

Produit cumulatif d'un vecteur x, stockant le résultat dans y. Voir aussi cumprod.

cumsum(A; dims::Integer)

Somme cumulative le long de la dimension dims. Voir aussi cumsum! pour utiliser un tableau de sortie préalloué, à la fois pour des performances et pour contrôler la précision de la sortie (par exemple, pour éviter le débordement).

Exemples

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

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

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

cumsum(itr)

Somme cumulative d'un itérateur.

Voir aussi accumulate pour appliquer des fonctions autres que +.

Exemples

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)

Somme cumulative de A le long de la dimension dims, stockant le résultat dans B. Voir aussi cumsum.

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

Opérateur de différence finie sur un vecteur ou un tableau multidimensionnel A. Dans ce dernier cas, la dimension sur laquelle opérer doit être spécifiée avec l'argument clé dims.

Exemples

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

Construit un tableau en répétant le tableau A un nombre donné de fois dans chaque dimension, spécifié par counts.

Voir aussi : fill, Iterators.repeated, Iterators.cycle.

Exemples

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

Construisez un tableau en répétant les entrées de A. L'élément i-ème de inner spécifie le nombre de fois que les entrées individuelles de la i-ème dimension de A doivent être répétées. L'élément i-ème de outer spécifie le nombre de fois qu'une tranche le long de la i-ème dimension de A doit être répétée. Si inner ou outer sont omis, aucune répétition n'est effectuée.

Exemples

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)

Répète une chaîne r fois. Cela peut être écrit comme s^r.

Voir aussi ^.

Exemples

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

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

Répète un caractère r fois. Cela peut également être accompli en appelant c^r.

Exemples

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

rot180(A)

Faire pivoter la matrice A de 180 degrés.

Exemples

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)

Faire pivoter la matrice A de 180 degrés un nombre entier k de fois. Si k est pair, cela équivaut à une copie.

Exemples

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)

Faire pivoter la matrice A à gauche de 90 degrés.

Exemples

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)

Faites pivoter la matrice A de 90 degrés dans le sens antihoraire un nombre entier k de fois. Si k est un multiple de quatre (y compris zéro), cela équivaut à une copie.

Exemples

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)

Faire pivoter la matrice A vers la droite de 90 degrés.

Exemples

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)

Faire pivoter la matrice A de 90 degrés dans le sens des aiguilles d'une montre un nombre entier k de fois. Si k est un multiple de quatre (y compris zéro), cela équivaut à un copy.

Exemples

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)

Transformez les dimensions données du tableau A en appliquant une fonction f sur chaque tranche de la forme A[..., :, ..., :, ...], avec un deux-points à chaque d dans dims. Les résultats sont concaténés le long des dimensions restantes.

Par exemple, si dims = [1,2] et que A est 4-dimensionnel, alors f est appelé sur x = A[:,:,i,j] pour tous les i et j, et f(x) devient R[:,:,i,j] dans le résultat R.

Voir aussi eachcol ou eachslice, utilisés avec map ou stack.

Exemples

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) avec 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);  # retourne une matrice 1×4

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];  # retourne un nombre

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-élément 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

Remarquez que dans eachslice(A; dims=2), la dimension spécifiée est celle sans deux-points dans la tranche. C'est view(A,:,i,:), tandis que mapslices(f, A; dims=(1,3)) utilise A[:,i,:]. La fonction f peut modifier les valeurs dans la tranche sans affecter A.

eachrow(A::AbstractVecOrMat) <: AbstractVector

Créez un objet RowSlices qui est un vecteur de lignes de la matrice ou du vecteur A. Les tranches de lignes sont retournées sous forme de vues AbstractVector de A.

Pour l'inverse, voir stack(rows; dims=1).

Voir aussi eachcol, eachslice et mapslices.

Exemples

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

Créez un objet ColumnSlices qui est un vecteur de colonnes de la matrice ou du vecteur A. Les tranches de colonnes sont retournées sous forme de vues AbstractVector de A.

Pour l'inverse, voir stack(cols) ou reduce(hcat, cols).

Voir aussi eachrow, eachslice et mapslices.

Exemples

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)

Créez un objet Slices qui est un tableau de tranches sur les dimensions dims de A, retournant des vues qui sélectionnent toutes les données des autres dimensions dans A. dims peut être soit un entier, soit un tuple d'entiers.

Si drop = true (par défaut), le Slices extérieur supprimera les dimensions intérieures, et l'ordre des dimensions correspondra à celles de dims. Si drop = false, alors le Slices aura la même dimensionalité que le tableau sous-jacent, avec des dimensions intérieures de taille 1.

Voir stack(slices; dims) pour l'inverse de eachslice(A; dims::Integer).

Voir aussi eachrow, eachcol, mapslices et selectdim.

Exemples

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)

Renvoie la permutation inverse de v. Si B = A[v], alors A == B[invperm(v)].

Voir aussi sortperm, invpermute!, isperm, permutedims.

Exemples

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

Retourne true si v est une permutation valide.

Exemples

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

Permute le vecteur v sur place, selon la permutation p. Aucune vérification n'est effectuée pour vérifier que p est une permutation.

Pour retourner une nouvelle permutation, utilisez v[p]. Cela est généralement plus rapide que permute!(v, p) ; il est encore plus rapide d'écrire dans un tableau de sortie pré-alloué avec u .= @view v[p]. (Bien que permute! écrase v sur place, il nécessite en interne une certaine allocation pour garder une trace des éléments qui ont été déplacés.)

Voir aussi invpermute!.

Exemples

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)

Comme permute!, mais l'inverse de la permutation donnée est appliqué.

Notez que si vous avez un tableau de sortie préalloué (par exemple u = similar(v)), il est plus rapide d'utiliser u[p] = v. (invpermute! alloue en interne une copie des données.)

Exemples

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=:)

Inverse A le long de la dimension dims, qui peut être un entier (une seule dimension), un tuple d'entiers (un tuple de dimensions) ou : (inverse le long de toutes les dimensions, par défaut). Voir aussi reverse! pour une inversion en place.

Exemples

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)

Étant donné un index i dans reverse(v), renvoie l'index correspondant dans v de sorte que v[reverseind(v,i)] == reverse(v)[i]. (Cela peut être non trivial dans les cas où v contient des caractères non-ASCII.)

Exemples

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

Version en place de reverse.

Exemples

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=:)

Comme reverse, mais fonctionne en place dans A.