Arrays

AbstractArray{T,N}

T türünde elemanlara sahip N-boyutlu diziler (veya dizi benzeri türler) için süpertip. Array ve diğer türler bunun alt türleridir. AbstractArray arayüzü ile ilgili kılavuz bölümüne bakın.

Ayrıca bakınız: AbstractVector, AbstractMatrix, eltype, ndims.

AbstractVector{T}

T türünden elemanlara sahip bir boyutlu diziler (veya dizi benzeri türler) için süpertip. AbstractArray{T,1} için takma ad.

AbstractMatrix{T}

İki boyutlu diziler (veya dizi benzeri türler) için T türünde elemanlara sahip süpertip. AbstractArray{T,2} için takma ad.

AbstractVecOrMat{T}

AbstractVector{T} ve AbstractMatrix{T} union türü.

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

N-boyutlu yoğun dizi, T türünde elemanlarla.

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

Başlatılmamış bir N-boyutlu Array oluşturur ve T türünde elemanlar içerir. N, Array{T,N}(undef, dims) şeklinde açıkça sağlanabilir veya dims'in uzunluğu veya sayısı ile belirlenebilir. dims, her boyuttaki uzunluklara karşılık gelen bir demet veya bir dizi tam sayı argümanı olabilir. Eğer N açıkça sağlanmışsa, o zaman dims'in uzunluğu veya sayısı ile eşleşmelidir. Burada undef UndefInitializerdır.

Örnekler

julia> A = Array{Float64, 2}(undef, 2, 3) # N açıkça verilmiş
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 girdi ile belirlenmiş
4-element Vector{Float64}:
   2.360075077e-314
 NaN
   2.2671131793e-314
   2.299821756e-314

julia> similar(B, 2, 4, 1) # typeof(B) kullan, ve verilen boyutu
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)

T türünden elemanlar içeren N-boyutlu Array oluşturun, nothing girişleri ile başlatılmıştır. Eleman türü T, bu değerleri tutabilmelidir, yani Nothing <: T.

Örnekler

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)

T türünden elemanlar içeren N-boyutlu Array oluşturun, missing girişleri ile başlatılmıştır. Eleman türü T, bu değerleri tutabilmelidir, yani Missing <: T.

Örnekler

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

Dizi başlatmada kullanılan tekil tür, dizi oluşturucu çağrısının başlatılmamış bir dizi istediğini belirtir. Ayrıca undef için bir takma ad olan UndefInitializer()'a da bakın.

Örnekler

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

undef

UndefInitializer() için bir takma addır; bu, dizi başlatmada, dizi oluşturucu çağrısının başlatılmamış bir dizi istediğini belirtmek için kullanılan UndefInitializer tekil türünün bir örneğini oluşturur.

Ayrıca bakınız: missing, similar.

Örnekler

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

Vector{T} <: AbstractVector{T}

Bir boyutlu yoğun dizi, T türünde elemanlara sahip olup, genellikle matematiksel bir vektörü temsil etmek için kullanılır. Array{T,1} için bir takma ad.

Ayrıca vektör oluşturmak için empty, similar ve zero ile ilgili bilgilere de bakınız.

Vector{T}(undef, n)

n uzunluğunda başlatılmamış bir Vector{T} oluşturur.

Örnekler

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

Vector{T}(nothing, m)

Vector{T} uzunluğunda m ile başlatılmış nothing girişleri ile bir vektör oluşturur. Eleman türü T, bu değerleri tutabilmelidir, yani Nothing <: T.

Örnekler

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

Vector{T}(missing, m)

Vector{T} uzunluğunda m ile başlatılmış missing girişleri ile bir vektör oluşturur. Eleman türü T, bu değerleri tutabilmelidir, yani Missing <: T.

Örnekler

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

Matrix{T} <: AbstractMatrix{T}

İki boyutlu yoğun dizi, T türünde elemanlara sahip olup, genellikle matematiksel bir matris temsil etmek için kullanılır. Array{T,2} için bir takma ad.

Ayrıca matris oluşturmak için fill, zeros, undef ve similar ile ilgili bilgilere de bakın.

Matrix{T}(undef, m, n)

Başka bir tanımsız Matrix{T} oluşturur, boyutu m×n.

Örnekler

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)

m×n boyutunda, nothing girişleri ile başlatılmış bir Matrix{T} oluşturur. Eleman türü T, bu değerleri tutabilmelidir, yani Nothing <: T.

Örnekler

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)

m×n boyutunda, missing girişleri ile başlatılmış bir Matrix{T} oluşturur. Eleman türü T, bu değerleri tutabilmelidir, yani Missing <: T olmalıdır.

Örnekler

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

VecOrMat{T}

Vector{T} ve Matrix{T} union türü, fonksiyonların ya bir Matris ya da bir Vektör kabul etmesine olanak tanır.

Örnekler

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

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

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

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

N-boyutlu yoğun dizi, T türünde elemanlar içerir. Yoğun bir dizinin elemanları bellekte ardışık olarak saklanır.

DenseVector{T}

T türünde elemanlara sahip bir boyutlu DenseArray. DenseArray{T,1} için takma ad.

DenseMatrix{T}

T türünde elemanlara sahip iki boyutlu DenseArray. DenseArray{T,2} için takma ad.

DenseVecOrMat{T}

DenseVector{T} ve DenseMatrix{T} union türü.

StridedArray{T, N}

Sabit kodlanmış Union ortak dizi türlerinin bir birleşimidir ve strided array interface ile uyumludur, T türünde elemanlar ve N boyutları vardır.

Eğer A bir StridedArray ise, o zaman elemanları bellekte kaydırmalarla depolanır; bu kaydırmalar boyutlar arasında değişebilir ancak bir boyut içinde sabittir. Örneğin, A boyut 1'de 2 kaydırmaya ve boyut 2'de 3 kaydırmaya sahip olabilir. A'yı boyut d boyunca artırmak, bellekte [stride(A, d)] slotları kadar atlamaya neden olur. Strided diziler özellikle önemlidir ve kullanışlıdır çünkü bazen doğrudan BLAS gibi yabancı dil kütüphanelerine işaretçi olarak geçirilebilirler.

StridedVector{T}

T türünde elemanlara sahip bir boyutlu StridedArray.

StridedMatrix{T}

İki boyutlu StridedArray elemanları T türünde olan.

StridedVecOrMat{T}

T türündeki elemanlarla StridedVector ve StridedMatrix union türü.

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

Sabit boyutlu DenseVector{T}.

kind şu anda ya :not_atomic ya da :atomic olabilir. :atomic'in ne anlama geldiği hakkında daha fazla bilgi için AtomicMemory bölümüne bakın.

addrspace şu anda yalnızca Core.CPU olarak ayarlanabilir. Bu, GPU'lar gibi diğer sistemler tarafından genişletilmesine izin vermek için tasarlanmıştır; bu sistemler aşağıdaki gibi değerler tanımlayabilir:

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

Bu diğer addrspace'lerin tam anlamı, belirli arka uç tarafından tanımlanır, ancak kullanıcı CPU'da bunlara erişmeye çalışıyorsa hata verecektir.

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

Sabit boyutlu DenseVector{T}.

`memoryref(::GenericMemory)`

Bir bellek nesnesinden bir GenericMemoryRef oluşturur. Bu işlem başarısız olmaz, ancak sonuçta elde edilen bellek yalnızca bellek boşsa sınır dışına işaret eder.

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

Bir bellek nesnesinden ve bir offset indeksinden (1-bazlı) GenericMemoryRef oluşturur; bu indeks negatif de olabilir. Bu her zaman bir sınır içindeki nesne döndürür ve bu mümkün değilse (çünkü indeks, temel belleğin dışına kaymaya neden olursa) bir hata fırlatır.

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

Belirli boyut(lar) üzerinden bir üst diziye dilimler içeren bir AbstractArray, diğer boyut(lar)dan tüm verileri seçen görünümler döndürür.

Bunlar genellikle eachslice, eachcol veya eachrow ile oluşturulmalıdır.

parent(s::Slices) üst diziyi döndürecektir.

RowSlices{M,AX,S}

Bir matrisin satır dilimlerinin bir vektörü olan Slices özel bir durumudur ve eachrow ile oluşturulur.

Altındaki matrisi almak için parent kullanılabilir.

ColumnSlices{M,AX,S}

Bir matrisin sütun dilimlerinin bir vektörü olan Slices özel bir durumudur ve eachcol ile oluşturulur.

Altındaki matrisi almak için parent kullanılabilir.

getindex(tür[, elemanlar...])

Belirtilen türde 1-d dizisi oluşturur. Bu genellikle Tür[] sözdizimi ile çağrılır. Eleman değerleri Tür[a,b,c,...] kullanılarak belirtilebilir.

Örnekler

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

Bir Array oluşturur, eleman tipi T olan, dims ile belirtilen boyutta tüm elemanları sıfır olan. Ayrıca fill, ones, zero ile de bakabilirsiniz.

Örnekler

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

Bir Array oluşturur, eleman tipi T olan, dims ile belirtilen boyutta tüm elemanları bir olan. Ayrıca fill, zeros ile de bakabilirsiniz.

Örnekler

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}

Alanı sadece bir bit kullanarak boolean değerler için N-boyutlu alanı verimli bir şekilde depolayan BitArray.

BitArray'ler her 8 baytta 64 değere kadar paketlenir, bu da Array{Bool, N} üzerinde 8 kat alan verimliliği sağlar ve bazı işlemlerin aynı anda 64 değer üzerinde çalışmasına olanak tanır.

