Arrays

AbstractArray{T,N}

Supertipo para arreglos de N dimensiones (o tipos similares a arreglos) con elementos del tipo T. Array y otros tipos son subtipos de esto. Consulta la sección del manual sobre la interfaz AbstractArray.

Véase también: AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

Supertipo para arreglos unidimensionales (o tipos similares a arreglos) con elementos del tipo T. Alias para AbstractArray{T,1}.

AbstractMatrix{T}

Supertipo para arreglos bidimensionales (o tipos similares a arreglos) con elementos del tipo T. Alias para AbstractArray{T,2}.

AbstractVecOrMat{T}

Tipo de unión de AbstractVector{T} y AbstractMatrix{T}.

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

Arreglo denso de N dimensiones con elementos del tipo T.

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

Construye un Array no inicializado de N dimensiones que contiene elementos del tipo T. N puede ser proporcionado explícitamente, como en Array{T,N}(undef, dims), o ser determinado por la longitud o el número de dims. dims puede ser una tupla o una serie de argumentos enteros que corresponden a las longitudes en cada dimensión. Si el rango N se proporciona explícitamente, entonces debe coincidir con la longitud o el número de dims. Aquí undef es el UndefInitializer.

Ejemplos

julia> A = Array{Float64, 2}(undef, 2, 3) # N dado explícitamente
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 determinado por la entrada
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # usa typeof(B), y el tamaño dado
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}(nothing, dims)
Array{T,N}(nothing, dims)

Construye un Array de N dimensiones que contenga elementos del tipo T, inicializado con entradas de nothing. El tipo de elemento T debe ser capaz de contener estos valores, es decir, Nothing <: T.

Ejemplos

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

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

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

Construye un Array de N dimensiones que contenga elementos del tipo T, inicializado con entradas de missing. El tipo de elemento T debe ser capaz de contener estos valores, es decir, Missing <: T.

Ejemplos

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

Tipo singleton utilizado en la inicialización de arreglos, indicando que el llamador del constructor de arreglos desea un arreglo no inicializado. Ver también undef, un alias para UndefInitializer().

Ejemplos

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

undef

Alias para UndefInitializer(), que construye una instancia del tipo singleton UndefInitializer, utilizado en la inicialización de arreglos para indicar que el llamador del constructor de arreglos desea un arreglo no inicializado.

Ver también: missing, similar.

Ejemplos

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

Vector{T} <: AbstractVector{T}

Arreglo denso unidimensional con elementos del tipo T, a menudo utilizado para representar un vector matemático. Alias para Array{T,1}.

Véase también empty, similar y zero para crear vectores.

Vector{T}(undef, n)

Construye un Vector{T} no inicializado de longitud n.

Ejemplos

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

Vector{T}(nada, m)

Construye un Vector{T} de longitud m, inicializado con entradas de nada. El tipo de elemento T debe ser capaz de contener estos valores, es decir, Nothing <: T.

Ejemplos

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

Vector{T}(missing, m)

Construye un Vector{T} de longitud m, inicializado con entradas de missing. El tipo de elemento T debe ser capaz de contener estos valores, es decir, Missing <: T.

Ejemplos

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

Matrix{T} <: AbstractMatrix{T}

Arreglo denso bidimensional con elementos del tipo T, a menudo utilizado para representar una matriz matemática. Alias para Array{T,2}.

Véase también fill, zeros, undef y similar para crear matrices.

Matrix{T}(undef, m, n)

Construye un Matrix{T} no inicializado de tamaño m×n.

Ejemplos

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

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

Matrix{T}(nothing, m, n)

Construye una Matrix{T} de tamaño m×n, inicializada con entradas de nothing. El tipo de elemento T debe ser capaz de contener estos valores, es decir, Nothing <: T.

Ejemplos

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

Matrix{T}(missing, m, n)

Construye una Matrix{T} de tamaño m×n, inicializada con entradas de missing. El tipo de elemento T debe ser capaz de contener estos valores, es decir, Missing <: T.

Ejemplos

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

VecOrMat{T}

Tipo de unión de Vector{T} y Matrix{T} que permite que las funciones acepten ya sea una Matriz o un Vector.

Ejemplos

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}

Arreglo denso de N dimensiones con elementos del tipo T. Los elementos de un arreglo denso se almacenan de manera contigua en la memoria.

DenseVector{T}

Arreglo unidimensional DenseArray con elementos del tipo T. Alias para DenseArray{T,1}.

DenseMatrix{T}

Array bidimensional DenseArray con elementos del tipo T. Alias para DenseArray{T,2}.

DenseVecOrMat{T}

Tipo de unión de DenseVector{T} y DenseMatrix{T}.

StridedArray{T, N}

Un Union codificado de tipos de arreglo comunes que siguen la interfaz de arreglo estratificado, con elementos de tipo T y N dimensiones.

Si A es un StridedArray, entonces sus elementos se almacenan en memoria con desplazamientos, que pueden variar entre dimensiones pero son constantes dentro de una dimensión. Por ejemplo, A podría tener un desplazamiento de 2 en la dimensión 1, y un desplazamiento de 3 en la dimensión 2. Incrementar A a lo largo de la dimensión d salta en memoria por [stride(A, d)] espacios. Los arreglos estratificados son particularmente importantes y útiles porque a veces pueden ser pasados directamente como punteros a bibliotecas de lenguajes extranjeros como BLAS.

StridedVector{T}

Arreglo unidimensional StridedArray con elementos del tipo T.

StridedMatrix{T}

Matriz bidimensional StridedArray con elementos del tipo T.

StridedVecOrMat{T}

Tipo de unión de StridedVector y StridedMatrix con elementos de tipo T.

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

Tamaño fijo DenseVector{T}.

kind puede ser actualmente :not_atomic o :atomic. Para detalles sobre lo que implica :atomic, consulta AtomicMemory

addrspace actualmente solo se puede establecer en Core.CPU. Está diseñado para permitir la extensión por otros sistemas como GPUs, que podrían definir valores como:

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

La semántica exacta de estos otros addrspaces está definida por el backend específico, pero generará un error si el usuario intenta acceder a estos en la CPU.

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

Vector denso de tamaño fijo DenseVector{T}.

`memoryref(::GenericMemory)`

Construye un GenericMemoryRef a partir de un objeto de memoria. Esto no falla, pero la memoria resultante apuntará fuera de los límites si y solo si la memoria está vacía.

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

Construye un GenericMemoryRef a partir de un objeto de memoria y un índice de desplazamiento (basado en 1) que también puede ser negativo. Esto siempre devuelve un objeto dentro de los límites, y lanzará un error si eso no es posible (porque el índice resultaría en un desplazamiento fuera de los límites de la memoria subyacente).

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

Un AbstractArray de secciones en un array padre sobre dimensión(es) especificada(s), devolviendo vistas que seleccionan todos los datos de la(s) otra(s) dimensión(es).

Estos deberían ser construidos típicamente por eachslice, eachcol o eachrow.

parent(s::Slices) devolverá el array padre.

RowSlices{M,AX,S}

Un caso especial de Slices que es un vector de secciones de fila de una matriz, tal como se construye con eachrow.

parent se puede usar para obtener la matriz subyacente.

ColumnSlices{M,AX,S}

Un caso especial de Slices que es un vector de rebanadas de columna de una matriz, tal como se construye con eachcol.

parent se puede usar para obtener la matriz subyacente.

getindex(tipo[, elementos...])

Construye un arreglo unidimensional del tipo especificado. Esto se llama generalmente con la sintaxis Tipo[]. Los valores de los elementos se pueden especificar usando Tipo[a,b,c,...].

Ejemplos

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

Crea un Array, con tipo de elemento T, de todos ceros con tamaño especificado por dims. Véase también fill, ones, zero.

Ejemplos

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

Crea un Array, con tipo de elemento T, de todos unos con tamaño especificado por dims. Ver también fill, zeros.

