Bahasa-bahasa ini terakumulasi | beragampengetahuan.com – Beragampengetahuan

Oleh: Jonathan Carroll

Diposting ulang dari:

Saya selalu mengatakan bahwa semakin banyak bahasa pemrograman yang Anda ketahui, semakin banyak yang Anda miliki
memahami semua hal lain yang Anda ketahui – saat ini saya berada pada titik di mana saya ingin menghadapinya
setiap masalah yang saya temui ada dalam beberapa bahasa yang berbeda. Mereka semua memberikannya
Fungsinya berbeda-beda dan beberapa pasti lebih cocok untuk ini
masalah daripada yang lain, tetapi ada perbedaan besar antara kedua karakter tersebut
dan mengimpor dari dua perpustakaan.

Buletin yang saya ikuti (dan tidak dapat menemukan salinannya secara online) menunjukkan kerapian
hal-hal dengan python (harus mempelajarinya, meskipun tidak menyukainya) baru-baru ini disebutkan
accumulatemenunjukkan itu sum Dan accumulate terkait

>>> my_list = [42, 73, 0, 16, 10]
>>> sum(my_list)

141

>>> from itertools import accumulate
>>> list(accumulate(my_list))

[42, 115, 115, 131, 141]

sum jumlahkan semua elemen daftar, sementara accumulate melakukan hal yang sama tetapi
pertahankan setiap jumlah parsial berturut-turut.

Ini melengkapi demo dengan fungsi alternatif yang digunakan accumulate

>>> from itertools import accumulate
>>> from operator import mul  # mul(2, 3) == 6
>>> initial_investment = 1000
>>> rates = [1.01, 1.01, 1.02, 1.025, 1.035, 1.035, 1.06]
>>> list(
...     accumulate(rates, mul, initial=initial_investment)
... )

[1000, 1010.0, 1020.1, 1040.502, 1066.515, 1103.843, 1142.477, 1211.026]

Sekarang, pertama-tama… from operator import mul??? Sepertinya tidak ada cara untuk melakukannya
mengatasi * sebagai argumen terhadap suatu fungsi. SAYA Mungkin Mendefinisikan fungsi implementasi
serupa pada argumen yang diketahui, misalnya lambda x, y: x * y

>>> list(accumulate(rates, lambda x, y: x*y, initial=initial_investment))

[1000, 1010.0, 1020.1, 1040.502, 1066.5145499999999, 1103.8425592499998, 1142.4770488237498, 1211.0256717531747]

tapi… oh.

Mungkin ada cara lain untuk mengatasi masalah ini. Sebuah daftar
pemahaman muncul di benak, misalnya sesuatu seperti

>>> [sum(my_list[0:i]) for i in range(1, len(my_list)+1)]

[42, 115, 115, 131, 141]

tetapi hal itu memerlukan penjumlahan untuk setiap sub-interval, sehingga kinerja akan tercapai
tidak berskala dengan baik (memang itu sama sekali bukan pertimbangan di sini). saya juga
Saya tidak percaya itu ada di dalamnya prod jadi seseorang harus import math untuk melakukan
serupa

>>> import math
>>> x = [initial_investment] + rates
>>> [math.prod(x[0:i]) for i in range(1, len(x)+1)]

[1000, 1010.0, 1020.1, 1040.502, 1066.5145499999999, 1103.8425592499998, 1142.4770488237498, 1211.0256717531747]

Di R dimungkinkan untuk menggunakan fitur bawaan cumprod untuk produk kumulatif

initial_investment <- 1000
rates = c(1.01, 1.01, 1.02, 1.025, 1.035, 1.035, 1.06)

cumprod(c(initial_investment, rates))

## [1] 1000.000 1010.000 1020.100 1040.502 1066.515 1103.843 1142.477 1211.026

tetapi operasi ‘kalikan’ di-hardcode. cumsum kegunaan + menyukai
fungsi… hmmm. Mungkin R tidak memiliki generalisasi accumulate?

Saya telah bereksperimen dengan Haskell akhir-akhir ini untuk fungsi rekursif
pembebasan! Salah satu fitur fungsi rekursif di R yang sangat saya sukai adalah Recall
yang memanggil fungsi tersebut di mana hal itu didefinisikan dengan serangkaian argumen baru –
sempurna untuk rekursi!