Varsayılan olarak, Julia, boolean elemanlar üreten yayılma işlemlerinden (dotted-comparisons gibi .== dahil) ve trues ile falses fonksiyonlarından BitArrays döndürür.

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

Verilen boyutlarla bir undef BitArray oluşturur. Array yapıcısına benzer şekilde davranır. Bakınız undef.

Örnekler

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)

Verilen iterable nesnesi tarafından oluşturulan bir BitArray oluşturur. Şekil itr nesnesinden çıkarılır.

Örnekler

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)

Tüm değerleri true olarak ayarlanmış bir BitArray oluşturur.

Örnekler

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

falses(dims)

Tüm değerleri false olarak ayarlanmış bir BitArray oluşturur.

Örnekler

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

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

Boyutları dims olan ve her konumu value ile ayarlanmış bir dizi oluşturur.

Örneğin, fill(1.0, (5,5)) her konumunda 1.0 bulunan 5×5'lik bir float dizisi döndürür.

Boyut uzunlukları dims ya bir demet (tuple) ya da bir argüman dizisi olarak belirtilebilir. value'dan sonra gelen N uzunluğundaki bir demet veya N argümanı, N-boyutlu bir dizi belirtir. Bu nedenle, yalnızca x ile ayarlanmış sıfır-boyutlu bir dizi oluşturmak için yaygın bir deyim fill(x)'dir.

Döndürülen dizinin her konumu, geçilen value ile ayarlanmıştır (ve dolayısıyla === ile eşittir); bu, eğer value kendisi değiştirilirse, fill edilmiş dizinin tüm elemanlarının bu değişikliği yansıtacağı anlamına gelir çünkü hala o value'dur. Bu, fill(1.0, (5,5)) ile bir sorun değildir çünkü value olan 1.0 değiştirilemez ve kendisi değiştirilemez, ancak genellikle diziler gibi değiştirilebilir değerlerle beklenmedik olabilir. Örneğin, fill([], 3) döndürülen vektörün üç konumuna tam olarak aynı boş diziyi yerleştirir:

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]

Birçok bağımsız iç dizi oluşturmak için bunun yerine bir kapsam kullanın. Bu, döngünün her yinelemesinde yeni ve ayrı bir dizi oluşturur:

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

Ayrıca bakınız: fill!, zeros, ones, similar.

Örnekler

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-boyutlu Array{Int64, 0}:
42

julia> A = fill(zeros(2), 2) # her iki elemanı da aynı [0.0, 0.0] vektörüne ayarlar
2-element Vector{Vector{Float64}}:
 [0.0, 0.0]
 [0.0, 0.0]

julia> A[1][1] = 42; # doldurulmuş değeri [42.0, 0.0] olarak değiştirir

julia> A # hem A[1] hem de A[2] tam olarak aynı vektördür
2-element Vector{Vector{Float64}}:
 [42.0, 0.0]
 [42.0, 0.0]

fill!(A, x)

Dizi A'yı x değeriyle doldurun. Eğer x bir nesne referansıysa, tüm elemanlar aynı nesneye referans verecektir. fill!(A, Foo()) ifadesi, Foo()'yu bir kez değerlendirerek elde edilen sonuçla doldurulmuş A döndürecektir.

Örnekler

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)

Boş bir demet döndürür, ().

empty(v::AbstractVector, [eltype])

Boş bir vektör oluşturur, v'ye benzer, isteğe bağlı olarak eltype'i değiştirir.

Ayrıca bakınız: empty!, isempty, isassigned.

Örnekler

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

Boş bir AbstractDict konteyneri oluşturur; bu konteyner index_type türünde indeksler ve value_type türünde değerler kabul edebilir. İkinci ve üçüncü argüman isteğe bağlıdır ve sırasıyla girişin keytype ve valtype değerlerine varsayılan olarak ayarlanır. (Eğer yalnızca iki türden biri belirtilirse, bu value_type olarak varsayılır ve index_type için varsayılan olarak keytype(a) alınır).

Özel AbstractDict alt türleri, belirli indeks ve değer türleri için en uygun sözlük türünü döndürmek üzere üç argümanlı imzayı özelleştirerek seçebilir. Varsayılan olarak boş bir Dict döndürülür.

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

Verilen kaynak SparseMatrixCSC'ye dayanarak, belirtilen eleman türü, indeks türü ve boyut ile başlatılmamış bir değiştirilebilir dizi oluşturur. Yeni seyrek matris, orijinal seyrek matrisin yapısını korur, yalnızca çıkış matrisinin boyutları çıkıştan farklı olduğunda durum farklıdır.

Çıkış matrisinin, girdi ile aynı konumlarda sıfırları vardır, ancak sıfır olmayan konumlar için başlatılmamış değerler içerir.

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

Verilen kaynak diziye dayalı olarak, belirtilen eleman türü ve boyut ile başlatılmamış bir değişken dizi oluşturur. İkinci ve üçüncü argümanlar isteğe bağlıdır ve varsayılan olarak verilen dizinin eltype ve size değerlerine ayarlanır. Boyutlar, ya tek bir demet argümanı olarak ya da bir dizi tam sayı argümanı olarak belirtilebilir.

Özel AbstractArray alt türleri, verilen eleman türü ve boyut için en uygun dizi türünü döndürmeyi seçebilir. Bu yöntemi özelleştirmezlerse, varsayılan olarak Array{element_type}(undef, dims...) döner.

Örneğin, benzer(1:10, 1, 4) başlatılmamış bir Array{Int,2} döner çünkü aralıklar ne değişkendir ne de 2 boyut destekler:

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

Tersine, benzer(trues(10,10), 2) iki elemanlı başlatılmamış bir BitVector döner çünkü BitArray'ler hem değişkendir hem de 1 boyutlu dizileri destekleyebilir:

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

Ancak, BitArray'ler yalnızca Bool türündeki elemanları depolayabildiğinden, farklı bir eleman türü talep ederseniz, bunun yerine normal bir Array oluşturur:

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