Ejemplos

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}

Arreglo booleano N-dimensional eficiente en espacio, utilizando solo un bit para cada valor booleano.

Los BitArray empaquetan hasta 64 valores en cada 8 bytes, resultando en una eficiencia de espacio de 8x sobre Array{Bool, N} y permitiendo que algunas operaciones trabajen en 64 valores a la vez.

Por defecto, Julia devuelve BitArrays de operaciones de broadcasting que generan elementos booleanos (incluyendo comparaciones con punto como .==) así como de las funciones trues y falses.

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

Construye un BitArray indefinido con las dimensiones dadas. Se comporta de manera idéntica al constructor de Array. Ver undef.

Ejemplos

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)

Construye un BitArray generado por el objeto iterable dado. La forma se infiere del objeto itr.

Ejemplos

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)

Crea un BitArray con todos los valores establecidos en true.

Ejemplos

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

falses(dims)

Crea un BitArray con todos los valores establecidos en false.

Ejemplos

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

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

Crea un arreglo de tamaño dims con cada ubicación establecida en value.

Por ejemplo, fill(1.0, (5,5)) devuelve un arreglo de 5×5 de flotantes, con 1.0 en cada ubicación del arreglo.

Las longitudes de las dimensiones dims pueden especificarse como una tupla o como una secuencia de argumentos. Una tupla de longitud N o N argumentos después de value especifican un arreglo de N dimensiones. Así, un idiom común para crear un arreglo de cero dimensiones con su única ubicación establecida en x es fill(x).

Cada ubicación del arreglo devuelto se establece en (y es por lo tanto === a) el value que se pasó; esto significa que si el value se modifica, todos los elementos del arreglo fillado reflejarán esa modificación porque siguen siendo ese mismo value. Esto no es un problema con fill(1.0, (5,5)) ya que el value 1.0 es inmutable y no puede ser modificado, pero puede ser inesperado con valores mutables como — más comúnmente — arreglos. Por ejemplo, fill([], 3) coloca el mismo arreglo vacío en las tres ubicaciones del vector devuelto:

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]

Para crear un arreglo de muchos arreglos internos independientes, usa una comprensión en su lugar. Esto crea un nuevo y distinto arreglo en cada iteración del bucle:

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

Ver también: fill!, zeros, ones, similar.

Ejemplos

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) # establece ambos elementos en el mismo vector [0.0, 0.0]
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # modifica el valor llenado a ser [42.0, 0.0]

julia> A # tanto A[1] como A[2] son el mismo vector
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

Rellena el arreglo A con el valor x. Si x es una referencia de objeto, todos los elementos harán referencia al mismo objeto. fill!(A, Foo()) devolverá A lleno con el resultado de evaluar Foo() una vez.

Ejemplos

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)

Devuelve una tupla vacía, ().

empty(v::AbstractVector, [eltype])

Crea un vector vacío similar a v, cambiando opcionalmente el eltype.

Véase también: empty!, isempty, isassigned.

Ejemplos

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

Crea un contenedor AbstractDict vacío que puede aceptar índices del tipo index_type y valores del tipo value_type. Los segundo y tercero argumentos son opcionales y por defecto son el keytype y valtype de la entrada, respectivamente. (Si solo se especifica uno de los dos tipos, se asume que es el value_type, y el index_type por defecto será keytype(a)).

Los subtipos personalizados de AbstractDict pueden elegir qué tipo de diccionario específico es el más adecuado para devolver para los tipos de índice y valor dados, especializándose en la firma de tres argumentos. El valor por defecto es devolver un Dict vacío.

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

Crea un arreglo mutable no inicializado con el tipo de elemento, tipo de índice y tamaño dados, basado en la fuente SparseMatrixCSC dada. La nueva matriz dispersa mantiene la estructura de la matriz dispersa original, excepto en el caso en que las dimensiones de la matriz de salida son diferentes de la salida.

La matriz de salida tiene ceros en las mismas ubicaciones que la entrada, pero valores no inicializados para las ubicaciones no nulas.

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

Crea un arreglo mutable no inicializado con el tipo de elemento y tamaño dados, basado en el arreglo fuente proporcionado. Los segundo y tercer argumentos son opcionales, y por defecto son el eltype y size del arreglo dado. Las dimensiones pueden especificarse ya sea como un solo argumento de tupla o como una serie de argumentos enteros.

Los subtipos de AbstractArray personalizados pueden elegir qué tipo de arreglo específico es el más adecuado para devolver según el tipo de elemento y la dimensionalidad dados. Si no especializan este método, el valor por defecto es un Array{element_type}(undef, dims...).

Por ejemplo, similar(1:10, 1, 4) devuelve un Array{Int,2} no inicializado ya que los rangos no son mutables ni soportan 2 dimensiones:

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

Por el contrario, similar(trues(10,10), 2) devuelve un BitVector no inicializado con dos elementos ya que los BitArrays son tanto mutables como pueden soportar arreglos unidimensionales:

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

Sin embargo, dado que los BitArrays solo pueden almacenar elementos del tipo Bool, si solicitas un tipo de elemento diferente, se creará un Array regular en su lugar:

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

Ver también: undef, isassigned.

similar(storagetype, axes)

Crea un arreglo mutable no inicializado análogo al especificado por storagetype, pero con axes especificados por el último argumento.

Ejemplos:

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

crea un arreglo que "actúa como" un Array{Int} (y que de hecho podría estar respaldado por uno), pero que está indexado de manera idéntica a A. Si A tiene indexación convencional, esto será idéntico a Array{Int}(undef, size(A)), pero si A tiene indexación no convencional, entonces los índices del resultado coincidirán con los de A.

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

crearía un arreglo lógico unidimensional cuyos índices coinciden con los de las columnas de A.

ndims(A::AbstractArray) -> Integer

Devuelve el número de dimensiones de A.

Véase también: size, axes.

Ejemplos

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

Devuelve una tupla que contiene las dimensiones de A. Opcionalmente, puedes especificar una dimensión para obtener solo la longitud de esa dimensión.

Ten en cuenta que size puede no estar definido para arreglos con índices no estándar, en cuyo caso axes puede ser útil. Consulta el capítulo del manual sobre arreglos con índices personalizados.

Véase también: length, ndims, eachindex, sizeof.

Ejemplos

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

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

julia> size(A, 2)
3

axes(A)

Devuelve la tupla de índices válidos para el arreglo A.

Véase también: size, keys, eachindex.

Ejemplos

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

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

axes(A, d)

Devuelve el rango válido de índices para el arreglo A a lo largo de la dimensión d.

Véase también size, y el capítulo del manual sobre arreglos con índices personalizados.

Ejemplos

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

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

julia> axes(A, 4) == 1:1  # todas las dimensiones d > ndims(A) tienen tamaño 1
true

Nota de uso

Cada uno de los índices tiene que ser un AbstractUnitRange{<:Integer}, pero al mismo tiempo puede ser un tipo que use índices personalizados. Así que, por ejemplo, si necesitas un subconjunto, utiliza construcciones de indexación generalizadas como begin/end o firstindex/lastindex:

ix = axes(v, 1)
ix[2:end]          # funcionará para por ejemplo Vector, pero puede fallar en general
ix[(begin+1):end]  # funciona para índices generalizados

length(A::AbstractArray)

Devuelve el número de elementos en el array, por defecto es prod(size(A)).

Ejemplos

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

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

keys(a::AbstractArray)

Devuelve un array eficiente que describe todos los índices válidos para a dispuestos en la forma de a misma.

Las claves de los arrays unidimensionales (vectores) son enteros, mientras que todos los demás arrays N-dimensionales utilizan CartesianIndex para describir sus ubicaciones. A menudo, los tipos de array especiales LinearIndices y CartesianIndices se utilizan para representar de manera eficiente estos arrays de enteros y CartesianIndexes, respectivamente.