accumulate_recall <- function(x, f, i=x[1]) {
  if (!length(x)) return(NULL)
  c(i, Recall(tail(x, -1), f, f(i, x[2])))
}

Ini juga secara efektif menolak penggantian nama fungsi; tubuh tidak benar-benar menelepon
accumulate_recall berdasarkan nama.

Namun, ini mungkin tidak berhasil – korupsi tumpukan sering terjadi
yang baru Tailcall fungsionalitas (tidak terlihat mewah seperti kekokohan
menentang penggantian nama) membantu menandai ini sebagai sesuatu yang dapat dioptimalkan

accumulate <- function(x, f, i=x[1]) {
  if (!length(x)) return(NULL)
  c(i, Tailcall(accumulate, tail(x, -1), f, f(i, x[2])))
}

Dengan ini, saya bisa melakukan simulasi cumsum() Dan cumprod() fungsi

cumprod(1:6)

## [1]   1   2   6  24 120 720

accumulate(1:6, `*`)

## [1]   1   2   6  24 120 720

cumsum(2:6)

## [1]  2  5  9 14 20

accumulate(2:6, `+`)

## [1]  2  5  9 14 20

kecuali saya mencoba menghitung sesuatu yang terlalu besar…

cumprod(5:15)

##  [1]           5          30         210        1680       15120      151200
##  [7]     1663200    19958400   259459200  3632428800 54486432000

accumulate(5:15, `*`)

## Warning in f(i, x[2]): NAs produced by integer overflow

##  [1]         5        30       210      1680     15120    151200   1663200
##  [8]  19958400 259459200        NA        NA

Sepertinya fungsi bawaan diubah menjadi angka. Itu mudah diperbaiki
tentang masukan

accumulate(as.numeric(5:15), `*`)

##  [1]           5          30         210        1680       15120      151200
##  [7]     1663200    19958400   259459200  3632428800 54486432000

Bagaimanapun, ada generalisasi accumulate memiliki fungsi kosong seperti
argumen.

Tapi ini bisa menjadi jauh lebih bersih dari ini!

Di APL Anda tidak akan menemukan fungsi apa pun yang bernama “jumlah” karena ini hanyalah kontraksi
(Reduce di R) dengan fungsi +

      sum←+/
      
      sum ⍳6 ⍝ sum the values 1:6
21

      sum 1↓⍳6 ⍝ sum the values 2:6
20

di R adalah

sum(1:6)

## [1] 21

sum(2:6)

## [1] 20

Mengapa kamu menulis? sum jika Anda bisa menggunakannya +/? Itu kurang
Karakter yang dituliskan menghasilkan lebih dari sekadar nama!

Karena accumulate istilah di APL adalah scan digunakan dengan cara yang sangat mirip
mesin terbang karena operasinya sendiri sangat mirip; Satu reduce (/) hanya
nilai akhir a scan (\) memegang nilai-nilai progresif. Dalam kedua kasus tersebut,
operator (atau garis miring) mengambil fungsi biner sebagai argumen ke kiri dan
membuat fungsi yang dimodifikasi – dalam contoh ini, secara efektif sum Dan prod –
kemudian diterapkan ke nilai di sebelah kanan. itu scan versi melakukan hal yang sama

      +\⍳6
1 3 6 10 15 21

      ×\⍳6
1 2 6 24 120 720

accumulate(1:6, `+`)

## [1]  1  3  6 10 15 21

accumulate(1:6, `*`)

## [1]   1   2   6  24 120 720

Untuk contoh skala di atas, kami menggabungkan nilai awal dengan catenate
(,) seperti contoh R, tetapi selain itu berfungsi dengan baik

      rates ← 1.01 1.01 1.02 1.025 1.035 1.035 1.06
      inv ← 1000
      
      ×/inv, rates
1211.025672

      ×\inv, rates
1000 1010 1020.1 1040.502 1066.51455 1103.842559 1142.477049 1211.025672

Jadi semua kode R rekursif dibuat untuk menggeneralisasi penerapan kumulatif
fungsi yang disediakan sebagai argumen direduksi menjadi satu mesin terbang \.
Luar biasa!