Ayrıca bakınız: undef, isassigned. ```

similar(storagetype, axes)

storagetype tarafından belirtilen türde, ancak son argümanla belirtilen axes ile benzer şekilde, başlatılmamış bir değiştirilebilir dizi oluşturur.

Örnekler:

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

Array{Int} gibi "davranan" bir dizi oluşturur (ve gerçekten de birinin arkasında olabilir), ancak A ile aynı şekilde indekslenir. Eğer A geleneksel indeksleme kullanıyorsa, bu Array{Int}(undef, size(A)) ile aynı olacaktır, ancak A alışılmadık indeksleme kullanıyorsa, sonucun indeksleri A ile eşleşecektir.

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

A'nın sütunlarının indeksleriyle eşleşen 1 boyutlu bir mantıksal dizi oluşturur.

ndims(A::AbstractArray) -> Integer

A'nın boyut sayısını döndürür.

Ayrıca bakınız: size, axes.

Örnekler

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

julia> ndims(A)
3

size(A::AbstractArray, [dim])

A'nın boyutlarını içeren bir demet döndürür. İsteğe bağlı olarak, yalnızca o boyutun uzunluğunu almak için bir boyut belirtebilirsiniz.

size'in standart dışı indekslere sahip diziler için tanımlı olmayabileceğini unutmayın; bu durumda axes yararlı olabilir. Özel indekslere sahip diziler konusundaki kılavuz bölümüne bakın.

Ayrıca bakınız: length, ndims, eachindex, sizeof.

Örnekler

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

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

julia> size(A, 2)
3

axes(A)

Dizi A için geçerli indekslerin demetini döndürür.

Ayrıca bakınız: size, keys, eachindex.

Örnekler

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

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

axes(A, d)

Dizi A için d boyutu boyunca geçerli indeks aralığını döndürür.

Ayrıca size ve özel indekslere sahip diziler konulu kılavuz bölümüne bakın.

Örnekler

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

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

julia> axes(A, 4) == 1:1  # ndims(A) > d olan tüm boyutlar 1 boyutuna sahiptir
true

Kullanım notu

Her bir indeks AbstractUnitRange{<:Integer} olmalıdır, ancak aynı zamanda özel indeksler kullanan bir tür de olabilir. Örneğin, bir alt küme gerekiyorsa, begin/end veya firstindex/lastindex gibi genelleştirilmiş indeksleme yapıları kullanın:

ix = axes(v, 1)
ix[2:end]          # örneğin Vektör için çalışır, ancak genel olarak başarısız olabilir
ix[(begin+1):end]  # genelleştirilmiş indeksler için çalışır

length(A::AbstractArray)

Dizinin içindeki eleman sayısını döndürür, varsayılan olarak prod(size(A)) kullanılır.

Örnekler

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

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

keys(a::AbstractArray)

a için şekline göre düzenlenmiş tüm geçerli indeksleri tanımlayan verimli bir dizi döndürür.

1 boyutlu dizilerin (vektörlerin) anahtarları tam sayılardır, oysa diğer N boyutlu diziler CartesianIndex kullanarak konumlarını tanımlar. Genellikle, bu tam sayı ve CartesianIndex dizilerini verimli bir şekilde temsil etmek için özel dizi türleri olan LinearIndices ve CartesianIndices kullanılır.

Bir dizinin keys'inin en verimli indeks türü olmayabileceğini unutmayın; maksimum performans için eachindex kullanın.

Örnekler

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

Bir AbstractArray A'nın her indeksini verimli bir şekilde ziyaret etmek için bir yineleyici nesne oluşturur. Hızlı lineer indekslemeye (örneğin Array gibi) katılan dizi türleri için bu, 1 tabanlı indeksleme kullanıyorlarsa basitçe 1:length(A) aralığıdır. Hızlı lineer indekslemeye katılmayan dizi türleri için, genellikle her boyut için belirtilen indekslerle diziyi verimli bir şekilde indekslemek için özel bir Kartezyen aralığı döndürülür.

Genel olarak eachindex, dizeler ve sözlükler de dahil olmak üzere keyfi yineleyicileri kabul eder ve keyfi indeks türlerini (örneğin, düzensiz aralıklı veya tam sayı olmayan indeksler) destekleyen bir yineleyici nesnesi döndürür.

Eğer A bir AbstractArray ise, eachindex'in döndürmesi gereken indekslerin stilini açıkça belirtmek için ilk argüman olarak IndexStyle türünde bir değer geçerek belirtebilirsiniz (genellikle lineer indeksler gerekiyorsa IndexLinear(), Kartezyen aralık isteniyorsa IndexCartesian()).

Birden fazla AbstractArray argümanı sağlarsanız, eachindex tüm argümanlar için hızlı bir yineleyici nesnesi oluşturur (genellikle tüm girdilerin hızlı lineer indekslemesi varsa bir UnitRange, aksi takdirde bir CartesianIndices). Eğer diziler farklı boyutlara ve/veya boyutlara sahipse, bir DimensionMismatch istisnası fırlatılacaktır.

Ayrıca, indeksler ve değerler üzerinde birlikte yineleme yapmak için pairs(A) ve bir boyut boyunca geçerli indeksler için axes(A, 2)'yi de görebilirsiniz.

Örnekler

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

julia> for i in eachindex(A) # lineer indeksleme
           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)) # Kartezyen indeksleme
           println(i)
       end
CartesianIndex(1, 1)
CartesianIndex(2, 1)

IndexStyle(A)
IndexStyle(typeof(A))

IndexStyle, dizi A için "yerel indeksleme stilini" belirtir. Yeni bir AbstractArray türü tanımladığınızda, ya lineer indeksleme (IndexLinear ile) ya da kartezyen indeksleme uygulamayı seçebilirsiniz. Sadece lineer indeksleme uygulamaya karar verirseniz, o zaman bu özelliği dizi türünüz için ayarlamalısınız:

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

Varsayılan IndexCartesian() 'dir.

Julia'nın dahili indeksleme mekanizması, tüm indeksleme işlemlerini otomatik olarak (ve görünmez bir şekilde) tercih edilen stile yeniden hesaplayacaktır. Bu, kullanıcıların, açık yöntemler sağlanmamış olsa bile, dizinizin elemanlarına herhangi bir indeksleme stili kullanarak erişmelerine olanak tanır.

AbstractArray'ınız için her iki indeksleme stilini tanımlarsanız, bu özellik en performanslı indeksleme stilini seçmek için kullanılabilir. Bazı yöntemler, girdilerinde bu özelliği kontrol eder ve en verimli erişim desenine bağlı olarak farklı algoritmalara yönlendirme yapar. Özellikle, eachindex bu özelliğin ayarına bağlı olarak türü değişen bir yineleyici oluşturur.

IndexLinear()

Tekil bir indeksle tanımlanan dizileri tanımlamak için kullanılan IndexStyle alt türü.

Bir doğrusal indeksleme stili, dizideki konumu tanımlamak için bir tam sayı indeksi kullanır (çok boyutlu bir dizi olsa bile) ve elemanlara verimli bir şekilde erişmek için sütun-ana sıralama kullanılır. Bu, IndexLinear olan bir diziden eachindex istemenin, çok boyutlu olsa bile basit bir tek boyutlu aralık döndüreceği anlamına gelir.

IndexStyle'ını IndexLinear olarak bildiren özel bir dizi, yalnızca tek bir Int indeksi ile indeksleme (ve indeksli atama) uygulamak zorundadır; diğer tüm indeksleme ifadeleri — çok boyutlu erişimler de dahil — doğrusal indekse yeniden hesaplanacaktır. Örneğin, A doğrusal indeksleme ile 2×3 özel bir matris olsaydı ve A[1, 3] referansını alsaydık, bu, eşdeğer doğrusal indekse yeniden hesaplanacak ve A[5] çağrılacaktır çünkü 1 + 2*(3 - 1) = 5.

Ayrıca bkz. IndexCartesian.

IndexCartesian()

IndexStyle alt türü, Cartesian indeksi ile optimal olarak indekslenen dizileri tanımlamak için kullanılır. Bu, yeni özel AbstractArray alt türleri için varsayılandır.

Bir Cartesian indeksleme stili, çok boyutlu bir dizideki konumu tanımlamak için birden fazla tam sayı indeksi kullanır ve her boyut için tam olarak bir indeks bulunur. Bu, IndexCartesian olan bir diziden eachindex talep edildiğinde, bir dizi CartesianIndices döneceği anlamına gelir.

IndexCartesian olarak IndexStyle'ını bildiren N boyutlu özel bir dizinin, tam olarak N Int indeksi ile indeksleme (ve indeksli atama) uygulaması gerekir; diğer tüm indeksleme ifadeleri — lineer indeksleme dahil — eşdeğer Cartesian konumuna yeniden hesaplanacaktır. Örneğin, A bir Cartesian indeksleme ile 2×3 özel bir matris olsaydı ve A[5] referans verilseydi, bu eşdeğer Cartesian indeksi olarak yeniden hesaplanacak ve A[1, 3] çağrılacaktır çünkü 5 = 1 + 2*(3 - 1).

Lineer bir indeksten Cartesian indeksleri hesaplamak, tersine gitmekten çok daha pahalıdır. İlk işlem bölme gerektirir — çok maliyetli bir işlem — oysa ikincisi yalnızca çarpma ve toplama kullanır ve esasen ücretsizdir. Bu asimetri, IndexCartesian dizisi ile lineer indeksleme kullanmanın, IndexLinear dizisi ile Cartesian indeksleme kullanmaktan çok daha maliyetli olduğu anlamına gelir.

Ayrıca bkz. IndexLinear.

conj!(A)

Bir diziyi karmaşık eşleniğine yerinde dönüştürür.

Ayrıca bkz. conj.

Örnekler

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)

k boyutundaki bitişik elemanlar arasındaki bellek mesafesini (eleman sayısı cinsinden) döndürür.

Ayrıca bkz: strides.

Örnekler

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

julia> stride(A,2)
3

julia> stride(A,3)
12

strides(A)

Her boyut için bellek adımlarının bir demetini döndürür.

Ayrıca bkz: stride.

Örnekler

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

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

broadcast(f, As...)

Fonksiyonu f diziler, demetler, koleksiyonlar, Refs ve/veya skalarlar As üzerinde yayar.

Yayılma, fonksiyonu f konteyner argümanlarının elemanları ve As içindeki skalarlar üzerinde uygular. Tekil ve eksik boyutlar, diğer argümanların boyutlarıyla eşleşecek şekilde sanal olarak değeri tekrar ederek genişletilir. Varsayılan olarak, yalnızca sınırlı sayıda tür skalar olarak kabul edilir; bunlar arasında Numbers, Strings, Symbols, Types, Functions ve missing ve nothing gibi bazı yaygın tekil değerler bulunur. Diğer tüm argümanlar eleman bazında yinelemeli veya dizinlenir.

Sonuçta oluşan konteyner türü aşağıdaki kurallara göre belirlenir:

• Tüm argümanlar skalar veya sıfır boyutlu diziler ise, bir sarılmamış skalar döner.
• En az bir argüman bir demet ise ve diğerleri skalar veya sıfır boyutlu diziler ise, bir demet döner.
• Diğer tüm argüman kombinasyonları varsayılan olarak bir Array döner, ancak özel konteyner türleri, argüman olarak göründüklerinde sonucu özelleştirmek için kendi uygulamalarını ve terfi benzeri kurallarını tanımlayabilir.

Yayılma için özel bir sözdizimi vardır: f.(args...) ifadesi broadcast(f, args...) ile eşdeğerdir ve iç içe f.(g.(args...)) çağrıları tek bir yayılma döngüsünde birleştirilir.

Örnekler

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

broadcast gibi, ancak broadcast(f, As...) sonucunu dest dizisinde saklar. dest yalnızca sonucu saklamak için kullanılır ve f'ye argüman sağlamaz, yalnızca As içinde listelenmişse, örneğin broadcast!(f, A, A, B) ile A[:] = broadcast(f, A, B) işlemini gerçekleştirmek için.

Örnekler

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

Herhangi bir işlev çağrısını veya operatörü expr içinde "nokta çağrısına" (örneğin f(x)'i f.(x)'e dönüştürmek) ve expr içindeki her atamayı "nokta atamasına" (örneğin +='yi .+='ye dönüştürmek) dönüştürün.

Eğer expr içinde seçilen işlev çağrıları için noktaları kaçınmak istiyorsanız, bu işlev çağrılarını $ ile birleştirin. Örneğin, @. sqrt(abs($sort(x))) ifadesi sqrt.(abs.(sort(x))) ile eşdeğerdir (sort için nokta yok).

(@. ifadesi @__dot__ çağrısına eşdeğerdir.)

Örnekler

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, bir soyut tür ve nesnelerin yayılma altındaki davranışını belirlemek için kullanılan bir özellik-fonksiyondur. BroadcastStyle(typeof(x)), x ile ilişkili stili döndürür. Bir türün yayılma davranışını özelleştirmek için, bir tür/yöntem çifti tanımlayarak bir stil ilan edilebilir.

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

Daha sonra, Broadcasted{MyContainerStyle} üzerinde çalışan yöntem(ler) (en az similar) yazılır. Ayrıca, yararlanabileceğiniz birkaç önceden tanımlanmış BroadcastStyle alt türü vardır; daha fazla bilgi için Arayüzler bölümüne bakın.

Broadcast.AbstractArrayStyle{N} <: BroadcastStyle bir AbstractArray türü ile ilişkili herhangi bir stil için soyut süper türdür. N parametresi, belirli boyutları yalnızca destekleyen AbstractArray türleri için kullanışlı olabilecek boyutsallığı temsil eder:

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

Herhangi bir boyutsallığı destekleyen AbstractArray türleri için, N Any olarak ayarlanabilir:

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

Birden fazla AbstractArrayStyle'ı karıştırabilmek ve boyutsallığı takip edebilmek istediğiniz durumlarda, stilinizin bir Val yapıcıyı desteklemesi gerekir:

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

İki veya daha fazla AbstractArrayStyle alt türü çelişirse, yayılma mekanizması Array üretmeye geri dönecektir. Bu istenmiyorsa, çıktı türünü kontrol etmek için ikili BroadcastStyle kuralları tanımlamanız gerekebilir.

Ayrıca Broadcast.DefaultArrayStyle ile de bakabilirsiniz.

Broadcast.ArrayStyle{MyArrayType}() bir BroadcastStyle nesnesidir ve bir nesnenin yayılma için bir dizi gibi davrandığını gösterir. Belirli AbstractArray konteyner türleri için Broadcast.AbstractArrayStyle oluşturmanın basit bir yolunu sunar. Bu şekilde oluşturulan yayılma stilleri boyutsallığı takip etmez; eğer türünüz için boyutsallığı takip etmek önemliyse, kendi özel Broadcast.AbstractArrayStyle nesnenizi oluşturmalısınız.

Broadcast.DefaultArrayStyle{N}() bir BroadcastStyle nesnesidir ve bir nesnenin yayılma için N-boyutlu bir dizi gibi davrandığını gösterir. Özellikle, DefaultArrayStyle, özel bir stil tanımlanmamış herhangi bir AbstractArray türü için kullanılır ve diğer broadcast argümanlarından gelen geçersiz kılmaların yokluğunda, sonuçta elde edilen çıktı türü Array olur. broadcast'a birden fazla girdi olduğunda, DefaultArrayStyle herhangi bir diğer Broadcast.ArrayStyle ile "kaybeder".

Broadcast.broadcastable(x)

Ya x ya da x gibi bir nesne döndürür ki bu axes, indeksleme destekler ve türü ndims destekler.

Eğer x yinelemeyi destekliyorsa, döndürülen değer collect(x) ile aynı axes ve indeksleme davranışlarına sahip olmalıdır.

Eğer x bir AbstractArray değilse ama axes, indeksleme destekliyorsa ve türü ndims destekliyorsa, o zaman broadcastable(::typeof(x)) sadece kendisini döndürmek için uygulanabilir. Ayrıca, eğer x kendi BroadcastStyle tanımını yapıyorsa, o zaman özel stilin herhangi bir etkisi olması için broadcastable yöntemini kendisini döndürmek üzere tanımlamalıdır.

Örnekler

julia> Broadcast.broadcastable([1,2,3]) # diziler zaten axes ve indeksleme desteklediği için `identity` gibi
3-element Vector{Int64}:
 1
 2
 3

julia> Broadcast.broadcastable(Int) # Türler axes, indeksleme veya yineleme desteklemez ama genellikle skalar olarak kullanılır
Base.RefValue{Type{Int64}}(Int64)

julia> Broadcast.broadcastable("hello") # String'ler yineleme ile eşleşme kuralını bozar ve bunun yerine skalar gibi davranır
Base.RefValue{String}("hello")

combine_axes(As...) -> Tuple

As içindeki tüm değerler için yayılma (broadcasting) üzerinde sonuç eksenlerini belirleyin.

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

Herhangi bir değer argümanı için hangi BroadcastStyle'ın kullanılacağına karar verir. Her argüman için stil almak üzere BroadcastStyle kullanır ve stilleri birleştirmek için result_style kullanır.

Örnekler

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

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

Bir veya iki BroadcastStyle alır ve ortak bir BroadcastStyle belirlemek için BroadcastStyle kullanarak bunları birleştirir.

Örnekler

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

Dizi A'nın, inds indeksleriyle seçilen bir alt kümesini döndürür.

Her bir indeks, Integer, CartesianIndex, aralık veya desteklenen indekslerin dizisi gibi herhangi bir desteklenen indeks türü olabilir. Belirli bir boyutta tüm elemanları seçmek için bir : kullanılabilir ve karşılık gelen indeksin true olduğu elemanları filtrelemek için bir boolean dizisi (örneğin, bir Array{Bool} veya bir BitArray) kullanılabilir.

inds birden fazla eleman seçtiğinde, bu fonksiyon yeni bir dizi döndürür. Kopya oluşturmadan birden fazla elemanı indekslemek için view kullanın.

Ayrıntılar için dizi indeksleme bölümüne bakın.

Örnekler

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

Dizi X'den değerleri, inds ile belirtilen A'nın bir alt kümesine yerleştirir. A[inds...] = X sözdizimi, (setindex!(A, X, inds...); X) ile eşdeğerdir.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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)

i'den sonra A'da bulunan indeksi döndürür. Döndürülen indeks genellikle bir tam sayı i için i + 1 ile eşdeğerdir. Bu fonksiyon, genel kodlar için yararlı olabilir.

Ayrıca bakınız: prevind.

Örnekler

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

julia> nextind(x, 1) # geçerli sonuç
2

julia> nextind(x, 4) # geçersiz sonuç
5

julia> nextind(x, CartesianIndex(1, 1)) # geçerli sonuç
CartesianIndex(2, 1)

julia> nextind(x, CartesianIndex(2, 2)) # geçersiz sonuç
CartesianIndex(1, 3)

prevind(A, i)

A içindeki i'den önceki indeksi döndürür. Döndürülen indeks genellikle bir tamsayı i için i - 1 ile eşdeğerdir. Bu fonksiyon, genel kod için yararlı olabilir.

Ayrıca bakınız: nextind.

Örnekler

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

julia> prevind(x, 4) # geçerli sonuç
3

julia> prevind(x, 1) # geçersiz sonuç
0

julia> prevind(x, CartesianIndex(2, 2)) # geçerli sonuç
CartesianIndex(1, 2)

julia> prevind(x, CartesianIndex(1, 1)) # geçersiz sonuç
CartesianIndex(2, 0)

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

Rsrc aralığında src'nin bloğunu Rdest aralığında dest'in bloğuna kopyalayın. İki bölgenin boyutları eşleşmelidir.

Örnekler

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

src'yi dst'ye yerinde copy ederek, dst'deki mevcut elemanları atar. Eğer dst ve src aynı türde ise, çağrıdan sonra dst == src durumu sağlanmalıdır. Eğer dst ve src çok boyutlu diziler ise, eşit axes olmalıdırlar.

!!! uyarı Herhangi bir değiştirilmiş argümanın, diğer bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Ayrıca bkz. copyto!.

isassigned(array, i) -> Bool

Verilen dizinin i indeksine karşılık gelen bir değere sahip olup olmadığını test eder. İndeks sınırların dışındaysa veya tanımsız bir referansa sahipse false döner.

Örnekler

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

Kolonlar (:) tüm nesneleri veya boyutları bir kerede indekslemek için kullanılır.

Kolonlar üzerinde doğrudan çok az işlem tanımlanmıştır; bunun yerine, to_indices ile içsel bir vektör türüne (Base.Slice) dönüştürülerek kapsadıkları indeksler koleksiyonunu temsil etmek için kullanılır.

Colon'un tekil örneği, aralıkları oluşturmak için kullanılan bir işlevdir; bkz. :.

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

Çok boyutlu bir indeks I oluşturun; bu, çok boyutlu bir dizi A için indeksleme yapmak üzere kullanılabilir. Özellikle, A[I] ifadesi A[i,j,k...] ile eşdeğerdir. Tam sayılar ve CartesianIndex indekslerini serbestçe karıştırabilirsiniz; örneğin, A[Ipre, i, Ipost] (burada Ipre ve Ipost CartesianIndex indeksleri ve i bir Int'dir) bir dizinin tek bir boyutunda çalışan algoritmalar yazarken yararlı bir ifade olabilir.

Bir CartesianIndex, bazen eachindex ile üretilir ve her zaman açık bir CartesianIndices ile yineleme yapıldığında üretilir.

Bir I::CartesianIndex, broadcast için bir "skalar" (bir konteyner değil) olarak işlenir. Bir CartesianIndex'in bileşenleri üzerinde yineleme yapmak için, Tuple(I) ile bir tuple'a dönüştürün.

Örnekler

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

Bir bölge R tanımlayın, bu bölge çok boyutlu dikdörtgen bir tam sayı indeks aralığını kapsar. Bu genellikle yineleme bağlamında karşılaşılır; burada for I in R ... end ifadesi, iç içe döngülere eşdeğer CartesianIndex indeksleri I döndürecektir.

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

Sonuç olarak, bunlar, rastgele boyutlarda çalışan algoritmalar yazmak için yararlı olabilir.

CartesianIndices(A::AbstractArray) -> R

Bir diziden CartesianIndices oluşturmak, dizinin indekslerinin bir aralığını oluşturur.

Örnekler

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

Doğrusal ve kartezyen indeksler arasında dönüşüm

Doğrusal indeksin kartezyen indekse dönüşümü, CartesianIndices'in bir AbstractArray olduğunu ve doğrusal olarak indekslenebileceğini kullanır:

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)

Yayılma

CartesianIndices, bir CartesianIndex ile yayılma aritmetiğini (+ ve -) destekler.

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

Kartezyen'den doğrusal indeks dönüşümü için, LinearIndices kısmına bakın. ```