Ten en cuenta que las keys de un array pueden no ser el tipo de índice más eficiente; para un rendimiento máximo utiliza eachindex en su lugar.

Ejemplos

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

Crea un objeto iterable para visitar cada índice de un AbstractArray A de manera eficiente. Para los tipos de arreglo que han optado por la indexación lineal rápida (como Array), esto es simplemente el rango 1:length(A) si utilizan indexación basada en 1. Para los tipos de arreglo que no han optado por la indexación lineal rápida, generalmente se devuelve un rango cartesiano especializado para indexar eficientemente en el arreglo con índices especificados para cada dimensión.

En general, eachindex acepta iterables arbitrarios, incluidos cadenas y diccionarios, y devuelve un objeto iterador que admite tipos de índice arbitrarios (por ejemplo, índices desiguales o índices no enteros).

Si A es AbstractArray, es posible especificar explícitamente el estilo de los índices que deben ser devueltos por eachindex pasando un valor de tipo IndexStyle como su primer argumento (típicamente IndexLinear() si se requieren índices lineales o IndexCartesian() si se desea un rango cartesiano).

Si proporcionas más de un argumento AbstractArray, eachindex creará un objeto iterable que es rápido para todos los argumentos (típicamente un UnitRange si todas las entradas tienen indexación lineal rápida, un CartesianIndices de lo contrario). Si los arreglos tienen diferentes tamaños y/o dimensionalidades, se lanzará una excepción DimensionMismatch.

Consulta también pairs(A) para iterar sobre índices y valores juntos, y axes(A, 2) para índices válidos a lo largo de una dimensión.

Ejemplos

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

julia> for i in eachindex(A) # indexación lineal
           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)) # indexación cartesiana
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle especifica el "estilo de indexación nativo" para el arreglo A. Cuando defines un nuevo tipo de AbstractArray, puedes elegir implementar ya sea indexación lineal (con IndexLinear) o indexación cartesiana. Si decides implementar solo la indexación lineal, entonces debes establecer este rasgo para tu tipo de arreglo:

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

El valor predeterminado es IndexCartesian().

La maquinaria de indexación interna de Julia recomputará automáticamente (e invisiblemente) todas las operaciones de indexación en el estilo preferido. Esto permite a los usuarios acceder a los elementos de tu arreglo utilizando cualquier estilo de indexación, incluso cuando no se han proporcionado métodos explícitos.

Si defines ambos estilos de indexación para tu AbstractArray, este rasgo puede ser utilizado para seleccionar el estilo de indexación más eficiente. Algunos métodos verifican este rasgo en sus entradas y despachan a diferentes algoritmos dependiendo del patrón de acceso más eficiente. En particular, eachindex crea un iterador cuyo tipo depende de la configuración de este rasgo.

IndexLinear()

Subtipo de IndexStyle utilizado para describir arreglos que son indexados de manera óptima por un índice lineal.

Un estilo de indexación lineal utiliza un índice entero para describir la posición en el arreglo (incluso si es un arreglo multidimensional) y se utiliza un ordenamiento por columnas para acceder eficientemente a los elementos. Esto significa que solicitar eachindex de un arreglo que es IndexLinear devolverá un rango unidimensional simple, incluso si es multidimensional.

Un arreglo personalizado que reporta su IndexStyle como IndexLinear solo necesita implementar la indexación (y la asignación indexada) con un único índice Int; todas las demás expresiones de indexación —incluyendo accesos multidimensionales— se recalcularán al índice lineal. Por ejemplo, si A fuera una matriz personalizada de 2×3 con indexación lineal, y referenciáramos A[1, 3], esto se recalcularía al índice lineal equivalente y llamaría a A[5] ya que 1 + 2*(3 - 1) = 5.

Ver también IndexCartesian.

IndexCartesian()

Subtipo de IndexStyle utilizado para describir arreglos que son indexados de manera óptima por un índice cartesiano. Este es el valor predeterminado para nuevos subtipos de AbstractArray personalizados.

Un estilo de indexación cartesiana utiliza múltiples índices enteros para describir la posición en un arreglo multidimensional, con exactamente un índice por dimensión. Esto significa que solicitar eachindex de un arreglo que es IndexCartesian devolverá un rango de CartesianIndices.

Un arreglo personalizado de N dimensiones que reporta su IndexStyle como IndexCartesian necesita implementar la indexación (y la asignación indexada) con exactamente N índices Int; todas las demás expresiones de indexación —incluida la indexación lineal— se recalcularán a la ubicación cartesiana equivalente. Por ejemplo, si A fuera una matriz personalizada de 2×3 con indexación cartesiana, y referenciáramos A[5], esto se recalcularía al índice cartesiano equivalente y llamaría a A[1, 3] ya que 5 = 1 + 2*(3 - 1).

Es significativamente más costoso calcular índices cartesianos a partir de un índice lineal que hacerlo en la otra dirección. La primera operación requiere división —una operación muy costosa— mientras que la última solo utiliza multiplicación y adición y es esencialmente gratuita. Esta asimetría significa que es mucho más costoso usar indexación lineal con un arreglo IndexCartesian que usar indexación cartesiana con un arreglo IndexLinear.

Ver también IndexLinear.

conj!(A)

Transforma un arreglo a su conjugado complejo en su lugar.

Ver también conj.

Ejemplos

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)

Devuelve la distancia en memoria (en número de elementos) entre elementos adyacentes en la dimensión k.

Véase también: strides.

Ejemplos

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

Devuelve una tupla de los pasos de memoria en cada dimensión.

Véase también: stride.

Ejemplos

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

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

broadcast(f, As...)

Difunde la función f sobre los arreglos, tuplas, colecciones, Refs y/o escalares As.

La difusión aplica la función f sobre los elementos de los argumentos contenedores y los escalares mismos en As. Las dimensiones singleton y faltantes se expanden para coincidir con las extensiones de los otros argumentos repitiendo virtualmente el valor. Por defecto, solo se consideran un número limitado de tipos como escalares, incluyendo Numbers, Strings, Symbols, Types, Functions y algunos singleton comunes como missing y nothing. Todos los demás argumentos se iteran o se indexan de manera elementwise.

El tipo de contenedor resultante se establece mediante las siguientes reglas:

• Si todos los argumentos son escalares o arreglos de cero dimensiones, devuelve un escalar sin envolver.
• Si al menos un argumento es una tupla y todos los demás son escalares o arreglos de cero dimensiones, devuelve una tupla.
• Todas las demás combinaciones de argumentos por defecto devuelven un Array, pero los tipos de contenedores personalizados pueden definir su propia implementación y reglas de promoción para personalizar el resultado cuando aparecen como argumentos.

Existe una sintaxis especial para la difusión: f.(args...) es equivalente a broadcast(f, args...), y las llamadas anidadas f.(g.(args...)) se fusionan en un solo bucle de difusión.

Ejemplos

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

Como broadcast, pero almacena el resultado de broadcast(f, As...) en el array dest. Ten en cuenta que dest solo se utiliza para almacenar el resultado y no proporciona argumentos a f a menos que también esté listado en los As, como en broadcast!(f, A, A, B) para realizar A[:] = broadcast(f, A, B).

Ejemplos

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

Convierte cada llamada a función u operador en expr en una "llamada con punto" (por ejemplo, convierte f(x) en f.(x)), y convierte cada asignación en expr en una "asignación con punto" (por ejemplo, convierte += en .+=).

Si deseas evitar agregar puntos para llamadas a funciones seleccionadas en expr, inserta esas llamadas a funciones con $. Por ejemplo, @. sqrt(abs($sort(x))) es equivalente a sqrt.(abs.(sort(x))) (sin punto para sort).

(@. es equivalente a una llamada a @__dot__.)