Selain itu, ya sangat banyak fungsi biner yang akan digunakan dengan ini, semuanya
di antaranya adalah nama yang dieja dalam bahasa lain

      +/ ⍝ sum (add)
      ×/ ⍝ prod (multiply)
      ∧/ ⍝ all (and)
      ∨/ ⍝ any (or)
      ⌈/ ⍝ maximum (max)
      ⌊/ ⍝ minimum (min)

Singkatnya, tampaknya ketika melihat bahasa-bahasa ini, opsinya tersedia
berkisar dari satu mesin terbang hingga scan bersama dengan operator biner telanjang, misalnya
×/; Satu cumprod() Fungsinya tidak digeneralisasikan dengan baik tetapi berhasil
kotak; dan tidak peduli betapa berantakannya hal ini (setelah Anda melakukannya dipasang ini)

>>> from itertools import accumulate
>>> from operator import mul
>>> list(accumulate(rates, mul, initial=initial_investment))

Dimana kesalahan kita?

Untuk apa nilainya, Julia punya satu reduce dan satu accumulate berperilaku sangat
unik; digeneralisasikan ke fungsi biner sebagai argumen

julia> reduce(+, 1:6)
21

julia> reduce(*, 1:6)
720

julia> accumulate(+, 1:6)
6-element Vector{Int64}:
  1
  3
  6
 10
 15
 21

julia> accumulate(*, 1:6)
6-element Vector{Int64}:
   1
   2
   6
  24
 120
 720

Ini sangat mirip dengan pendekatan APL, tetapi dengan nama yang lebih panjang
perempuan reduce Dan scan operator. Ini juga menentukan cara yang lebih nyaman sum,
prod, cumsumDan cumprod; Ada banyak cara untuk melakukan hal ini di Julia!

Di Haskell, foldl Dan scanl adalah versi (tertaut kiri) dari reduce
Dan accumulatedan meneruskan infiks sebagai argumen diperlukan untuk membungkusnya
dalam tanda kurung

ghci> foldl (+) 0 [1..6]
21

ghci> scanl (+) 0 [1..6]
[0,1,3,6,10,15,21]

ghci> foldl (*) 1 [1..6]
720

ghci> scanl (*) 1 [1..6]
[1,1,2,6,24,120,720]

Ini memerlukan nilai awal yang eksplisit, kecuali jika seseorang menggunakan nilai khusus
versi menggunakan nilai pertama sebagai nilai awal

ghci> foldl1 (+) [1..6]
21

ghci> scanl1 (+) [1..6]
[1,3,6,10,15,21]

ghci> foldl1 (*) [1..6]
720

ghci> scanl1 (*) [1..6]
[1,2,6,24,120,720]

Saya memulai posting ini dengan harapan untuk menunjukkan betapa bagusnya sintaks APL untuk ini,
Namun menelusuri generalisasi fungsi R memiliki banyak kesenangan yang tidak terduga
Juga.

Komentar, perbaikan, atau solusi Anda sangat kami harapkan. saya dapat ditemukan
di Mastodon atau gunakan komentar di bawah.

Lampiran

Mungkin perlu dicatat bahwa R Mengerjakan memiliki fungsi scan Tapi itu untuk
membaca data ke dalam vektor – jika Anda pernah menemukan seseorang menggunakannya untuk… tujuan berjalan.
Saya punya cerita perang tentang fungsi itu.

Saya juga ingin tahu bagaimana hal ini dilakukan dalam beberapa bahasa lain – bukan?
memiliki bawaan accumulate apakah ada fungsi biner?