Dims{N}

AbstractArray'ın boyutlarını temsil etmek için kullanılan N Int'den oluşan bir NTuple.

LinearIndices(A::AbstractArray)

A ile aynı şekle ve axes sahip bir LinearIndices dizisi döndürür, A'daki her bir girişin lineer indeksini tutar. Bu diziyi kartezyen indekslerle indekslemek, bunları lineer indekslere eşleştirmeyi sağlar.

Geleneksel indeksleme ile diziler (indeksler 1'den başlar) veya herhangi bir çok boyutlu dizi için, lineer indeksler 1'den length(A)'ye kadar uzanır. Ancak, AbstractVector'lar için lineer indeksler axes(A, 1)'dir ve bu nedenle alışılmadık indekslemeye sahip vektörler için 1'den başlamaz.

Bu fonksiyonu çağırmak, lineer indekslemeyi kullanan algoritmalar yazmanın "güvenli" yoludur.

Örnekler

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

Belirtilen şekle veya axes ile aynı olan bir LinearIndices dizisi döndürür.

Örnekler

Bu yapıcının ana amacı, kartezyen indekslemeden lineer indekslemeye sezgisel bir dönüşümdür:

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)

Dizi A'ya indeksleme için I tuple'ını indekslerin bir tuple'ına dönüştürür.

