Referensi Referensi | juliablogger.com – Beragampengetahuan

Oleh: Blog Bogumił Kamiński

Repost dari:

Hari ini saya ingin membahas tentang Ref type didefinisikan di Base Julia.
Alasannya, sering digunakan dalam praktik, tetapi tidak langsung
jelas apa desain di balik Ref Menjadi.

Saya akan fokus pada pengantar dasar topik dan melewatkannya
Masalah yang lebih lanjut seringkali tidak diperlukan saat bekerja dengannya
Julia.

Posting ini ditulis di bawah Julia 1.9.0-rc2.

Sebagai pengguna Julia biasa, ada dua situasi yang mungkin Anda temui Ref:
menyiarkan dan mengizinkan mutasi.

Penyiaran

Kasus pertama adalah selama siaran ketika Anda ingin menyimpan beberapa objek menjadi satu
Kontainer 0 dimensi melindungi isinya agar tidak terdistribusi.
Berikut adalah contoh tipikal:

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

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

julia> Ref(x) .* y
3-element Vector{Vector{Int64}}:
 [2, 4, 6]
 [3, 6, 9]
 [4, 8, 12]

Perhatikan bahwa saya bungkus x DI DALAM Ref untuk memastikan bahwa keseluruhan x vektor dikalikan
oleh unsur-unsur dari y. Jika saya melewatkan Ref Saya akan menerima produk sesuai dengan unsur
x Dan y:

julia> x .* y
3-element Vector{Int64}:
  2
  6
 12

Alasan mengapa Ref digunakan dalam kasus tersebut adalah Ref efek minimal pada
jenis hasil operasi yang disiarkan. Pertimbangkan contoh ini:

julia> z = (2, 3, 4)
(2, 3, 4)

julia> [x] .* z
3-element Vector{Vector{Int64}}:
 [2, 4, 6]
 [3, 6, 9]
 [4, 8, 12]

julia> Ref(x) .* z
([2, 4, 6], [3, 6, 9], [4, 8, 12])

Di sini saya telah dilindungi x saat mengalikannya dengan elemen tuple z.
Saya bisa melindungi x dengan membungkusnya dengan vektor, tetapi, seperti yang Anda lihat
maka hasil operasi akan menjadi vektor dari vektor tersebut. Ketika
kemasan x DI DALAM Ref hasilnya adalah sekumpulan vektor.
Seperti yang Anda lihat, gunakan Ref Terapkan mekanisme siaran menggunakan tipe
wadah lain untuk menentukan jenis keluaran, yang sering diinginkan.

Izinkan mutasi

Kegunaan lain dari Ref adalah ketika kita memiliki tipe yang tidak dapat diubah yang kita inginkan
untuk bermutasi 😄. Ini mungkin terdengar aneh, tetapi terkadang itu sangat membantu.

Izinkan saya memberi Anda contoh sederhana:

julia> struct X
           value::Int
           callcount::Base.RefValue{Int}

           X(x) = new(Int(x), Ref(0))
       end

julia> f(x::X) = (x.callcount[] += 1; x)
f (generic function with 1 method)

julia> x = X(10)
X(10, Base.RefValue{Int64}(0))

julia> f(x)
X(10, Base.RefValue{Int64}(1))

julia> f(x)
X(10, Base.RefValue{Int64}(2))

julia> f(x)
X(10, Base.RefValue{Int64}(3))

Di sini saya telah mendefinisikan X ketik yang menyimpan nilai yang ingin saya ubah,
dan sekolah tambahan callcount hitung berapa kali fungsi f dulu
memanggil objek ini. Dari Int tidak dapat diubah, saya harus membungkusnya dengan Ref
untuk mencapai terobosan bidang ini.

Sebagai catatan tambahan, ini bukan satu-satunya cara untuk mendapatkan efek semacam ini. Misalnya,
Saya dapat mendefinisikan a mutable struct dengan const bidang value. Masih dalam beberapa
kasus Ref berguna karena dapat berubah. Perhatikan bahwa saya telah mengakses dan memperbarui
nilai disimpan di Ref gunakan pengindeksan kosong x.callcount[] (yaitu tanda kurung
tidak ada nilai di dalamnya).