Ejemplos

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 es un tipo abstracto y una función rasgo utilizada para determinar el comportamiento de los objetos bajo la difusión. BroadcastStyle(typeof(x)) devuelve el estilo asociado con x. Para personalizar el comportamiento de difusión de un tipo, se puede declarar un estilo definiendo un par de tipo/método

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

Uno luego escribe método(s) (al menos similar) que operan en Broadcasted{MyContainerStyle}. También hay varios subtipos predefinidos de BroadcastStyle que puede que puedas aprovechar; consulta el capítulo de Interfaces para más información.

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle es el supertipo abstracto para cualquier estilo asociado con un tipo AbstractArray. El parámetro N es la dimensionalidad, que puede ser útil para tipos de AbstractArray que solo admiten dimensionalidades específicas:

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

Para tipos AbstractArray que admiten dimensionalidad arbitraria, N se puede establecer en Any:

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

En casos donde desees poder mezclar múltiples AbstractArrayStyles y hacer un seguimiento de la dimensionalidad, tu estilo necesita admitir un constructor Val:

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

Ten en cuenta que si dos o más subtipos de AbstractArrayStyle entran en conflicto, la maquinaria de broadcasting volverá a producir Arrays. Si esto no es deseable, es posible que necesites definir reglas binarias BroadcastStyle para controlar el tipo de salida.

Consulta también Broadcast.DefaultArrayStyle.

Broadcast.ArrayStyle{MyArrayType}() es un BroadcastStyle que indica que un objeto se comporta como un array para la transmisión. Presenta una forma simple de construir Broadcast.AbstractArrayStyles para tipos de contenedores AbstractArray específicos. Los estilos de transmisión creados de esta manera pierden el seguimiento de la dimensionalidad; si mantener el seguimiento es importante para tu tipo, deberías crear tu propio Broadcast.AbstractArrayStyle.

Broadcast.DefaultArrayStyle{N}() es un BroadcastStyle que indica que un objeto se comporta como un arreglo de N dimensiones para la difusión. Específicamente, DefaultArrayStyle se utiliza para cualquier tipo de AbstractArray que no ha definido un estilo especializado, y en ausencia de sobrecargas de otros argumentos de broadcast, el tipo de salida resultante es Array. Cuando hay múltiples entradas para broadcast, DefaultArrayStyle "pierde" ante cualquier otro Broadcast.ArrayStyle.

Broadcast.broadcastable(x)

Devuelve x o un objeto como x de tal manera que soporte axes, indexación, y su tipo soporte ndims.

Si x soporta iteración, el valor devuelto debe tener los mismos comportamientos de axes e indexación que collect(x).

Si x no es un AbstractArray pero soporta axes, indexación, y su tipo soporta ndims, entonces broadcastable(::typeof(x)) puede ser implementado para simplemente devolverse a sí mismo. Además, si x define su propio BroadcastStyle, entonces debe definir su método broadcastable para devolverse a sí mismo para que el estilo personalizado tenga algún efecto.

Ejemplos

julia> Broadcast.broadcastable([1,2,3]) # como `identity` ya que los arreglos ya soportan ejes e indexación
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Los tipos no soportan ejes, indexación, o iteración pero se utilizan comúnmente como escalares
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # Las cadenas rompen la convención de coincidencia de iteración y actúan como un escalar en su lugar
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

Determina los ejes resultantes para la difusión a través de todos los valores en 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

Decide qué BroadcastStyle usar para cualquier número de argumentos de valor. Utiliza BroadcastStyle para obtener el estilo de cada argumento y usa result_style para combinar estilos.

Ejemplos

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

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

Toma uno o dos BroadcastStyles y los combina usando BroadcastStyle para determinar un BroadcastStyle común.

Ejemplos

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

Devuelve un subconjunto del arreglo A según lo seleccionado por los índices inds.

Cada índice puede ser de cualquier tipo de índice soportado, como un Integer, CartesianIndex, rango, o arreglo de índices soportados. Un : puede ser utilizado para seleccionar todos los elementos a lo largo de una dimensión específica, y un arreglo booleano (por ejemplo, un Array{Bool} o un BitArray) puede ser utilizado para filtrar elementos donde el índice correspondiente es true.

Cuando inds selecciona múltiples elementos, esta función devuelve un arreglo recién asignado. Para indexar múltiples elementos sin hacer una copia, utiliza view en su lugar.

Consulta la sección del manual sobre indexación de arreglos para más detalles.

Ejemplos

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

Almacena valores del arreglo X dentro de un subconjunto de A según lo especificado por inds. La sintaxis A[inds...] = X es equivalente a (setindex!(A, X, inds...); X).

Ejemplos

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)

Devuelve el índice después de i en A. El índice devuelto a menudo es equivalente a i + 1 para un entero i. Esta función puede ser útil para código genérico.

Véase también: prevind.

Ejemplos

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

julia> nextind(x, 1) # resultado válido
2

julia> nextind(x, 4) # resultado inválido
5

julia> nextind(x, CartesianIndex(1, 1)) # resultado válido
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # resultado inválido
CartesianIndex(1, 3)

prevind(A, i)

Devuelve el índice antes de i en A. El índice devuelto a menudo es equivalente a i - 1 para un entero i. Esta función puede ser útil para código genérico.

Véase también: nextind.

Ejemplos

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

julia> prevind(x, 4) # resultado válido
3

julia> prevind(x, 1) # resultado inválido
0

julia> prevind(x, CartesianIndex(2, 2)) # resultado válido
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # resultado inválido
CartesianIndex(2, 0)

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

Copia el bloque de src en el rango de Rsrc al bloque de dest en el rango de Rdest. Los tamaños de las dos regiones deben coincidir.

Ejemplos

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

Copia en su lugar copy de src a dst, descartando cualquier elemento preexistente en dst. Si dst y src son del mismo tipo, dst == src debería ser cierto después de la llamada. Si dst y src son arreglos multidimensionales, deben tener los mismos axes.

Véase también copyto!.

isassigned(array, i) -> Bool

Prueba si el array dado tiene un valor asociado con el índice i. Devuelve false si el índice está fuera de límites, o tiene una referencia indefinida.

Ejemplos

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

Los dos puntos (:) se utilizan para significar la indexación de objetos o dimensiones enteras a la vez.

Muy pocas operaciones están definidas directamente sobre los dos puntos; en su lugar, se convierten mediante to_indices a un tipo de vector interno (Base.Slice) para representar la colección de índices que abarcan antes de ser utilizados.

La instancia singleton de Colon también es una función utilizada para construir rangos; consulta :.

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

Crea un índice multidimensional I, que se puede usar para indexar un arreglo multidimensional A. En particular, A[I] es equivalente a A[i,j,k...]. Se pueden mezclar libremente índices enteros y CartesianIndex; por ejemplo, A[Ipre, i, Ipost] (donde Ipre y Ipost son índices CartesianIndex y i es un Int) puede ser una expresión útil al escribir algoritmos que funcionan a lo largo de una sola dimensión de un arreglo de dimensionalidad arbitraria.

Un CartesianIndex a veces es producido por eachindex, y siempre cuando se itera con un CartesianIndices explícito.

Un I::CartesianIndex se trata como un "escalar" (no un contenedor) para broadcast. Para iterar sobre los componentes de un CartesianIndex, conviértelo en una tupla con Tuple(I).

Ejemplos

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

Define una región R que abarca un rango rectangular multidimensional de índices enteros. Estos se encuentran más comúnmente en el contexto de la iteración, donde for I in R ... end devolverá índices I equivalentes a los bucles anidados de CartesianIndex

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

En consecuencia, estos pueden ser útiles para escribir algoritmos que funcionen en dimensiones arbitrarias.

CartesianIndices(A::AbstractArray) -> R

Como conveniencia, construir un CartesianIndices a partir de un array crea un rango de sus índices.

Ejemplos

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

Conversión entre índices lineales y cartesianas