Dönen tuple yalnızca A dizisi tarafından desteklenen Int veya skalar indekslerin AbstractArray'larını içermelidir. İşlenemeyen yeni bir indeks türü ile karşılaştığında hata verecektir.

Basit indeks türleri için, her bir indeks i'yi işlemek üzere dışa aktarılmamış Base.to_index(A, i) fonksiyonuna başvurur. Bu iç fonksiyon doğrudan çağrılmak üzere tasarlanmamıştır, ancak Base.to_index, özel dizi veya indeks türleri tarafından özel indeksleme davranışları sağlamak için genişletilebilir.

Daha karmaşık indeks türleri, hangi boyuta indeksleme yaptıkları hakkında daha fazla bağlama ihtiyaç duyabilir. Bu tür durumları desteklemek için, to_indices(A, I) to_indices(A, axes(A), I) fonksiyonunu çağırır; bu da verilen indeks tuple'ı ile A'nın boyutsal indekslerini birlikte yinelemeli olarak dolaşır. Bu nedenle, tüm indeks türlerinin Base.to_index'e geçiş yapacağı garanti edilmez.

Örnekler

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)) # sınır kontrolü yok
(1, 1, 2, 20)

julia> to_indices(A, (CartesianIndex((1,)), 2, CartesianIndex((3,4)))) # egzotik indeks
(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)) # şekil kontrolü yok
(1, 2)

checkbounds(Bool, A, I...)

Belirtilen indekslerin I, verilen dizi A için sınırlar içinde olup olmadığını kontrol etmek için true döner. AbstractArray'ın alt türleri, özel sınır kontrolü davranışları sağlamaları gerekiyorsa bu yöntemi özelleştirmelidir; ancak birçok durumda A'nın indekslerine ve checkindex yöntemine güvenilebilir.

Ayrıca bkz. checkindex.

Örnekler

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

Belirtilen indeksler I, verilen dizi A için sınırların dışındaysa bir hata fırlatır.

checkindex(Bool, inds::AbstractUnitRange, index)

Verilen index değeri inds sınırları içinde ise true döner. Tüm diziler için indeks olarak davranmak isteyen özel türler, özel bir sınır kontrolü uygulaması sağlamak amacıyla bu yöntemi genişletebilir.

Ayrıca bkz. checkbounds.

Örnekler

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

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

elsize(tip)

Verilen tip içinde saklanan eltype ardışık elemanları arasındaki bellek adımını bayt cinsinden hesaplar, eğer dizi elemanları yoğun bir şekilde ve uniform bir lineer adımla saklanıyorsa.

Örnekler

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

view(A, inds...)

getindex ile benzer, ancak belirtilen indeks veya indeksler inds üzerinde ana dizi A'ya tembel bir şekilde referans veren (veya etkili bir şekilde bir görünüm olan) hafif bir dizi döndürür; bu, elemanları hevesle çıkarmak veya kopyalanmış bir alt küme oluşturmak yerine. Döndürülen değere (SubArray(@ref) sıklıkla) getindex veya setindex! çağrıldığında, ana diziye erişmek veya onu değiştirmek için indeksler anında hesaplanır. view çağrıldıktan sonra ana dizinin şekli değiştirilirse davranış belirsizdir çünkü ana dizi için bir sınır kontrolü yoktur; örneğin, bu bir segmentasyon hatasına neden olabilir.

Bazı değişmez ana diziler (aralıklar gibi) bazı durumlarda SubArray döndürmek yerine yeni bir dizi yeniden hesaplamayı tercih edebilir, eğer bu verimli ve uyumlu bir anlam sağlıyorsa.

Örnekler

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 # Not A değişti, b'yi değiştirdiğimiz halde
2×2 Matrix{Int64}:
 0  2
 0  4

julia> view(2:5, 2:3) # tür değişmez olduğu için bir aralık döndürür
3:4

@view A[inds...]

İndeksleme ifadesi A[inds...]'i eşdeğer view çağrısına dönüştürün.

Bu yalnızca tek bir indeksleme ifadesine doğrudan uygulanabilir ve A[begin, 2:end-1] gibi özel begin veya end indeksleme sözdizimlerini içeren ifadeler için özellikle yararlıdır (çünkü bunlar normal view işlevi tarafından desteklenmez).

@view'in bir normal atamanın hedefi olarak kullanılamayacağını (örneğin, @view(A[1, 2:end]) = ...), ayrıca süslemesiz indeksli atama (A[1, 2:end] = ...) veya yayılmış indeksli atamanın (A[1, 2:end] .= ...) bir kopya oluşturmayacağını unutmayın. Ancak, @view(A[1, 2:end]) .+= 1 gibi güncelleme işlemleri için yararlı olabilir çünkü bu, @view(A[1, 2:end]) .= @view(A[1, 2:end]) + 1 için basit bir sözdizimidir ve sağdaki indeksleme ifadesi @view olmadan bir kopya oluşturacaktır.

Ayrıca, skalar olmayan indeksleme için bir kod bloğunun tamamını görünümler kullanacak şekilde değiştirmek için @views ile de bakabilirsiniz.

Örnekler

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 ifade

Verilen ifadede (bu bir begin/end bloğu, döngü, fonksiyon vb. olabilir) her dizi dilimleme işlemini bir görünüm döndürecek şekilde dönüştürün. Skalar indeksler, dizi olmayan türler ve açık getindex çağrıları (dizi[...] yerine) etkilenmez.

Benzer şekilde, @views dize dilimlerini SubString görünümlerine dönüştürür.

Örnekler

julia> A = zeros(3, 3);

julia> @views for row in 1:3
           b = A[row, :] # b bir görünüm, kopya değil
           b .= row      # her elemanı satır indeksine atayın
       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)

Görünümün temel ebeveyn nesnesini döndürür. SubArray, SubString, ReshapedArray veya LinearAlgebra.Transpose türündeki nesnelerin ebeveyni, nesne oluşturulurken view, reshape, transpose vb. için bir argüman olarak geçirilen nesnedir. Girdi bir sarmalanmış nesne değilse, girdiyi kendisi olarak döndürün. Girdi birden fazla kez sarılmışsa, yalnızca en dıştaki sarıcı kaldırılacaktır.

Örnekler

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

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

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

parentindices(A)

A görünümüne karşılık gelen parent içindeki indeksleri döndürür.

Örnekler

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

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

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

selectdim(A, d::Integer, i)

A'nın d boyutu için indeksinin i'ye eşit olduğu tüm verilerin bir görünümünü döndürür.

i'nin d konumunda olduğu view(A,:,:,...,i,:,:,...) ile eşdeğerdir.

Ayrıca bkz: eachslice.

Örnekler

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)

İkili verinin x isbits değerindeki tür yorumlamasını isbits türü Out olarak değiştirir. Out'un boyutu (doldurma hariç) x türünün boyutuyla aynı olmalıdır. Örneğin, reinterpret(Float32, UInt32(7)) UInt32(7) ile ilişkili 4 baytı bir Float32 olarak yorumlar. reinterpret(In, reinterpret(Out, x)) === x olduğunu unutmayın.

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)

!!! uyarı Out içindeki bazı bit kombinasyonları geçerli olarak kabul edilmediğinde ve türün yapıcıları ve yöntemleri tarafından engellenmediğinde dikkatli olun. Ek doğrulama olmadan beklenmedik davranışlar ortaya çıkabilir.

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

Verilen dizinin aynı ikili verilerine sahip bir görünümünü oluşturur, ancak T eleman türü olarak kullanılır.

Bu işlev, elemanları açıkça alınana kadar hesaplanmayan "tembel" diziler üzerinde de çalışır. Örneğin, reinterpret aralığı 1:6 üzerinde, yoğun vektör collect(1:6) üzerinde olduğu gibi çalışır:

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

Eğer T ile eltype(A) arasındaki dolgu bitlerinin konumu hizalanmazsa, sonuçta oluşan dizi yalnızca okunabilir veya yalnızca yazılabilir olacaktır; bu, geçersiz bitlerin yazılmasını veya okunmasını önlemek içindir.

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

