Modifikasi di tempat | beragampengetahuan.com – Beragampengetahuan

Oleh: Jonathan Carroll

Diposting ulang dari:

Pada postingan kali ini saya mengeksplorasi beberapa perbedaan antara R, python, Julia dan APL
tentang kemungkinan perubahan dan mencoba menciptakan sesuatu yang mungkin seharusnya tidak ada.

Saya menonton video yang dijelaskan code_report ini
masalah kode leet;

Anda diberikan array bilangan bulat numsbilangan bulat kdan bilangan bulat multiplier.

Anda perlu melakukannya k bekerja di atas nums. Dalam setiap operasi:

• Temukan nilai terkecil x DI DALAM nums. Jika terdapat beberapa kemunculan nilai minimum, pilih nilai yang muncul terlebih dahulu.
• Menggantikan nilai minimum yang dipilih x dengan x * multiplier.

Mengembalikan array bilangan bulat yang mewakili keadaan akhir angka setelah semua eksekusi k bekerja.

Solusi python Conor dalam video adalah

def getFinalState(nums, k, m): 
  for _ in range(k): 
    i = nums.index(min(nums)) 
    nums[i] *= m
  return nums

x = [2, 1, 3, 5, 6]
k = 5
mult = 2

getFinalState(x, k, mult)

## [8, 4, 6, 5, 6]

dan, seperti biasa, saya ingin melihat bagaimana saya bisa melakukannya di R. Saya menemukan ini

getFinalState = function(nums, k, m) 
  for (i in 1:k) 
    m <- which.min(nums)[1]
    nums[m] <- mult * nums[m]
  
  nums


x <- c(2, 1, 3, 5, 6)
k <- 5
mult <- 2

getFinalState(x, k, mult)

## [1] 8 4 6 5 6

Perlu dicatat bahwa saya tidak dapat menggunakannya map dalam fungsi ini karena iterasi
menjadi tergantung; Nilai minimum pada setiap iterasi bergantung pada nilai sebelumnya
nilai-nilai.

Saya juga berkesempatan mendiskusikan solusi ini dengan beberapa APL pada pertemuan dan
solusi J diberikan, tapi saya rasa saya tidak menuliskannya.

Solusi saya hampir kata demi kata sama dengan solusi python
Beberapa pengecualian muncul dari perbedaan di antara keduanya
bahasa:

Pertama, R melakukannya which.min() sebagai perangkat lunak terintegrasi daripada perlu menanyakan indeks
memiliki nilai minimum (dan dua referensi ke nums). Selain itu, R tidak memiliki senyawa
latihan seperti x *= 2 modifikasi di tempat – hal terdekat yang dapat saya pikirkan
dari adalah %<>% operator di magrittr (tidak diekspor ulang di dplyr karena ini
perilaku yang dianggap perilaku buruk di R, meskipun sebenarnya tidak “di tempat”)

library(magrittr)

m <- data.frame(x = 1:6, y = letters[1:6])
m

##   x y
## 1 1 a
## 2 2 b
## 3 3 c
## 4 4 d
## 5 5 e
## 6 6 f

m %<>% head(2)
m

##   x y
## 1 1 a
## 2 2 b

meskipun saya yakin ada alasannya – operator ini menghindari pengulangan
variabel sedang digunakan dan ditugaskan, karena variabel tersebut menggunakan substitusi
Pipa tradisional adalah

m <- data.frame(x = 1:6, y = letters[1:6])
m

##   x y
## 1 1 a
## 2 2 b
## 3 3 c
## 4 4 d
## 5 5 e
## 6 6 f

m <- m %>% head(2)
m

##   x y
## 1 1 a
## 2 2 b

Ada yang berpendapat bahwa menuliskan nama variabel yang lebih panjang sebanyak dua kali masih efektif
Jelas bahwa pembayangan sedang terjadi; nilai sedang ditimpa
nilai baru, tapi saya merasa sedikit kesal karena harus mengetikkannya dua kali

important_variable <- important_variable * 2