## ─ Session info ───────────────────────────────────────────────────────────────
##  setting  value
##  version  R version 4.4.1 (2024-06-14)
##  os       macOS Sonoma 14.6
##  system   aarch64, darwin20
##  ui       X11
##  language (EN)
##  collate  en_US.UTF-8
##  ctype    en_US.UTF-8
##  tz       Australia/Adelaide
##  date     2024-11-28
##  pandoc   3.5 @ /opt/homebrew/bin/ (via rmarkdown)
## 
## ─ Packages ───────────────────────────────────────────────────────────────────
##  package     * version    date (UTC) lib source
##  blogdown      1.19       2024-02-01 [1] CRAN (R 4.4.0)
##  bookdown      0.41       2024-10-16 [1] CRAN (R 4.4.1)
##  bslib         0.8.0      2024-07-29 [1] CRAN (R 4.4.0)
##  cachem        1.1.0      2024-05-16 [1] CRAN (R 4.4.0)
##  cli           3.6.3      2024-06-21 [1] CRAN (R 4.4.0)
##  devtools      2.4.5      2022-10-11 [1] CRAN (R 4.4.0)
##  digest        0.6.37     2024-08-19 [1] CRAN (R 4.4.1)
##  ellipsis      0.3.2      2021-04-29 [1] CRAN (R 4.4.0)
##  evaluate      1.0.1      2024-10-10 [1] CRAN (R 4.4.1)
##  fastmap       1.2.0      2024-05-15 [1] CRAN (R 4.4.0)
##  fs            1.6.5      2024-10-30 [1] CRAN (R 4.4.1)
##  glue          1.8.0      2024-09-30 [1] CRAN (R 4.4.1)
##  htmltools     0.5.8.1    2024-04-04 [1] CRAN (R 4.4.0)
##  htmlwidgets   1.6.4      2023-12-06 [1] CRAN (R 4.4.0)
##  httpuv        1.6.15     2024-03-26 [1] CRAN (R 4.4.0)
##  jquerylib     0.1.4      2021-04-26 [1] CRAN (R 4.4.0)
##  jsonlite      1.8.9      2024-09-20 [1] CRAN (R 4.4.1)
##  knitr         1.48       2024-07-07 [1] CRAN (R 4.4.0)
##  later         1.3.2      2023-12-06 [1] CRAN (R 4.4.0)
##  lifecycle     1.0.4      2023-11-07 [1] CRAN (R 4.4.0)
##  magrittr      2.0.3      2022-03-30 [1] CRAN (R 4.4.0)
##  memoise       2.0.1      2021-11-26 [1] CRAN (R 4.4.0)
##  mime          0.12       2021-09-28 [1] CRAN (R 4.4.0)
##  miniUI        0.1.1.1    2018-05-18 [1] CRAN (R 4.4.0)
##  pkgbuild      1.4.5      2024-10-28 [1] CRAN (R 4.4.1)
##  pkgload       1.4.0      2024-06-28 [1] CRAN (R 4.4.0)
##  profvis       0.4.0      2024-09-20 [1] CRAN (R 4.4.1)
##  promises      1.3.0      2024-04-05 [1] CRAN (R 4.4.0)
##  purrr         1.0.2      2023-08-10 [1] CRAN (R 4.4.0)
##  R6            2.5.1      2021-08-19 [1] CRAN (R 4.4.0)
##  Rcpp          1.0.13-1   2024-11-02 [1] CRAN (R 4.4.1)
##  remotes       2.5.0.9000 2024-11-03 [1] Github (r-lib/remotes@5b7eb08)
##  rlang         1.1.4      2024-06-04 [1] CRAN (R 4.4.0)
##  rmarkdown     2.28       2024-08-17 [1] CRAN (R 4.4.0)
##  rstudioapi    0.17.1     2024-10-22 [1] CRAN (R 4.4.1)
##  sass          0.4.9      2024-03-15 [1] CRAN (R 4.4.0)
##  sessioninfo   1.2.2      2021-12-06 [1] CRAN (R 4.4.0)
##  shiny         1.9.1      2024-08-01 [1] CRAN (R 4.4.0)
##  urlchecker    1.0.1      2021-11-30 [1] CRAN (R 4.4.0)
##  usethis       3.0.0      2024-07-29 [1] CRAN (R 4.4.0)
##  vctrs         0.6.5      2023-12-01 [1] CRAN (R 4.4.0)
##  xfun          0.49       2024-10-31 [1] CRAN (R 4.4.1)
##  xtable        1.8-4      2019-04-21 [1] CRAN (R 4.4.0)
##  yaml          2.3.10     2024-07-26 [1] CRAN (R 4.4.0)
## 
##  [1] /Library/Frameworks/R.framework/Versions/4.4-arm64/Resources/library
## 
## ──────────────────────────────────────────────────────────────────────────────

Terkait