julia> a[1] = 3
HATA: Tuple{UInt8, UInt32} türünün dolgusu UInt32 türü ile uyumlu değildir.

julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # gösterim hatası verecektir

julia> b[1]
HATA: UInt32 türünün dolgusu Tuple{UInt8, UInt32} türü ile uyumlu değildir.

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

A'nın tür yorumlamasını değiştirirken "kanal boyutu" ekleyin veya çıkarın.

Eğer sizeof(T) = n*sizeof(S) ve n>1 ise, A'nın ilk boyutu n boyutunda olmalı ve B, A'nın ilk boyutunu içermez. Tersine, eğer sizeof(S) = n*sizeof(T) ve n>1 ise, B yeni bir ilk boyut alır ve bu boyut n'dir. Eğer sizeof(T) == sizeof(S) ise, boyut değişmez.

Örnekler

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

julia> reinterpret(reshape, Complex{Int}, A)    # sonuç bir vektördür
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)             # sonuç bir matristir
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

A ile aynı verilere sahip, ancak farklı boyutlara veya boyut sayısına sahip bir dizi döndürün. İki dizi aynı temel verileri paylaştığı için, sonuç yalnızca A değiştirilebilir ise değiştirilebilir ve birinin elemanlarını ayarlamak diğerinin değerlerini değiştirir.

Yeni boyutlar, ya bir argüman listesi olarak ya da bir şekil demeti olarak belirtilebilir. En fazla bir boyut : ile belirtilebilir; bu durumda, uzunluğu, belirtilen tüm boyutlarla çarpımının orijinal dizi A'nın uzunluğuna eşit olacak şekilde hesaplanır. Toplam eleman sayısı değişmemelidir.

Örnekler

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)

A ile aynı verilere sahip bir dizi döndürür, ancak dims ile belirtilen boyutlar kaldırılmıştır. size(A,d) her d için 1 olmalıdır ve tekrar eden boyutlar veya 1:ndims(A) dışındaki sayılar yasaktır.

Sonuç, A ile aynı temel verilere sahiptir; bu nedenle sonuç, yalnızca A değiştirilebilir olduğunda değiştirilebilir ve birinin elemanlarını ayarlamak diğerinin değerlerini değiştirir.

Ayrıca bkz: reshape, vec.

Örnekler

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

Diziyi a'yı bir boyutlu bir sütun vektörü olarak yeniden şekillendirir. Eğer a zaten bir AbstractVector ise a'yı döndürür. Elde edilen dizi, a ile aynı temel veriyi paylaşır, bu nedenle yalnızca a değiştirilebilir ise değiştirilebilir olacaktır; bu durumda birini değiştirmek diğerini de değiştirecektir.

Örnekler

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

Ayrıca reshape, dropdims bakınız.

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

N-boyutlu bir üst diziye (tipi P) bir ana diziye bakış, bir indeksler demeti (tipi I) ile kısıtlanmış bir eleman tipi T ile. L, hızlı lineer indekslemeyi destekleyen türler için doğrudur ve aksi takdirde yanlıştır.

SubArray'ları view fonksiyonu kullanarak oluşturun.

cat(A...; dims)

Girdi dizilerini dims'de belirtilen boyutlar boyunca birleştirir.

Bir d boyutunda dims içinde, çıktı dizisinin boyutu sum(size(a,d) for a in A)'dir. Diğer boyutlar boyunca, tüm girdi dizilerinin aynı boyutta olması gerekir; bu da o boyutlar boyunca çıktı dizisinin boyutunu belirler.

Eğer dims tek bir sayı ise, farklı diziler o boyut boyunca sıkı bir şekilde paketlenir. Eğer dims birden fazla boyut içeren bir iterable ise, bu boyutlar boyunca pozisyonlar her girdi dizisi için aynı anda artırılır ve diğer yerler sıfır ile doldurulur. Bu, cat(matrices...; dims=(1,2)) şeklinde blok-diagonal matrisler oluşturmayı sağlar ve bunların daha yüksek boyutlu analoglarını da.

Özel durum dims=1 vcat ve dims=2 hcat olarak tanımlanır. Ayrıca hvcat, hvncat, stack, repeat ile de bakılabilir.

Anahtar kelime ayrıca Val(dims)'i de kabul eder.

Örnekler

Farklı boyutlarda iki diziyi birleştirin:

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

Genişletilmiş Yardım

3D dizileri birleştirin:

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

Farklı boyutlardaki dizileri birleştirin:

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

Bir blok diagonal matris oluşturun:

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

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

julia> a = "aaa";

julia> b = "bbb";

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

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

julia> a * b
"aaabbb"

vcat(A...)

Dizileri veya sayıları dikey olarak birleştirir. cat(A...; dims=1) ile eşdeğerdir ve [a; b; c] sözdizimine eşdeğerdir.

Büyük bir dizi dizisini birleştirmek için, reduce(vcat, A) A isa AbstractVector{<:AbstractVecOrMat} olduğunda verimli bir yöntem çağırır, çiftler halinde çalışmak yerine.

Ayrıca hcat, Iterators.flatten, stack ile de ilgili.

Örnekler

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

julia> v == vcat(1, 2, [3,4])  # sayıları kabul eder
true

julia> v == [1; 2; [3,4]]  # aynı işlemi yapmak için sözdizimi
true

julia> summary(ComplexF64[1; 2; [3,4]])  # eleman türünü sağlamak için sözdizimi
"4-element Vector{ComplexF64}"

julia> vcat(range(1, 2, length=3))  # tembel aralıkları toplar
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> two = ([10, 20, 30]', Float64[4 5 6; 7 8 9])  # satır vektörü ve bir matris
([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)  # vcat(vs...)' den daha verimli
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

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

hcat(A...)

Dizileri veya sayıları yatay olarak birleştirir. cat(A...; dims=2) ile eşdeğerdir ve [a b c] veya [a;; b;; c] sözdizimine eşdeğerdir.

Büyük bir dizi vektörü için, reduce(hcat, A) A isa AbstractVector{<:AbstractVecOrMat} olduğunda verimli bir yöntemi çağırır. Vektörler için bu ayrıca stack(A) olarak da yazılabilir.

Ayrıca vcat, hvcat ile de bakabilirsiniz.

Örnekler

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]')  # sayıları kabul eder
1×7 Matrix{Int64}:
 1  2  30  40  5  6  7

julia> ans == [1 2 [30 40] [5, 6, 7]']  # aynı işlemi yapmak için sözdizimi
true

julia> Float32[1 2 [30 40] [5, 6, 7]']  # eltipi sağlamak için sözdizimi
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)  # hcat(ms...)'ten daha verimli
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  # matris vektörü üzerinde anlaşmazlık
"2×2×3 Array{Float64, 3}"

julia> hcat(Int[], Int[], Int[])  # boyutu (0,) olan boş vektörler
0×3 Matrix{Int64}

julia> hcat([1.1, 9.9], Matrix(undef, 2, 0))  # boş 2×0 Matris ile hcat
2×1 Matrix{Any}:
 1.1
 9.9

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

Tek bir çağrıda yatay ve dikey birleştirme. Bu fonksiyon blok matris sözdizimi için çağrılır. İlk argüman, her blok satırında birleştirilecek argüman sayısını belirtir. İlk argüman tek bir tamsayı n ise, tüm blok satırlarının n blok sütuna sahip olduğu varsayılır.

Örnekler

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

Birçok values'ı tek bir çağrıda yatay, dikey ve n-boyutlu birleştirme.

Bu fonksiyon blok matris sözdizimi için çağrılır. İlk argüman, bir tuple olarak birleştirmenin şeklinin belirlenmesini sağlar veya her eksen boyunca anahtar sayıdaki elemanları belirten boyutları belirtir ve çıktı boyutlarını belirlemek için kullanılır. dims biçimi daha performanslıdır ve birleştirme işlemi her eksen boyunca aynı sayıda eleman olduğunda varsayılan olarak kullanılır (örneğin, [a b; c d;;; e f ; g h]). shape biçimi, her eksen boyunca eleman sayısının dengesiz olduğu durumlarda kullanılır (örneğin, [a b ; c]). Dengesiz sözdizimi ek doğrulama yükü gerektirir. dim biçimi yalnızca bir boyut boyunca birleştirme için bir optimizasyondur. row_first, values'ın nasıl sıralandığını belirtir. shape'ın birinci ve ikinci elemanlarının anlamı da row_first'a göre değiştirilir.

Örnekler

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

Argümanların oluşturulması için örnekler

[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 = her satırdaki elemanlar (2, 1, 1)
 _______     _
 3           1 = her sütundaki elemanlar (3, 1)
 _____________
 4             = her 3d dilimdeki elemanlar (4,)
 _____________
 4             = her 4d dilimdeki elemanlar (4,)
⇒ shape = ((2, 1, 1), (3, 1), (4,), (4,)) ile `row_first` = true

stack(iter; [dims])

Eşit boyutlara sahip bir dizi (veya diğer yineleyici nesneler) koleksiyonunu, bir veya daha fazla yeni boyut boyunca düzenleyerek daha büyük bir dizi haline getirir.

Varsayılan olarak, elemanların eksenleri önce yerleştirilir, bu da size(result) = (size(first(iter))..., size(iter)...) sonucunu verir. Bu, Iterators.flatten(iter) ile aynı eleman sırasına sahiptir.

dims::Integer anahtar kelimesi ile, iter'in i'nci elemanı, result'ın dilimlerini selectdim(result, dims, i) haline getirir, böylece size(result, dims) == length(iter) olur. Bu durumda stack, aynı dims ile eachslice` işleminin tersini gerçekleştirir.

Çeşitli cat fonksiyonları da dizileri birleştirir. Ancak, bunlar dizilerin mevcut (belki de önemsiz) boyutlarını uzatır, yeni boyutlar boyunca dizileri yerleştirmek yerine. Ayrıca, dizileri ayrı argümanlar olarak kabul ederler, tek bir koleksiyon yerine.

Örnekler

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))  # her türlü yineleyici kabul eder
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)  # herhangi bir cat fonksiyonunun aksine, vecs[1]'in 1. ekseni sonucun 2. eksenidir
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)  # eachslice'in tersidir
true