La conversión de índice lineal a índice cartesiano explota el hecho de que un CartesianIndices es un AbstractArray y se puede indexar linealmente:

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)

Difusión

CartesianIndices soporta la aritmética de difusión (+ y -) con 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))

Para la conversión de cartesian a índice lineal, consulta LinearIndices. ```

Dims{N}

Un NTuple de N Ints utilizado para representar las dimensiones de un AbstractArray.

LinearIndices(A::AbstractArray)

Devuelve un array LinearIndices con la misma forma y axes que A, conteniendo el índice lineal de cada entrada en A. Indexar este array con índices cartesianos permite mapearlos a índices lineales.

Para arrays con indexación convencional (los índices comienzan en 1), o cualquier array multidimensional, los índices lineales varían de 1 a length(A). Sin embargo, para AbstractVectors, los índices lineales son axes(A, 1), y por lo tanto no comienzan en 1 para vectores con indexación no convencional.

Llamar a esta función es la forma "segura" de escribir algoritmos que explotan la indexación lineal.

Ejemplos

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

Devuelve un array LinearIndices con la forma especificada o axes.

Ejemplos

El propósito principal de este constructor es la conversión intuitiva de la indexación cartesiana a la indexación lineal:

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)

Convierte la tupla I en una tupla de índices para su uso en la indexación del arreglo A.

La tupla devuelta debe contener solo Ints o AbstractArrays de índices escalares que son compatibles con el arreglo A. Generará un error al encontrar un tipo de índice novedoso que no sabe cómo procesar.

Para tipos de índice simples, se delega a la función no exportada Base.to_index(A, i) para procesar cada índice i. Aunque esta función interna no está destinada a ser llamada directamente, Base.to_index puede ser extendida por tipos de arreglo o índice personalizados para proporcionar comportamientos de indexación personalizados.

Los tipos de índice más complicados pueden requerir más contexto sobre la dimensión en la que indexan. Para apoyar esos casos, to_indices(A, I) llama a to_indices(A, axes(A), I), que luego recorre recursivamente tanto la tupla dada de índices como los índices dimensionales de A en conjunto. Como tal, no se garantiza que todos los tipos de índice se propaguen a Base.to_index.

Ejemplos

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)) # sin verificación de límites
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # índice exótico
(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)) # sin verificación de forma
(1, 2)

checkbounds(Bool, A, I...)

Devuelve true si los índices especificados I están dentro de los límites para el array dado A. Los subtipos de AbstractArray deben especializar este método si necesitan proporcionar comportamientos personalizados de verificación de límites; sin embargo, en muchos casos se puede confiar en los índices de A y en checkindex.

Véase también checkindex.

Ejemplos

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

Lanza un error si los índices especificados I no están dentro de los límites para el arreglo dado A.

checkindex(Bool, inds::AbstractUnitRange, index)

Devuelve true si el index dado está dentro de los límites de inds. Los tipos personalizados que deseen comportarse como índices para todos los arreglos pueden extender este método para proporcionar una implementación de verificación de límites especializada.

Ver también checkbounds.

Ejemplos

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

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

elsize(tipo)

Calcula el paso de memoria en bytes entre elementos consecutivos de eltype almacenados dentro del tipo dado, si los elementos del arreglo se almacenan de manera densa con un paso lineal uniforme.

Ejemplos

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

view(A, inds...)

Como getindex, pero devuelve un array ligero que referencia de manera perezosa (o es efectivamente una vista de) el array padre A en el índice o índices dados inds en lugar de extraer elementos de manera ansiosa o construir un subconjunto copiado. Llamar a getindex o setindex! en el valor devuelto (a menudo un SubArray) calcula los índices para acceder o modificar el array padre sobre la marcha. El comportamiento es indefinido si la forma del array padre cambia después de que se llama a view porque no hay verificación de límites para el array padre; por ejemplo, puede causar un fallo de segmentación.

Algunos arrays padres inmutables (como los rangos) pueden optar por simplemente recomputar un nuevo array en algunas circunstancias en lugar de devolver un SubArray si hacerlo es eficiente y proporciona semánticas compatibles.

Ejemplos

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) con el tipo eltype Int64:
 1
 3

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

julia> A # Nota que A ha cambiado aunque modificamos b
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # devuelve un rango ya que el tipo es inmutable
3:4

@view A[inds...]

Transforma la expresión de indexación A[inds...] en la llamada equivalente a view.

Esto solo se puede aplicar directamente a una única expresión de indexación y es particularmente útil para expresiones que incluyen las sintaxis de indexación especiales begin o end como A[begin, 2:end-1] (ya que no son compatibles con la función normal view).

Ten en cuenta que @view no se puede usar como el objetivo de una asignación regular (por ejemplo, @view(A[1, 2:end]) = ...), ni la asignación indexada sin decorar (A[1, 2:end] = ...) o la asignación indexada transmitida (A[1, 2:end] .= ...) harían una copia. Sin embargo, puede ser útil para actualizar asignaciones transmitidas como @view(A[1, 2:end]) .+= 1 porque esta es una sintaxis simple para @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1, y la expresión de indexación en el lado derecho de lo contrario haría una copia sin el @view.

Consulta también @views para cambiar un bloque completo de código para usar vistas para indexación no escalar.

Ejemplos

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 expresión

Convierte cada operación de corte de matriz en la expresión dada (que puede ser un bloque begin/end, un bucle, una función, etc.) para que devuelva una vista. Los índices escalares, los tipos no de matriz y las llamadas explícitas a getindex (en lugar de array[...]) no se ven afectados.

De manera similar, @views convierte los cortes de cadenas en vistas de SubString.

Ejemplos

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b es una vista, no una copia
           b .= row      # asigna cada elemento al índice de fila
       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)

Devuelve el objeto padre subyacente de la vista. Este padre de objetos de tipos SubArray, SubString, ReshapedArray o LinearAlgebra.Transpose es lo que se pasó como argumento a view, reshape, transpose, etc. durante la creación del objeto. Si la entrada no es un objeto envuelto, devuelve la entrada misma. Si la entrada está envuelta múltiples veces, solo se eliminará el envoltorio más externo.

Ejemplos

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

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

parentindices(A)

Devuelve los índices en el parent que corresponden a la vista A.

Ejemplos

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

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

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

selectdim(A, d::Integer, i)

Devuelve una vista de todos los datos de A donde el índice para la dimensión d es igual a i.

Equivalente a view(A,:,:,...,i,:,:,...) donde i está en la posición d.

Véase también: eachslice.

Ejemplos

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)

Cambia la interpretación de tipo de los datos binarios en el valor isbits x al tipo isbits Out. El tamaño (ignorando el relleno) de Out tiene que ser el mismo que el del tipo de x. Por ejemplo, reinterpret(Float32, UInt32(7)) interpreta los 4 bytes correspondientes a UInt32(7) como un Float32. Ten en cuenta 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)

Construye una vista del arreglo con los mismos datos binarios que el arreglo dado, pero con T como tipo de elemento.

Esta función también funciona en arreglos "perezosos" cuyos elementos no se calculan hasta que se recuperan explícitamente. Por ejemplo, reinterpret en el rango 1:6 funciona de manera similar al vector denso 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 la ubicación de los bits de relleno no se alinea entre T y eltype(A), el arreglo resultante será de solo lectura o solo escritura, para evitar que se escriban o lean bits inválidos, respectivamente.

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

julia> a[1] = 3
ERROR: El relleno del tipo Tuple{UInt8, UInt32} no es compatible con el tipo UInt32.

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

julia> b[1]
ERROR: El relleno del tipo UInt32 no es compatible con el tipo Tuple{UInt8, UInt32}.

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

Cambia la interpretación de tipo de A mientras consume o añade una "dimensión de canal".

Si sizeof(T) = n*sizeof(S) para n>1, la primera dimensión de A debe ser de tamaño n y B carece de la primera dimensión de A. Por el contrario, si sizeof(S) = n*sizeof(T) para n>1, B obtiene una nueva primera dimensión de tamaño n. La dimensionalidad no cambia si sizeof(T) == sizeof(S).

Ejemplos

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

julia> reinterpret(reshape, Complex{Int}, A)    # el resultado es un vector
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)             # el resultado es una matriz
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

Devuelve un array con los mismos datos que A, pero con diferentes tamaños de dimensión o número de dimensiones. Los dos arrays comparten los mismos datos subyacentes, de modo que el resultado es mutable si y solo si A es mutable, y establecer elementos de uno altera los valores del otro.

Las nuevas dimensiones pueden especificarse ya sea como una lista de argumentos o como una tupla de forma. Como máximo, se puede especificar una dimensión con un :, en cuyo caso su longitud se calcula de tal manera que su producto con todas las dimensiones especificadas sea igual a la longitud del array original A. El número total de elementos no debe cambiar.

Ejemplos

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)

Devuelve un array con los mismos datos que A, pero con las dimensiones especificadas por dims eliminadas. size(A,d) debe ser igual a 1 para cada d en dims, y se prohíben dimensiones repetidas o números fuera de 1:ndims(A).

El resultado comparte los mismos datos subyacentes que A, de modo que el resultado es mutable si y solo si A es mutable, y establecer elementos de uno altera los valores del otro.

Véase también: reshape, vec.

Ejemplos

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

Reorganiza el arreglo a como un vector columna unidimensional. Devuelve a si ya es un AbstractVector. El arreglo resultante comparte los mismos datos subyacentes que a, por lo que solo será mutable si a es mutable, en cuyo caso modificar uno también modificará al otro.

Ejemplos

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

Ver también reshape, dropdims.

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

Vista N-dimensional en un array padre (de tipo P) con un tipo de elemento T, restringida por una tupla de índices (de tipo I). L es verdadero para tipos que soportan indexación lineal rápida, y falso en caso contrario.

Construya SubArrays utilizando la función view.

cat(A...; dims)

Concatena los arreglos de entrada a lo largo de las dimensiones especificadas en dims.

A lo largo de una dimensión d in dims, el tamaño del arreglo de salida es sum(size(a,d) for a in A). A lo largo de otras dimensiones, todos los arreglos de entrada deben tener el mismo tamaño, que también será el tamaño del arreglo de salida a lo largo de esas dimensiones.

Si dims es un solo número, los diferentes arreglos están empaquetados de manera compacta a lo largo de esa dimensión. Si dims es un iterable que contiene varias dimensiones, las posiciones a lo largo de estas dimensiones se incrementan simultáneamente para cada arreglo de entrada, llenando con ceros en otros lugares. Esto permite construir matrices diagonales por bloques como cat(matrices...; dims=(1,2)), y sus análogos de mayor dimensión.

El caso especial dims=1 es vcat, y dims=2 es hcat. Ver también hvcat, hvncat, stack, repeat.

La palabra clave también acepta Val(dims).

Ejemplos

Concatena dos arreglos en diferentes dimensiones:

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

Ayuda Extendida

Concatena arreglos 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

Concatena arreglos de diferentes tamaños:

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

Construye una matriz diagonal por bloques:

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

Concatena arreglos o números verticalmente. Equivalente a cat(A...; dims=1), y a la sintaxis [a; b; c].

Para concatenar un gran vector de arreglos, reduce(vcat, A) llama a un método eficiente cuando A isa AbstractVector{<:AbstractVecOrMat}, en lugar de trabajar de manera par.

Véase también hcat, Iterators.flatten, stack.

Ejemplos

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

julia> v == vcat(1, 2, [3,4])  # acepta números
true

julia> v == [1; 2; [3,4]]  # sintaxis para la misma operación
true

julia> summary(ComplexF64[1; 2; [3,4]])  # sintaxis para suministrar el tipo de elemento
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # recoge rangos perezosos
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # vector fila y una matriz
([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)  # más eficiente que vcat(vs...)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

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

hcat(A...)

Concatena arreglos o números horizontalmente. Equivalente a cat(A...; dims=2), y a la sintaxis [a b c] o [a;; b;; c].

Para un vector grande de arreglos, reduce(hcat, A) llama a un método eficiente cuando A isa AbstractVector{<:AbstractVecOrMat}. Para un vector de vectores, esto también se puede escribir como stack(A).

Véase también vcat, hvcat.

Ejemplos

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]')  # acepta números
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # sintaxis para la misma operación
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # sintaxis para suministrar el eltype
1×7 Matrix{Float32}:
 1.0  2.0  30.0  40.0  5.0  6.0  7.0

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

julia> reduce(hcat, ms)  # más eficiente 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  # no concuerda en un vector de matrices
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # vectores vacíos, cada uno de tamaño (0,)
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # hcat con matriz 2×0 vacía
2×1 Matrix{Any}:
 1.1
 9.9

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

Concatenación horizontal y vertical en una sola llamada. Esta función se llama para la sintaxis de matrices en bloques. El primer argumento especifica el número de argumentos a concatenar en cada fila de bloques. Si el primer argumento es un solo entero n, entonces se asume que todas las filas de bloques tienen n columnas de bloques.

Ejemplos

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

Concatenación horizontal, vertical y n-dimensional de muchos values en una sola llamada.

Esta función se llama para la sintaxis de matrices de bloques. El primer argumento especifica la forma de la concatenación, similar a hvcat, como una tupla de tuplas, o las dimensiones que especifican el número clave de elementos a lo largo de cada eje, y se utiliza para determinar las dimensiones de salida. La forma dims es más eficiente y se utiliza por defecto cuando la operación de concatenación tiene el mismo número de elementos a lo largo de cada eje (por ejemplo, [a b; c d;;; e f ; g h]). La forma shape se utiliza cuando el número de elementos a lo largo de cada eje es desigual (por ejemplo, [a b ; c]). La sintaxis desigual necesita una sobrecarga de validación adicional. La forma dim es una optimización para la concatenación a lo largo de solo una dimensión. row_first indica cómo se ordenan los values. El significado de los primeros y segundos elementos de shape también se intercambia según row_first.

Ejemplos

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

Ejemplos para la construcción de los argumentos

[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 = elementos en cada fila (2, 1, 1)
 _______     _
 3           1 = elementos en cada columna (3, 1)
 _____________
 4             = elementos en cada corte 3d (4,)
 _____________
 4             = elementos en cada corte 4d (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) con `row_first` = true

stack(iter; [dims])

Combina una colección de arreglos (u otros objetos iterables) de igual tamaño en un solo arreglo más grande, organizándolos a lo largo de una o más nuevas dimensiones.

Por defecto, los ejes de los elementos se colocan primero, dando size(result) = (size(first(iter))..., size(iter)...). Esto tiene el mismo orden de elementos que Iterators.flatten(iter).

Con la palabra clave dims::Integer, en su lugar, el elemento i de iter se convierte en el corte selectdim(result, dims, i), de modo que size(result, dims) == length(iter). En este caso, stack revierte la acción de eachslice con los mismos dims.

Las diversas funciones cat también combinan arreglos. Sin embargo, todas estas extienden las dimensiones existentes (posiblemente triviales) de los arreglos, en lugar de colocar los arreglos a lo largo de nuevas dimensiones. También aceptan arreglos como argumentos separados, en lugar de una sola colección.

Ejemplos

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))  # acepta cualquier iterador de iteradores
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)  # a diferencia de cualquier función cat, el 1er eje de vecs[1] es el 2do eje del resultado
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)  # inverso de eachslice
true

Ejemplos de dimensiones superiores:

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

julia> E = eachslice(A, dims=2);  # un vector 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  # mantiene todas las dimensiones
(2, 3, 5, 7)

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

julia> hvcat(5, M...) |> size  # hvcat coloca matrices una al lado de la otra
(14, 15)

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

Aplica una función a cada elemento de una colección y apila el resultado. O a varias colecciones, que se han zippeado juntas.

La función debe devolver arreglos (o tuplas, o otros iteradores) todos del mismo tamaño. Estos se convierten en secciones del resultado, cada una separada a lo largo de dims (si se proporciona) o por defecto a lo largo de las últimas dimensiones.

Véase también mapslices, eachcol.

Ejemplos

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

Crea un Vector con el tipo de elemento calculado a partir del promote_typeof del argumento, que contiene la lista de argumentos.

Ejemplos

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

circshift(A, shifts)

Desplaza circularmente, es decir, rota, los datos en un arreglo. El segundo argumento es una tupla o vector que indica la cantidad a desplazar en cada dimensión, o un entero para desplazar solo en la primera dimensión.

Véase también: circshift!, circcopy!, bitrotate, <<.

Ejemplos

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)

Desplaza circularmente, es decir, rota, los datos en src, almacenando el resultado en dest. shifts especifica la cantidad a desplazar en cada dimensión.

Véase también circshift.

circcopy!(dest, src)

Copia src a dest, indexando cada dimensión módulo su longitud. src y dest deben tener el mismo tamaño, pero pueden estar desplazados en sus índices; cualquier desplazamiento resulta en un envolvimiento (circular). Si los arreglos tienen índices superpuestos, entonces en el dominio de la superposición dest coincide con src.

Véase también: circshift.

Ejemplos

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)

Devuelve un vector I de los índices o claves true de A. Si no hay tales elementos en A, devuelve un array vacío. Para buscar otros tipos de valores, pasa un predicado como el primer argumento.

Los índices o claves son del mismo tipo que los devueltos por keys(A) y pairs(A).

Véase también: findfirst, searchsorted.

Ejemplos

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)

Devuelve un vector I de los índices o claves de A donde f(A[I]) devuelve true. Si no hay tales elementos en A, devuelve un array vacío.

Los índices o claves son del mismo tipo que los devueltos por keys(A) y pairs(A).

Ejemplos

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)

Devuelve el índice o clave del primer valor true en A. Devuelve nothing si no se encuentra tal valor. Para buscar otros tipos de valores, pasa un predicado como el primer argumento.

Los índices o claves son del mismo tipo que los devueltos por keys(A) y pairs(A).

Véase también: findall, findnext, findlast, searchsortedfirst.

Ejemplos

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # devuelve nothing, pero no se imprime en el 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)

Devuelve el índice o clave del primer elemento de A para el cual predicate devuelve true. Devuelve nothing si no hay tal elemento.

Los índices o claves son del mismo tipo que los devueltos por keys(A) y pairs(A).

Ejemplos

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) # devuelve nothing, pero no se imprime en el 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)

Devuelve el índice o clave del último valor true en A. Devuelve nothing si no hay un valor true en A.

Los índices o claves son del mismo tipo que los devueltos por keys(A) y pairs(A).

Véase también: findfirst, findprev, findall.

Ejemplos

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) # devuelve nothing, pero no se imprime en el 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)

Devuelve el índice o clave del último elemento de A para el cual predicate devuelve true. Devuelve nothing si no hay tal elemento.

Los índices o claves son del mismo tipo que los devueltos por keys(A) y pairs(A).

Ejemplos

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) # devuelve nothing, pero no se imprime en el 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)

Encuentra el siguiente índice después o incluyendo i de un elemento true de A, o nothing si no se encuentra.

Los índices son del mismo tipo que los devueltos por keys(A) y pairs(A).

Ejemplos

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

julia> findnext(A, 1)
3

julia> findnext(A, 4) # devuelve nothing, pero no se imprime en el 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)

Encuentra el siguiente índice después o incluyendo i de un elemento de A para el cual predicate devuelve true, o nothing si no se encuentra. Esto funciona para Arrays, Cadenas, y la mayoría de otras colecciones que soportan getindex, keys(A), y nextind.

Los índices son del mismo tipo que los devueltos por keys(A) y pairs(A).

Ejemplos

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # devuelve nothing, pero no se imprime en el 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)

Encuentra el índice anterior antes o incluyendo i de un elemento true de A, o nothing si no se encuentra.

Los índices son del mismo tipo que los devueltos por keys(A) y pairs(A).

Véase también: findnext, findfirst, findall.

Ejemplos

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

julia> findprev(A, 3)
3

julia> findprev(A, 1) # devuelve nothing, pero no se imprime en el 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)

Encuentra el índice anterior antes o incluyendo i de un elemento de A para el cual predicate devuelve true, o nothing si no se encuentra. Esto funciona para Arrays, Cadenas y la mayoría de otras colecciones que soportan getindex, keys(A), y nextind.

Los índices son del mismo tipo que los devueltos por keys(A) y pairs(A).

Ejemplos

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

julia> findprev(isodd, A, 1) # devuelve nothing, pero no se imprime en el 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)

Permuta las dimensiones (ejes) del arreglo A. perm es una tupla o vector de ndims(A) enteros que especifican la permutación.

Si A es un arreglo 2d (AbstractMatrix), entonces perm por defecto es (2,1), intercambiando los dos ejes de A (las filas y columnas de la matriz). Esto difiere de transpose en que la operación no es recursiva, lo cual es especialmente útil para arreglos de valores no numéricos (donde la transpose recursiva lanzaría un error) y/o arreglos 2d que no representan operadores lineales.

Para arreglos 1d, consulta permutedims(v::AbstractVector), que devuelve una “matriz” de 1 fila.

Consulta también permutedims!, PermutedDimsArray, transpose, invperm.

Ejemplos

Arreglos 2d:

A diferencia de transpose, permutedims se puede usar para intercambiar filas y columnas de arreglos 2d de elementos no numéricos arbitrarios, como cadenas:

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"

Y permutedims produce resultados que difieren de transpose para matrices cuyos elementos son a su vez matrices numéricas:

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]

Arreglos multidimensionales

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); # poner la última dimensión primero

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 permutación inversa
true

Para cada dimensión i de B = permutedims(A, perm), su dimensión correspondiente de A será perm[i]. Esto significa que la igualdad size(B, i) == size(A, perm[i]) se cumple.

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)

Reorganiza el vector v en una matriz fila de 1 × length(v). Se diferencia de transpose en que la operación no es recursiva, lo cual es especialmente útil para arreglos de valores no numéricos (donde la transpose recursiva podría lanzar un error).

Ejemplos

A diferencia de transpose, permutedims se puede usar en vectores de elementos no numéricos arbitrarios, como cadenas:

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

Para vectores de números, permutedims(v) funciona de manera similar a transpose(v), excepto que el tipo de retorno difiere (utiliza reshape en lugar de una vista LinearAlgebra.Transpose, aunque ambos comparten memoria con el arreglo 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; # mutar p o r también cambia v

julia> v # comparte memoria con ambos p y r
4-element Vector{Int64}:
 5
 6
 3
 4

Sin embargo, permutedims produce resultados que difieren de transpose para vectores cuyos elementos son matrices numéricas:

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)

Permuta las dimensiones del arreglo src y almacena el resultado en el arreglo dest. perm es un vector que especifica una permutación de longitud ndims(src). El arreglo preasignado dest debe tener size(dest) == size(src)[perm] y se sobrescribe completamente. No se admite la permutación en el lugar y ocurrirán resultados inesperados si src y dest tienen regiones de memoria superpuestas.

Véase también permutedims.

PermutedDimsArray(A, perm) -> B

Dada una AbstractArray A, crea una vista B de tal manera que las dimensiones parezcan estar permutadas. Similar a permutedims, excepto que no se realiza copia ( B comparte almacenamiento con A).

Véase también permutedims, invperm.

Ejemplos

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)

Verifica la compatibilidad de las formas de dos arreglos, permitiendo dimensiones singleton finales, y devuelve la forma que tiene más dimensiones.

Ejemplos

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

Operación acumulativa op a lo largo de la dimensión dims de A (siempre que dims sea opcional para vectores). Un valor inicial init puede ser proporcionado opcionalmente mediante un argumento de palabra clave. Véase también accumulate! para usar un array de salida preasignado, tanto por rendimiento como para controlar la precisión de la salida (por ejemplo, para evitar desbordamientos).

Para operaciones comunes hay variantes especializadas de accumulate, consulte cumsum, cumprod. Para una versión perezosa, consulte Iterators.accumulate.

Ejemplos

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

Operación acumulativa op sobre A a lo largo de la dimensión dims, almacenando el resultado en B. Proporcionar dims es opcional para vectores. Si se proporciona el argumento clave init, su valor se utiliza para instanciar la acumulación.

Véase también accumulate, cumsum!, cumprod!.

Ejemplos

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)

Producto acumulativo a lo largo de la dimensión dim. Ver también cumprod! para usar un array de salida preasignado, tanto por rendimiento como para controlar la precisión de la salida (por ejemplo, para evitar desbordamientos).

Ejemplos

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)

Producto acumulativo de un iterador.

Véase también cumprod!, accumulate, cumsum.

Ejemplos

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)

Producto acumulativo de A a lo largo de la dimensión dims, almacenando el resultado en B. Ver también cumprod.

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

Producto acumulativo de un vector x, almacenando el resultado en y. Ver también cumprod.

cumsum(A; dims::Integer)

Suma acumulativa a lo largo de la dimensión dims. Véase también cumsum! para usar un array de salida preasignado, tanto por rendimiento como para controlar la precisión de la salida (por ejemplo, para evitar desbordamientos).

Ejemplos

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)

Suma acumulativa de un iterador.

Véase también accumulate para aplicar funciones distintas de +.

Ejemplos

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)

Suma acumulativa de A a lo largo de la dimensión dims, almacenando el resultado en B. Ver también cumsum.

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

Operador de diferencia finita en un vector o un arreglo multidimensional A. En el último caso, la dimensión sobre la que operar debe especificarse con el argumento de palabra clave dims.

Ejemplos

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

Construye un array repitiendo el array A un número dado de veces en cada dimensión, especificado por counts.

Véase también: fill, Iterators.repeated, Iterators.cycle.

Ejemplos

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

Construye un array repitiendo las entradas de A. El i-ésimo elemento de inner especifica el número de veces que las entradas individuales de la i-ésima dimensión de A deben ser repetidas. El i-ésimo elemento de outer especifica el número de veces que una porción a lo largo de la i-ésima dimensión de A debe ser repetida. Si se omiten inner o outer, no se realiza ninguna repetición.

Ejemplos

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)

Repite una cadena r veces. Esto se puede escribir como s^r.

Véase también ^.

Ejemplos

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

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

Repite un carácter r veces. Esto se puede lograr de manera equivalente llamando a c^r.

Ejemplos

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

rot180(A)

Rote la matriz A 180 grados.

Ejemplos

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)

Rote la matriz A 180 grados un número entero k de veces. Si k es par, esto es equivalente a una copia.

Ejemplos

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)

Rote la matriz A a la izquierda 90 grados.

Ejemplos

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)

Rotea a la izquierda la matriz A 90 grados en sentido antihorario un número entero k de veces. Si k es un múltiplo de cuatro (incluyendo cero), esto es equivalente a una copia.

Ejemplos

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)

Gira la matriz A 90 grados a la derecha.

Ejemplos

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)

Rotea a la derecha la matriz A 90 grados en el sentido de las agujas del reloj un número entero k de veces. Si k es un múltiplo de cuatro (incluyendo cero), esto es equivalente a una copia.

Ejemplos

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)

Transforma las dimensiones dadas del arreglo A aplicando una función f en cada rebanada de la forma A[..., :, ..., :, ...], con dos puntos en cada d en dims. Los resultados se concatenan a lo largo de las dimensiones restantes.

Por ejemplo, si dims = [1,2] y A es de 4 dimensiones, entonces f se llama sobre x = A[:,:,i,j] para todos los i y j, y f(x) se convierte en R[:,:,i,j] en el resultado R.

Véase también eachcol o eachslice, utilizados con map o stack.

Ejemplos

julia> A = reshape(1:30,(2,5,3))
2×5×3 reshape(::UnitRange{Int64}, 2, 5, 3) con el tipo de elemento 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);  # devuelve una matriz 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];  # devuelve un número

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))
Vector de 5 elementos {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

Observe que en eachslice(A; dims=2), la dimensión especificada es la que no tiene un dos puntos en la rebanada. Esto es view(A,:,i,:), mientras que mapslices(f, A; dims=(1,3)) utiliza A[:,i,:]. La función f puede mutar valores en la rebanada sin afectar a A.

eachrow(A::AbstractVecOrMat) <: AbstractVector

Crea un objeto RowSlices que es un vector de filas de la matriz o vector A. Las secciones de fila se devuelven como vistas de AbstractVector de A.

Para la inversa, consulta stack(rows; dims=1).

Consulta también eachcol, eachslice y mapslices.

Ejemplos

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

Crea un objeto ColumnSlices que es un vector de columnas de la matriz o vector A. Los cortes de columna se devuelven como vistas de AbstractVector de A.

Para la inversa, consulta stack(cols) o reduce(hcat, cols).

Consulta también eachrow, eachslice y mapslices.

Ejemplos

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)

Crea un objeto Slices que es un arreglo de cortes sobre las dimensiones dims de A, devolviendo vistas que seleccionan todos los datos de las otras dimensiones en A. dims puede ser un entero o una tupla de enteros.

Si drop = true (el valor predeterminado), el Slices externo eliminará las dimensiones internas, y el orden de las dimensiones coincidirá con las de dims. Si drop = false, entonces el Slices tendrá la misma dimensionalidad que el arreglo subyacente, con dimensiones internas de tamaño 1.

Consulta stack(slices; dims) para la inversa de eachslice(A; dims::Integer).

También consulta eachrow, eachcol, mapslices y selectdim.

Ejemplos

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)

Devuelve la permutación inversa de v. Si B = A[v], entonces A == B[invperm(v)].

Véase también sortperm, invpermute!, isperm, permutedims.

Ejemplos

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

Devuelve true si v es una permutación válida.

Ejemplos

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

Permuta el vector v en su lugar, de acuerdo con la permutación p. No se realiza ninguna verificación para confirmar que p es una permutación.

Para devolver una nueva permutación, usa v[p]. Esto es generalmente más rápido que permute!(v, p); es aún más rápido escribir en un array de salida preasignado con u .= @view v[p]. (A pesar de que permute! sobrescribe v en su lugar, internamente requiere alguna asignación para hacer un seguimiento de qué elementos han sido movidos.)

Ver también invpermute!.

Ejemplos

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)

Como permute!, pero se aplica la inversa de la permutación dada.

Ten en cuenta que si tienes un arreglo de salida preasignado (por ejemplo, u = similar(v)), es más rápido emplear u[p] = v. (invpermute! asigna internamente una copia de los datos.)

Ejemplos

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

Invierte A a lo largo de la dimensión dims, que puede ser un entero (una sola dimensión), una tupla de enteros (una tupla de dimensiones) o : (invertir a lo largo de todas las dimensiones, el valor predeterminado). Consulta también reverse! para la inversión en su lugar.

Ejemplos

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)

Dada un índice i en reverse(v), devuelve el índice correspondiente en v de modo que v[reverseind(v,i)] == reverse(v)[i]. (Esto puede ser no trivial en casos donde v contiene caracteres no ASCII.)

Ejemplos

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

Versión en su lugar de reverse.

Ejemplos

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

Como reverse, pero opera en su lugar en A.