Dalam contoh sebelumnya saya katakan saya bicarakan Reftetapi dalam definisi
itu X yang saya gunakan callcount::Base.RefValue{Int} alih-alih. Ini sulit
bagian. Ref adalah tipe abstrak parameter. Ini berarti bahwa tidak ada objek yang dapat memiliki
Ref jenis. Ref adalah simpul non-daun di pohon tipe Julia. Mari kita periksa
subkategori:

julia> subtypes(Ref)
6-element Vector{Any}:
 Base.CFunction
 Base.RefArray
 Base.RefValue
 Core.Compiler.RefValue
 Core.LLVMPtr
 Ptr

Seperti yang Anda lihat, ada enam tipe yang merupakan subtipe dari Ref. Dan inilah dia
kenapa saya bilang saya ingin postingan kita hari ini entry level. Saya hanya akan berbicara
Tentang RefValue Dan RefArray. Saya menghilangkan opsi lain karena memang begitu
jarang dibutuhkan (kecuali jika Anda melakukan hal-hal tingkat rendah di Julia, tapi mungkin
Anda tidak perlu membaca artikel ini 😄).

Yang sulit adalah ketika kita menulis Ref(1) kita tidak mendapatkan objek
Tipe siapa? Reftetapi sebaliknya a RefValue (ini adalah subtipe dari Ref):

julia> v1 = Ref(1)
Base.RefValue{Int64}(1)

julia> v1[]
1

Demikian pula, kita dapat memiliki referensi ke elemen array. Pada kasus ini
kami melewatkan array sebagai argumen pertama Ref dan indeks sebagai yang kedua:

julia> v2 = Ref([2, 3, 4], 2)
Base.RefArray{Int64, Vector{Int64}, Nothing}([2, 3, 4], 2, nothing)

julia> v2[]
3

Anda bisa memikirkannya Ref sebagai cara mudah untuk menangani kedua kasus (membungkus nilai
dan bungkus elemen array) dalam satu sintaks.

Ada perbedaan antara RefValue Dan RefArray meskipun. RefValue
sebenarnya menjamin mutabilitas wadah seperti yang kita lihat pada contoh
di atas dengan X struktur. Cobalah untuk bertransformasi RefArray akan mencoba untuk berubah
susunan di bawah ini. Oleh karena itu, kode berikut gagal:

julia> v3 = Ref(2:4, 2)
Base.RefArray{Int64, UnitRange{Int64}, Nothing}(2:4, 2, nothing)

julia> v3[] = 10
ERROR: CanonicalIndexError: setindex! not defined for UnitRange{Int64}

Sementara kode ini berfungsi:

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

julia> v4 = Ref(a, 2)
Base.RefArray{Int64, Vector{Int64}, Nothing}([2, 3, 4], 2, nothing)

julia> v4[]
3

julia> v4[] = 100
100

julia> v4
Base.RefArray{Int64, Vector{Int64}, Nothing}([2, 100, 4], 2, nothing)

julia> a
3-element Vector{Int64}:
   2
 100
   4

dan kita bisa melihat itu a larik telah diubah.

Hal-hal penting yang perlu diingat Ref Menjadi:

• Penggunaan utamanya adalah penyiaran dan saat kita membutuhkan wadah yang bisa diubah sedikit.
• Ref abstrak, ketika Anda menulis Ref(x) Anda tidak mendapatkannya Ref Misalnya. Alih-alih
  Anda akan menerima RefValue (dapat berubah sewaktu-waktu).
• Ada subtipe lain dari Ref dibandingkan RefValue. Anda akan jarang membutuhkannya.
  Di antara opsi lainnya, yang mungkin paling sering Anda gunakan adalah RefArrayyang
  membuat referensi ke satu elemen dari array yang mendasarinya.

Saya harap Anda menemukan artikel ini referensi yang berguna. Karena Ref.

Terkait