Daha yüksek boyutlu örnekler:

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

julia> E = eachslice(A, dims=2);  # matrislerin bir vektörü

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  # tüm boyutları korur
(2, 3, 5, 7)

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

julia> hvcat(5, M...) |> size  # hvcat matrisleri yan yana koyar
(14, 15)

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

Bir koleksiyonun her bir elemanına bir fonksiyon uygulayın ve sonucu stack edin. Veya birden fazla koleksiyonu, zip ile birleştirerek.

Fonksiyon, hepsi aynı boyutta olan diziler (veya demetler, veya diğer iteratörler) döndürmelidir. Bunlar, sonuçların dilimlerini oluşturur ve her biri dims (verilmişse) veya varsayılan olarak son boyutlar boyunca ayrılır.

Ayrıca mapslices, eachcol ile de bakabilirsiniz.

Örnekler

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

Bir Vector oluşturur, eleman türü argümanın promote_typeof'undan hesaplanır ve argüman listesini içerir.

Örnekler

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

circshift(A, shifts)

Diziyi dairesel olarak kaydırır, yani döndürür. İkinci argüman, her boyutta kaydırma miktarını veren bir demet veya vektör ya da yalnızca birinci boyutta kaydırmak için bir tam sayıdır.

Ayrıca bakınız: circshift!, circcopy!, bitrotate, <<.

Örnekler

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)

Dairesel kaydırma, yani döndürme, src içindeki verileri kaydırarak sonucu dest içinde saklar. shifts, her boyutta kaydırma miktarını belirtir.

Ayrıca bkz. circshift.

circcopy!(dest, src)

src'yi dest'ye kopyalar, her boyutu uzunluğuna göre modül alarak indeksler. src ve dest aynı boyutta olmalıdır, ancak indekslerinde kaydırma olabilir; herhangi bir kaydırma (dairesel) sarılmaya neden olur. Eğer diziler örtüşen indekslere sahipse, o örtüşme alanında dest, src ile aynı olur.

Ayrıca bkz: circshift.

Örnekler

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)

A'nın true indekslerini veya anahtarlarını içeren bir vektör I döndürür. Eğer A'da böyle bir eleman yoksa, boş bir dizi döndürülür. Diğer türdeki değerleri aramak için, ilk argüman olarak bir predikat geçirin.

İndeksler veya anahtarlar, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Ayrıca bakınız: findfirst, searchsorted.

Örnekler

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)

f(A[I]) true döndüren A'nın indekslerinin veya anahtarlarının I'den oluşan bir vektör I döndürür. Eğer A'nın böyle bir elemanı yoksa, boş bir dizi döndürür.

İndeksler veya anahtarlar, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Örnekler

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)

A içindeki ilk true değerinin indeksini veya anahtarını döndürür. Böyle bir değer bulunamazsa nothing döner. Diğer türdeki değerleri aramak için, ilk argüman olarak bir predikat geçirin.

İndeksler veya anahtarlar, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Ayrıca bakınız: findall, findnext, findlast, searchsortedfirst.

Örnekler

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

julia> findfirst(A)
3

julia> findfirst(falses(3)) # hiçbir şey döner, ancak REPL'de yazdırılmaz

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

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

findfirst(predicate::Function, A)

predicate doğru döndüğü A'nın ilk elemanının indeksini veya anahtarını döndürür. Böyle bir eleman yoksa nothing döner.

İndeksler veya anahtarlar, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Örnekler

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) # hiçbir şey döndürmez, ancak REPL'de yazdırılmaz

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)

A içindeki son true değerinin indeksini veya anahtarını döndürür. A içinde true değeri yoksa nothing döner.

İndeksler veya anahtarlar, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Ayrıca bakınız: findfirst, findprev, findall.

Örnekler

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) # hiçbir şey döndürmez, ancak REPL'de yazdırılmaz

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

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

findlast(predicate::Function, A)

predicate doğru döndüğü A'nın son elemanının indeksini veya anahtarını döndürür. Böyle bir eleman yoksa nothing döner.

İndeksler veya anahtarlar, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Örnekler

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) # nothing döner, ama REPL'de yazdırılmaz

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

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

findnext(A, i)

A içindeki true elemanının i'den sonraki veya i dahil indeksini bulur, eğer bulunamazsa nothing döner.

İndeksler, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Örnekler

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

julia> findnext(A, 1)
3

julia> findnext(A, 4) # bulunamaz, ancak REPL'de yazdırılmaz

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)

predicate'in true döndüğü A'nın bir elemanının i'den sonraki veya i dahil indeksini bulur, eğer bulunamazsa nothing döner. Bu, getindex, keys(A) ve nextind destekleyen Diziler, String'ler ve diğer çoğu koleksiyon için çalışır.

İndeksler, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Örnekler

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

julia> findnext(isodd, A, 1)
1

julia> findnext(isodd, A, 2) # nothing döner, ama REPL'de yazdırılmaz

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)

A içindeki true elemanının i'den önceki veya i dahil indeksini bulur, eğer bulunamazsa nothing döner.

İndeksler, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Ayrıca bakınız: findnext, findfirst, findall.

Örnekler

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

julia> findprev(A, 3)
3

julia> findprev(A, 1) # hiçbir şey döner, ancak REPL'de yazdırılmaz

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)

predicate doğru döndüren A'nın i'den önceki veya i dahilindeki bir elemanının önceki indeksini bulur, eğer bulunamazsa nothing döner. Bu, getindex, keys(A) ve nextind destekleyen Diziler, String'ler ve diğer çoğu koleksiyon için çalışır.

İndeksler, keys(A) ve pairs(A) tarafından döndürülenlerle aynı türdedir.

Örnekler

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

julia> findprev(isodd, A, 1) # hiçbir şey döner, ancak REPL'de yazdırılmaz

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)

Dizinin boyutlarını (ekseni) A dizisinde permütasyon yapın. perm, ndims(A) tamsayılarından oluşan bir demet veya vektördür ve permütasyonu belirtir.

Eğer A 2 boyutlu bir dizi (AbstractMatrix) ise, perm varsayılan olarak (2,1) değerini alır ve A'nın iki eksenini (matrisin satır ve sütunlarını) değiştirir. Bu, transpose ile farklıdır çünkü işlem özyinelemeli değildir; bu, özellikle özyinelemeli transpose hataya neden olacağı için sayısal olmayan değerler içeren diziler ve/veya lineer operatörleri temsil etmeyen 2 boyutlu diziler için özellikle yararlıdır.

1 boyutlu diziler için permutedims(v::AbstractVector) bakın; bu, 1 satırlık bir “matris” döndürür.

Ayrıca permutedims!, PermutedDimsArray, transpose, invperm ile ilgili daha fazla bilgiye bakın.

Örnekler

2 boyutlu diziler:

transpose'dan farklı olarak, permutedims, 2 boyutlu dizilerin satır ve sütunlarını, örneğin dizeler gibi, rastgele sayısal olmayan elemanlarla değiştirmek için kullanılabilir:

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"

Ve permutedims, elemanları kendileri sayısal matrisler olan matrisler için transpose'dan farklı sonuçlar üretir:

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]

Çok boyutlu diziler

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); # son boyutu ilk sıraya koy

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)) # ters permütasyon
true

B = permutedims(A, perm) için her bir boyut i'de, A'nın karşılık gelen boyutu perm[i] olacaktır. Bu, size(B, i) == size(A, perm[i]) eşitliğinin geçerli olduğu anlamına gelir.

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)

Vektörü v 1 × length(v) satır matrisine yeniden şekillendirir. transpose ile farklıdır çünkü işlem özyinelemeli değildir; bu, özellikle özyinelemeli transpose'ın hata verebileceği sayısal olmayan değerlerin dizileri için özellikle yararlıdır.

Örnekler

transpose'dan farklı olarak, permutedims rastgele sayısal olmayan öğelerin vektörlerinde, örneğin dizelerde kullanılabilir:

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

Sayılardan oluşan vektörler için, permutedims(v) transpose(v) ile çok benzer şekilde çalışır, tek fark dönüş türünün farklı olmasıdır (bir LinearAlgebra.Transpose görünümü yerine reshape kullanır, ancak her ikisi de orijinal dizi v ile belleği paylaşır):

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; # p veya r'yi değiştirmek v'yi de değiştirir

julia> v # hem p hem de r ile belleği paylaşır
4-element Vector{Int64}:
 5
 6
 3
 4

Ancak, permutedims sayısal matrislerden oluşan vektörler için transpose'dan farklı sonuçlar üretir:

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)

Dizi src'nin boyutlarını permütasyon yaparak dest dizisine kaydedin. perm, ndims(src) uzunluğunda bir permütasyonu belirten bir vektördür. Önceden tahsis edilmiş dest dizisinin size(dest) == size(src)[perm] olmalı ve tamamen üzerine yazılmalıdır. Yerinde permütasyon desteklenmez ve src ile dest'in bellek bölgeleri örtüşüyorsa beklenmedik sonuçlar ortaya çıkabilir.

Ayrıca bkz. permutedims.

PermutedDimsArray(A, perm) -> B