Kembali ke solusi R saya, mengindeks pada kumpulan nilai tertentu membuat saya berpikir
itu akan bersih jika kita bisa melewatinya fungsi TIBA [ so that we could
write

nums[which.min]    <- nilai

(mungkin tidak terlalu banyak untuk contoh ini ketika m digunakan dua kali, tapi itu membuatku kesal
peduli)

Misalkan saya ingin mengatur semua nilai genap suatu vektor ke nilai lain.
Itu cukup mudah untuk dilakukan

x[x %% 2 == 0] <- 0

tapi saya tidak suka itu memerlukan dua referensi xYang mana yang (seharusnya?) bisa
nama yang jauh lebih panjang

important_variable[important_variable %% 2 == 0] <- 0

Saya ingin sesuatu seperti x[f] <- y untuk mengatur nilai x Di mana f(x) Menjadi
TRUE TIBA y. Ini sepertinya bisa dilakukan, mungkin dengan salah satunya function
metode ke [<-, but [<- dispatches on the class of x, not what’s inside
[, so no dice. In theory (which will never happen) the built-in [<- could
have some branch logic for dealing with a function passed as the indices to be
modified, but I’m not about to go rebuilding R from source myself just to play
with that idea.

Nonetheless, if I define some functions that do accomplish this

is_even <- function(z) z %% 2 == 0

set_if <- function(x, f, value) 
  x[f(x)]    <- nilai x

Lalu saya bisa mencobanya pada vektor

a <- 1:10
a

##  [1]  1  2  3  4  5  6  7  8  9 10

set_if(a, is_even, 0)

##  [1] 1 0 3 0 5 0 7 0 9 0

a # unchanged

##  [1]  1  2  3  4  5  6  7  8  9 10

Berhasil, tetapi saya kembali harus menulis a <- do_stuff(a) Karena a Bukan
sebenarnya dimodifikasi oleh fungsi ini.

Idealnya fungsi saya akan bekerja seperti ini

a <- 1:10
a[is_even(a)] <- 0
a

##  [1] 1 0 3 0 5 0 7 0 9 0

yang Mengerjakan mengubah a di tempat; R tidak sepenuhnya murni dan terkadang
memungkinkan apa yang tampak seperti mutasi langsung, meskipun sebenarnya tidak – sebuah fitur baru
Objek tersebut benar-benar dibuat

# not using a range e.g. 1:n because that's internally 
# a "compact" representation
a <- c(2, 3, 4)
.Internal(inspect(a))

## @63a4d9b05be8 14 REALSXP g0c3 [REF(2)] (len=3, tl=0) 2,3,4

a[2] <- 9
.Internal(inspect(a))

## @63a4d9b0fbf8 14 REALSXP g0c3 [REF(1)] (len=3, tl=0) 2,9,4

Perhatikan bahwa alamat memori telah berubah.

Jika saya bekerja dengan bahasa yang mendukung (mengaktifkan?) modifikasi di tempat
maka itu mungkin terlihat seperti itu

def is_even(x):
   return x % 2 == 0

def set_if(x, f, value):
     for i in range(len(x)):
         if f(x[i]):
             x[i] = value

a = list(range(10))
a

## [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

set_if(a, is_even, 0)
a

## [0, 1, 0, 3, 0, 5, 0, 7, 0, 9]

Nah, itu tidak selalu merupakan hal yang bagus. Dalam suatu bahasa ada struktur yang bisa berubah
(misalnya daftar) kita bisa melakukan hal-hal gila seperti ini

x = [3, 4, 5]
y = x
y is x

## True

y[1] = 9
x # still 'bound' to y

## [3, 9, 5]

Ini, is artinya “apakah kedua hal ini serupa dalam pengertian yang disebutkan
blok memori yang sama”, perhatikan bahwa angka (misalnya angka tunggal) adalah
direferensikan seperti itu, tetapi kumpulan datanya tidak

abc = (11, 99)
xyz = (11, 99)
abc is xyz

## False

abc == xyz

## True

Pertanyaan besarnya adalah bisakah saya menggabungkan beberapa solusi Mengerjakan bekerja di lokasi
di R? Ya, dengan beberapa panggilan buruk

set_if <- function(x, f, value) 
  # can't use <<- because the value passed in as the x argument isn't 
  # necessarily named 'x' in the parent scope
  .x <- x
  .x[f(.x)] <- value
  e <- parent.env(environment())
  assign(deparse(substitute(x)), .x, pos = e)
  invisible(.x)



a <- 1:10
a

##  [1]  1  2  3  4  5  6  7  8  9 10

set_if(a, is_even, 0)
a

##  [1] 1 0 3 0 5 0 7 0 9 0

Seperti yang saya catat di komentar di sana, saya tidak bisa menggunakan panah tugas super <<-
di dalam fungsi ini karena saya tidak tahu nama variabel yang saya perbarui;
itu perlu dipisahkan dari argumen yang masuk.

Ini berarti ia berfungsi terlepas dari nama variabel yang diubah

b <- 10:20
b

##  [1] 10 11 12 13 14 15 16 17 18 19 20

set_if(b, is_even, 0)
b

##  [1]  0 11  0 13  0 15  0 17  0 19  0

Saya mencoba memikirkan bahasa lain yang mungkin mendukung hal semacam ini
set_if(x, f, value) modifikasi dan (Dyalog) APL layak untuk dipikirkan.

    ⍝ create a vector from 1 to 10
    x←⍳10
    x
1 2 3 4 5 6 7 8 9 10

    ⍝ the function ⍵ calculates a boolean vector with 
    ⍝ 1 where the value is even
    ⍵ x
0 1 0 1 0 1 0 1 0 1

    ⍝ the `@` operator takes a value (or function) on the left and 
    ⍝ a function (or boolean values) on the right and applies it to the 
    ⍝ other argument on the right
    0@⍵ x 
1 0 3 0 5 0 7 0 9 0

    ⍝ alternatively a point-free function defined as the negation (`~`) of a 
    ⍝ binding (`∘`) of the value 2 to modulo (`|`); the negation is needed
    ⍝ otherwise this returns the result of the modulo, not where it is 0
    0@(~2∘|)⍳10
1 0 3 0 5 0 7 0 9 0

    ⍝ x is, however, unchanged as APL is typically immutable
    x
1 2 3 4 5 6 7 8 9 10

Jadi tidak ada cara untuk melakukan modifikasi di tempat. namun itu luar biasa
0@(~2∘|)x baru saja disebutkan x sekali.

Julia membuat perbedaan yang jelas antara fungsi yang mengubah argumen dan fungsi yang mengubah argumen
mereka yang tidak; (menurut konvensi) yang pertama diberi nama yang diakhiri dengan satu
tanda seru, misalnya

vec = collect(1:5)

## 5-element VectorInt64:
##  1
##  2
##  3
##  4
##  5

# non-mutating
reverse(vec)

## 5-element VectorInt64:
##  5
##  4
##  3
##  2
##  1

vec

## 5-element VectorInt64:
##  1
##  2
##  3
##  4
##  5

# mutating
reverse!(vec)

## 5-element VectorInt64:
##  5
##  4
##  3
##  2
##  1

vec

## 5-element VectorInt64:
##  5
##  4
##  3
##  2
##  1

Di Julia, iseven() Fungsionalitasnya sudah ada di dalamnya, tetapi vektorisasinya
rupanya melalui operator penyiaran . dan tetapkan nilai genap menjadi 0
sepertinya

x = collect(1:10);
x[iseven.(x)] .= 0;
x

## 10-element VectorInt64:
##  1
##  0
##  3
##  0
##  5
##  0
##  7
##  0
##  9
##  0

terlihat sangat mirip dengan versi R dengan beberapa titik di mana fungsi skalar berada
divektorisasi. Jika saya tidak menggunakan yang terakhir . untuk melakukan latihan vektorisasi,
kesalahan memberi tahu saya bahwa kesalahan tersebut terkait dengan setindex! fungsi itu
terdengar seperti yang saya inginkan, tetapi ini tidak berhasil

setindex!(x, 0, iseven.(x))

karena mencoba memberikan nilai 0 beberapa kali dan saya hanya memberikan satu nilai
milik mereka. Alih-alih,

x = collect(1:10);
setindex!(x, zeros(Int8, 5), iseven.(x));
x

## 10-element VectorInt64:
##  1
##  0
##  3
##  0
##  5
##  0
##  7
##  0
##  9
##  0

tidak berhasil, tapi saya harus menghitung secara manual jumlah 0 item yang diminta, jadi
[ approach seems cleaner. Either way, I’ve had to explicitly calculate
iseven(x) and pass that result somewhere.

Since Julia allows users to extend methods, I could do that modification myself!

import Base.setindex! 
  
function setindex!(A::VectorInt64, v::Int64, f::Function) 
  A[f.(A)]    .= v berakhir

## setindex! (generic function with 240 methods)

x = collect(1:10);
setindex!(x, 0, iseven);
x

## 10-element VectorInt64:
##  1
##  0
##  3
##  0
##  5
##  0
##  7
##  0
##  9
##  0

yang dapat saya hubungi dengan mudah set_if!

set_if! = setindex!;
x = collect(1:10);
set_if!(x, 0, iseven);
x

## 10-element VectorInt64:
##  1
##  0
##  3
##  0
##  5
##  0
##  7
##  0
##  9
##  0

Cantik! Saya ingin tahu apakah saya bisa "meretas" (ahem, memperluas) Julia [ to get my prized
x[f] = 0 solusi tapi saya ragu itu layak dilakukan jika hal di atas melakukan hal yang benar
benda.

Saya tidak membayangkan saya akan berkemas set_if() di mana saja, dan mungkin aku harus melakukannya
Bahkan menghindari menggunakannya, tapi ini adalah perjalanan yang menarik untuk dipikirkan
hal ini. Mungkin ada cara yang lebih baik untuk melakukannya? Mungkin ada bahasa
Lebih baik mendukung hal seperti itu? Jika Anda tahu, atau Anda memiliki pendapat atau
Petunjuk, saya dapat ditemukan di
Mastodon atau gunakan bagian komentar di bawah.

## ─ Session info ───────────────────────────────────────────────────────────────
##  setting  value
##  version  R version 4.3.3 (2024-02-29)
##  os       Pop!_OS 22.04 LTS
##  system   x86_64, linux-gnu
##  ui       X11
##  language (EN)
##  collate  en_AU.UTF-8
##  ctype    en_AU.UTF-8
##  tz       Australia/Adelaide
##  date     2024-09-25
##  pandoc   3.2 @ /usr/lib/rstudio/resources/app/bin/quarto/bin/tools/x86_64/ (via rmarkdown)
## 
## ─ Packages ───────────────────────────────────────────────────────────────────
##  package     * version date (UTC) lib source
##  blogdown      1.19    2024-02-01 [1] CRAN (R 4.3.3)
##  bookdown      0.36    2023-10-16 [1] CRAN (R 4.3.2)
##  bslib         0.8.0   2024-07-29 [1] CRAN (R 4.3.3)
##  cachem        1.1.0   2024-05-16 [1] CRAN (R 4.3.3)
##  callr         3.7.3   2022-11-02 [3] CRAN (R 4.2.2)
##  cli           3.6.1   2023-03-23 [1] CRAN (R 4.3.3)
##  crayon        1.5.2   2022-09-29 [3] CRAN (R 4.2.1)
##  devtools      2.4.5   2022-10-11 [1] CRAN (R 4.3.2)
##  digest        0.6.37  2024-08-19 [1] CRAN (R 4.3.3)
##  ellipsis      0.3.2   2021-04-29 [3] CRAN (R 4.1.1)
##  evaluate      0.24.0  2024-06-10 [1] CRAN (R 4.3.3)
##  fastmap       1.2.0   2024-05-15 [1] CRAN (R 4.3.3)
##  fs            1.6.4   2024-04-25 [1] CRAN (R 4.3.3)
##  glue          1.7.0   2024-01-09 [1] CRAN (R 4.3.3)
##  htmltools     0.5.8.1 2024-04-04 [1] CRAN (R 4.3.3)
##  htmlwidgets   1.6.2   2023-03-17 [1] CRAN (R 4.3.2)
##  httpuv        1.6.12  2023-10-23 [1] CRAN (R 4.3.2)
##  icecream      0.2.1   2023-09-27 [1] CRAN (R 4.3.2)
##  jquerylib     0.1.4   2021-04-26 [1] CRAN (R 4.3.3)
##  jsonlite      1.8.8   2023-12-04 [1] CRAN (R 4.3.3)
##  JuliaCall     0.17.5  2022-09-08 [1] CRAN (R 4.3.3)
##  knitr         1.48    2024-07-07 [1] CRAN (R 4.3.3)
##  later         1.3.1   2023-05-02 [1] CRAN (R 4.3.2)
##  lattice       0.22-5  2023-10-24 [4] CRAN (R 4.3.1)
##  lifecycle     1.0.4   2023-11-07 [1] CRAN (R 4.3.3)
##  magrittr    * 2.0.3   2022-03-30 [1] CRAN (R 4.3.3)
##  Matrix        1.6-5   2024-01-11 [4] CRAN (R 4.3.3)
##  memoise       2.0.1   2021-11-26 [1] CRAN (R 4.3.3)
##  mime          0.12    2021-09-28 [1] CRAN (R 4.3.3)
##  miniUI        0.1.1.1 2018-05-18 [1] CRAN (R 4.3.2)
##  pkgbuild      1.4.2   2023-06-26 [1] CRAN (R 4.3.2)
##  pkgload       1.3.3   2023-09-22 [1] CRAN (R 4.3.2)
##  png           0.1-8   2022-11-29 [1] CRAN (R 4.3.2)
##  prettyunits   1.2.0   2023-09-24 [3] CRAN (R 4.3.1)
##  processx      3.8.3   2023-12-10 [3] CRAN (R 4.3.2)
##  profvis       0.3.8   2023-05-02 [1] CRAN (R 4.3.2)
##  promises      1.2.1   2023-08-10 [1] CRAN (R 4.3.2)
##  ps            1.7.6   2024-01-18 [3] CRAN (R 4.3.2)
##  purrr         1.0.2   2023-08-10 [3] CRAN (R 4.3.1)
##  R6            2.5.1   2021-08-19 [1] CRAN (R 4.3.3)
##  Rcpp          1.0.11  2023-07-06 [1] CRAN (R 4.3.2)
##  remotes       2.4.2.1 2023-07-18 [1] CRAN (R 4.3.2)
##  reticulate    1.34.0  2023-10-12 [1] CRAN (R 4.3.2)
##  rlang         1.1.4   2024-06-04 [1] CRAN (R 4.3.3)
##  rmarkdown     2.28    2024-08-17 [1] CRAN (R 4.3.3)
##  rstudioapi    0.15.0  2023-07-07 [3] CRAN (R 4.3.1)
##  sass          0.4.9   2024-03-15 [1] CRAN (R 4.3.3)
##  sessioninfo   1.2.2   2021-12-06 [1] CRAN (R 4.3.2)
##  shiny         1.7.5.1 2023-10-14 [1] CRAN (R 4.3.2)
##  stringi       1.8.4   2024-05-06 [1] CRAN (R 4.3.3)
##  stringr       1.5.1   2023-11-14 [1] CRAN (R 4.3.3)
##  urlchecker    1.0.1   2021-11-30 [1] CRAN (R 4.3.2)
##  usethis       3.0.0   2024-07-29 [1] CRAN (R 4.3.3)
##  vctrs         0.6.5   2023-12-01 [1] CRAN (R 4.3.3)
##  xfun          0.47    2024-08-17 [1] CRAN (R 4.3.3)
##  xtable        1.8-4   2019-04-21 [1] CRAN (R 4.3.2)
##  yaml          2.3.10  2024-07-26 [1] CRAN (R 4.3.3)
## 
##  [1] /home/jono/R/x86_64-pc-linux-gnu-library/4.3
##  [2] /usr/local/lib/R/site-library
##  [3] /usr/lib/R/site-library
##  [4] /usr/lib/R/library
## 
## ─ Python configuration ───────────────────────────────────────────────────────
##  python:         /home/jono/.virtualenvs/r-reticulate/bin/python
##  libpython:      /usr/lib/python3.10/config-3.10-x86_64-linux-gnu/libpython3.10.so
##  pythonhome:     /home/jono/.virtualenvs/r-reticulate:/home/jono/.virtualenvs/r-reticulate
##  version:        3.10.12 (main, Jul 29 2024, 16:56:48) [GCC 11.4.0]
##  numpy:           [NOT FOUND]
##  
##  NOTE: Python version was forced by VIRTUAL_ENV
## 
## ──────────────────────────────────────────────────────────────────────────────

Terkait