Bir AbstractArray A verildiğinde, boyutların permütasyonlu göründüğü bir görünüm B oluşturun. permutedims ile benzer, ancak kopyalama gerçekleşmez (B, A ile depolama paylaşır).

Ayrıca bkz. permutedims, invperm.

Örnekler

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)

İki dizi şeklinin uyumluluğunu kontrol eder, sonlanan tekil boyutlara izin verir ve daha fazla boyuta sahip olan şekli döndürür.

Örnekler

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

Aynı boyutta A'nın dims boyutu boyunca op işlemi. dims vektörler için isteğe bağlıdır. İsteğe bağlı olarak bir başlangıç değeri init anahtar argümanı ile sağlanabilir. Önceden tahsis edilmiş bir çıktı dizisi kullanmak için accumulate! ile performans ve çıktının hassasiyetini kontrol etmek (örneğin taşmayı önlemek için) için de bakın.

Yaygın işlemler için accumulate'in özel varyantları vardır, bkz. cumsum, cumprod. Tembel bir versiyon için bkz. Iterators.accumulate.

Örnekler

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

Kümülatif işlem op'u A üzerinde dims boyutu boyunca gerçekleştirir ve sonucu B'ye kaydeder. Vektörler için dims sağlamak isteğe bağlıdır. Eğer init anahtar kelime argümanı verilirse, değeri birikimi başlatmak için kullanılır.

Ayrıca bkz. accumulate, cumsum!, cumprod!.

Örnekler

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)

Boyut dim boyunca kümülatif çarpım. Önceden tahsis edilmiş bir çıktı dizisi kullanmak için cumprod! ile de bakabilirsiniz, bu hem performans hem de çıktının hassasiyetini kontrol etmek için (örneğin taşmayı önlemek için) faydalıdır.

Örnekler

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)

Bir iteratörün kümülatif çarpımı.

Ayrıca bkz. cumprod!, accumulate, cumsum.

Örnekler

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)

A'nın dims boyutu boyunca kümülatif çarpımını alır ve sonucu B'ye kaydeder. Ayrıca cumprod bakınız.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

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

Bir vektör x'in kümülatif çarpımını alır ve sonucu y'ye kaydeder. Ayrıca bkz. cumprod.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

cumsum(A; dims::Integer)

Boyut dims boyunca kümülatif toplam. Önceden tahsis edilmiş bir çıktı dizisi kullanmak için cumsum! ile birlikte performans ve çıktının hassasiyetini kontrol etmek için de kullanılabilir (örneğin, taşmayı önlemek için).

Örnekler

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)

Bir iteratörün kümülatif toplamı.

Ayrıca + dışında fonksiyonlar uygulamak için accumulate bakın.

Örnekler

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)

A'nın dims boyutu boyunca kümülatif toplamını alır ve sonucu B'ye kaydeder. Ayrıca bkz. cumsum.

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

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

Bir vektör veya çok boyutlu bir dizi A üzerindeki sonlu fark operatörü. İkinci durumda, işlem yapılacak boyut dims anahtar kelime argümanı ile belirtilmelidir.

Örnekler

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

Diziyi A'yı her boyutta belirtilen counts sayısı kadar tekrar ederek bir dizi oluşturur.

Ayrıca bakınız: fill, Iterators.repeated, Iterators.cycle.

Örnekler

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

A::AbstractArray'ı tekrar ederek bir dizi oluşturun. inner'ın i'inci elemanı, A'nın i'inci boyutunun bireysel girişlerinin kaç kez tekrar edileceğini belirtir. outer'ın i'inci elemanı, A'nın i'inci boyutu boyunca bir dilimin kaç kez tekrar edileceğini belirtir. inner veya outer atlandığında, tekrar yapılmaz.

# Örnekler

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

Bir dizeyi r kez tekrarlar. Bu, s^r olarak yazılabilir.

Ayrıca bkz. ^.

Örnekler

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

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

Bir karakteri r kez tekrarlar. Bu, c^r çağrılarak da eşdeğer şekilde gerçekleştirilebilir.

Örnekler

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

rot180(A)

Matris A'yı 180 derece döndür.

Örnekler

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)

Matris A'yı 180 derece döndür ve k kadar tam sayı ile döndür. Eğer k çift ise, bu bir kopya ile eşdeğerdir.

Örnekler

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)

Matris A'yı sola 90 derece döndür.

Örnekler

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)

Matris A'yı k kadar tam sayı ile saat yönünün tersine 90 derece sola döndürür. Eğer k dörtün katı (sıfır dahil) ise, bu bir copy ile eşdeğerdir.

Örnekler

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)

Matris A'yı sağa 90 derece döndür.

Örnekler

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)

Matris A'yı saat yönünde k kez 90 derece döndürür. Eğer k dörtün katıysa (sıfır dahil), bu bir copy ile eşdeğerdir.

Örnekler

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)

Verilen A dizisinin boyutlarını, her bir dilim için A[..., :, ..., :, ...] biçiminde bir fonksiyon f uygulayarak dönüştürür. Sonuçlar, kalan boyutlar boyunca birleştirilir.

Örneğin, eğer dims = [1,2] ve A 4 boyutlu ise, f, tüm i ve j için x = A[:,:,i,j] üzerinde çağrılır ve f(x) sonucu R[:,:,i,j] olur.

Ayrıca eachcol veya eachslice ile birlikte kullanılan map veya stack ile de bakabilirsiniz.

Örnekler

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

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

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

julia> f(x::Matrix) = fill(x[1,1], 1,4);  # 1×4 matris döner

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];  # bir sayı döner

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

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

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

eachslice(A; dims=2) ifadesinde, belirtilen boyut, dilimde noktasız olan boyuttur. Bu, view(A,:,i,:) iken, mapslices(f, A; dims=(1,3)) A[:,i,:] kullanır. Fonksiyon f, dilimdeki değerleri değiştirerek A'yı etkilemeden çalışabilir.

eachrow(A::AbstractVecOrMat) <: AbstractVector

Bir matris veya vektör A'nın satırlarının bir vektörü olan bir RowSlices nesnesi oluşturur. Satır dilimleri, A'nın AbstractVector görünümleri olarak döndürülür.

Tersi için, stack(rows; dims=1)'e bakın.

Ayrıca eachcol, eachslice ve mapslices ile de ilgilidir.

Örnekler

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

Bir matris veya vektör A'nın sütunlarının bir vektörü olan bir ColumnSlices nesnesi oluşturur. Sütun dilimleri, A'nın AbstractVector görünümleri olarak döndürülür.

Tersi için stack(cols) veya reduce(hcat, cols)'a bakın.

Ayrıca eachrow, eachslice ve mapslices ile de ilgilidir.

Örnekler

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)

Bir Slices nesnesi oluşturur; bu nesne, A'nın dims boyutları üzerindeki dilimlerin bir dizisidir ve A'daki diğer boyutlardan tüm verileri seçen görünümler döndürür. dims ya bir tamsayı ya da tamsayılar tuple'ı olabilir.

Eğer drop = true (varsayılan), dıştaki Slices iç boyutları atar ve boyutların sıralaması dims'deki gibi olur. Eğer drop = false ise, Slices temel dizinin aynı boyutluluğuna sahip olur ve iç boyutların boyutu 1'dir.

eachslice(A; dims::Integer)'ın tersini görmek için stack(slices; dims)'e bakın.

Ayrıca eachrow, eachcol, mapslices ve selectdim ile de ilgilidir.

Örnekler

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)

v'nin ters permütasyonunu döndürür. Eğer B = A[v] ise, o zaman A == B[invperm(v)] olur.

Ayrıca bkz. sortperm, invpermute!, isperm, permutedims.

Örnekler

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

v geçerli bir permütasyon ise true döndür.

Örnekler

julia> isperm([1; 2])
true

julia> isperm([1; 3])
false

permute!(v, p)

Vektörü v yerinde, permütasyon p'ye göre permüte et. p'nin bir permütasyon olduğunu doğrulamak için herhangi bir kontrol yapılmaz.

Yeni bir permütasyon döndürmek için v[p] kullanın. Bu genellikle permute!(v, p)'den daha hızlıdır; önceden tahsis edilmiş bir çıktı dizisine u .= @view v[p] ile yazmak daha da hızlıdır. (permute! yerinde v'yi üst üste yazsa da, içsel olarak hangi elemanların taşındığını takip etmek için bazı tahsisatlar gerektirir.)

!!! uyarı Herhangi bir değiştirilmiş argümanın başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Ayrıca invpermute! bakın.

Örnekler

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)

permute! gibi, ancak verilen permütasyonun tersini uygular.

Eğer önceden tahsis edilmiş bir çıktı diziniz varsa (örneğin u = similar(v)), u[p] = v kullanmak daha hızlıdır. (invpermute! verilerin bir kopyasını dahili olarak tahsis eder.)

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

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

A'yı dims boyutu boyunca ters çevirir; bu, bir tam sayı (tek bir boyut), bir tam sayı demeti (bir boyut demeti) veya : (tüm boyutlar boyunca ters çevir, varsayılan) olabilir. Yerinde ters çevirme için ayrıca reverse! bakın.

Örnekler

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)

Bir i indeksi reverse(v) içinde verildiğinde, v[reverseind(v,i)] == reverse(v)[i] olacak şekilde v içindeki karşılık gelen indeksi döndürün. (Bu, v'nin ASCII olmayan karakterler içerdiği durumlarda karmaşık olabilir.)

Örnekler

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

Yerinde versiyonu reverse.

Örnekler

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

reverse gibi, ancak A içinde yerinde çalışır.