Jumlah dirantai dengan Nest

Question

Saya ingin menghitung jumlah yang dirantai seperti ini $$ C_m = \sum\limits_{i_1=1}^N \;\sum\limits_{i_2=i_1+1}^N \;\sum\limits_{i_3=i_2+1}^N \cdots \;\sum\limits_{i_m=i_{m-1}+1}^N A_{i_1}A_{i_2}A_{i_3}\cdots A_{i_m} $$ Misalnya saat $m=3$, ini menjadi $$ C_3 = \sum\limits_{i=1}^N \;\sum\limits_{j=i+1}^N \;\sum\limits_{k=j+1}^N A_i A_j A_k $$ Tentu saja intinya adalah saya ingin $m$untuk tetap tidak ditentukan dalam algoritme. Sekarang, saya tahu bagaimana menerapkan ini dengan secara manual membuat daftar iterator (misalnya dengan Tuples) dan menerapkannya Sum. Tapi bagi saya itu lebih terasa seperti hack daripada kode elegan.

Karena saya selalu mencoba untuk mendapatkan kode saya seelegan mungkin, saya melihat ini sebagai kesempatan yang baik untuk belajar. Salah satu konsep yang selalu sulit saya pahami (tetapi ingin saya kuasai), adalah penggunaan Nestdan Fold. Jumlah ini dapat dilihat sebagai fungsi yang bersarang pada dirinya sendiri$$ C_m = \sum\limits_{i_1=1}^N A_{i_1} \left[ \;\sum\limits_{i_2=i_1+1}^N A_{i_2} \left[ \;\sum\limits_{i_3=i_2+1}^N A_{i_3} \left[ \cdots\vphantom{\sum\limits_{i_3=i_2+1}^N} \right]\right]\right] $$Saya berharap Nestmenjadi kandidat yang ideal. Saya sudah mencoba sedikit, tetapi yang terbaik yang bisa saya dapatkan adalah

f[g_,j_] := Sum[g[k]A[k], {k,j+1,n}]
F[x_] := f[x,#]&

c[m_] := f[Nest[F,1&,m-1],0]

Saya menemukan ini sangat jelek, terutama dua definisi fungsi yang masih perlu di dalam fungsi murni F, serta fakta bahwa saya perlu untuk membungkus tambahan fsekitar Nest. Itu menjadi lebih buruk jika saya mencoba menghindari kebutuhan untuk mendefinisikan fdan F:

c[m_] := Sum[
  Nest[ Function[var,Sum[var[k]A[k],{k,#+1,5}]&], 1&, m-1][l] A[l]
, {l,1,n}]

dengan kebutuhan untuk menggunakan Functiondan &.

Jadi, inilah pertanyaan saya: apakah ada cara yang lebih baik untuk mencapai jumlah yang dirantai ini menggunakan Nest? Jika tidak, mungkin dengan menggunakan Foldatau konstruksi fungsional lainnya?

Answer 1

Tablemelakukan ini secara otomatis. Anda harus dapat menyesuaikan kode berikut:

f[m_, n_] := Sum[
   Product[A[i[j]], {j, 1, m}] // Evaluate, 
   Sequence @@ Prepend[Table[{i[j], i[j - 1] + 1, n}, {j, 2, m}], {i[1], 1, n}] // Evaluate
  ]

Jadi

f[2, 3]
(* A[1] A[2] + A[1] A[3] + A[2] A[3] *)

dan

f[3, 5]
(* A[1] A[2] A[3] + A[1] A[2] A[4] + A[1] A[3] A[4] + A[2] A[3] A[4] + A[1] A[2] A[5] + A[1] A[3] A[5] + A[2] A[3] A[5] + A[1] A[4] A[5] + A[2] A[4] A[5] + A[3] A[4] A[5] *)

---

Atau, buat indeks secara langsung, dan terapkan fungsinya ke sana, seperti:

f2[n_, m_] := Times @@@ Map[A, Subsets[Range[m], {n}], {2}] // Total
f2[3, 5]
(* A[1] A[2] A[3] + A[1] A[2] A[4] + A[1] A[3] A[4] + A[2] A[3] A[4] + A[1] A[2] A[5] + A[1] A[3] A[5] + A[2] A[3] A[5] + A[1] A[4] A[5] + A[2] A[4] A[5] + A[3] A[4] A[5] *)

dan

f[3, 5] - f2[3, 5]
(* 0 *)

Atau

f3[n_, m_] := Sum[Times @@ A /@ is, {is, Subsets[Range[m], {n}]}]

Answer 2

"Nest [f, expr, n] memberikan ekspresi dengan f diterapkan n kali ke expr."

Nest mengambil fungsi, ekspresi, n bilangan bulat positif.

Tidak lebih, tidak kurang.

Nest entah bagaimana sudah ketinggalan zaman.

Ini digantikan oleh Composition.

Compositionadalah istilah dasar matematika dari dengan Nestditurunkan.

Ada contoh dalam dokumentasi Komposisi untuk penjumlahan:

Composition[HoldForm, Plus] @@ Range[20]
___
\!\(
TagBox[
RowBox[{"1", "+", "2", "+", "3", "+", "4", "+", "5", "+", "6", "+", 
    "7", "+", "8", "+", "9", "+", "10", "+", "11", "+", "12", "+", 
    "13", "+", "14", "+", "15", "+", "16", "+", "17", "+", "18", "+", 
    "19", "+", "20"}],
HoldForm]\)

Ini menjelaskan bahwa Sum dan Nest agak berbeda.

Sumditurunkan dari Pluscara di atas. Halaman dokumentasi Plusmenunjukkan beberapa alternatif untuk Sum.

Untuk membuat produk yang rumit, Mathematica menawarkan bawaan Product. Tidak ada baris dengan Nestdi halaman dokumentasi Productatau sebaliknya.

Apa artinya bagi pertanyaan Anda? Sekarang pada awalnya tidak ada. Tapi itu petunjuk yang kuat.

Meskipun Nestiteratif dengan n, konstanta "waktu" pada posisi argumen ketiga, Producttidak memerlukan x "tetapi iterator i dengan awal dan akhir. Itulah yang direpresentasikan oleh ringkasan Anda. Saya menerima contoh di halaman dokumentasi Productuntuk mudah atau banyak yang terspesialisasi.

Ada beberapa contoh dan metode yang bagus, bagaimana membuatnya lebih efisien:

∑𝑖=2𝑁cos𝜃𝑖cos𝜃′𝑖∏𝑗=𝑖+1𝑀sin𝜃𝑗𝜃′𝑗

    NSum[Cos[θ[[i]]] Cos[Θp[[i]]] Product[    Sin[θ[[j]]] Sin[θp[[j]]], {j, i + 1, d - 1}], {i, 2,    d - 1}]


f[M_, n_] := Reverse[Table[Cos[θ[i]] Cos[θ'[i]], {i, 2, n}]].PadLeft[FoldList[
Sin[θ[M - #2] θ'[M - #2]] # &, Sin[θ[M] θ'[M]], Range[M - 3]], Max[n - 1, 0], 1]

Pertanyaan ini sudah mengenai jumlah atau produk dengan pengecualian .

Jumlah lebih penting untuk mendapatkan formuler tertutup seperti dalam contoh ini:

Sum[Product[i^2, {i, 1, n}], {i, 1, n}]
n (n!)^2

n = 4;
Times @@ Flatten@Table[f[a[i] - a[j]], {i, 1, n - 1}, {j, i + 1, n}]

atau

With[{n = 6}, Times @@ f /@ Subtract @@@ Subsets[Array[a, n], {2}]]

dapat dilakukan dengan iterator atau daftar. Iterator memerlukan daftar koefisien yang sudah ditentukan dan mengulanginya secara linier. Dalam versi Mathematica yang lebih modern, versi kedua akan lebih cepat dalam banyak konteks.

Rumusnya menggunakan operator yang berbeda @, @@dan @@@itu berbeda dengan Composition @*.

Ini adalah jawaban yang berperingkat tinggi tentang scan vs map vs apply . Jawaban ini menjelaskan beberapa perbedaan antara Komposisi dan Penerapan . Jawaban ini masuk lebih dalam ke topik yang terkait: bentuk operator v10s untuk apa mereka baik?

Beberapa kesalahpahaman umum dibahas dalam jawaban ini: bagaimana cara menunjukkan argumen dalam peta bersarang .

ClearAll[list1, list2, a, b, c, x, y, z, f]
list1 = {a, b, c}
list2 = {x, y, z}
___
Map[Map[f[#1, #2] &, list1] &, list2]
__
list2
___
Map[Function[x, Map[f[#1, x] &, list1]], list2]
___
list2

Tetapi hasil yang diinginkan adalah ini

Outer[f, list1, list2]
(*
  {{f[a, x], f[a, y], f[a, z]}, 
   {f[b, x], f[b, y], f[b, z]}, 
   {f[c, x], f[c, y], f[c, z]}}
*)

Map[Function[p2, Map[Function[p1, f[p1, p2]], list1]], list2]

(* {{f [a, x], f [b, x], f [c, x]}, {f [a, y], f [b, y], f [c, y]}, { f [a, z], f [b, z], f [c, z]}} *)

Jika f in not listable ini bisa juga ditulis seperti ini:

Distribute[f[{a, b, c}, {x, y, z}], List]
(*
  {{f[a, x], f[b, x], f[c, x]}, 
   {f[a, y], f[b, y], f[c, y]}, 
   {f[a, z], f[b, z], f[c, z]}}
*)

Alternatif berikutnya adalah

Tuple [{{a, b, c}, {x, y, z}}] ( {{a, x}, {a, y}, {a, z}, {b, x}, {b, y }, {b, z}, {c, x}, {c, y}, {c, z}} )

Apply[f, Tuples[{{a, b, c}, {x, y, z}}], {1}]

( {f [a, x], f [a, y], f [a, z], f [b, x], f [b, y], f [b, z], f [c, x] , f [c, y], f [c, z]} )

Dan ini, pada gilirannya, memungkinkan yang diinginkan Nest:

Nest [f, #, 1] & / @ Tuples [{{a, b, c}, {x, y, z}}] ( {f [{a, x}], f [{a, y}] , f [{a, z}], f [{b, x}], f [{b, y}], f [{b, z}], f [{c, x}], f [{c , y}], f [{c, z}]} )

Pertanyaan tentang nest-fold-is-there-an-extension-for-more-than-2-arguments ini mengacu pada bab 5.5.3 Pembatasan fungsi Fold-ed untuk dua argumen adalah palsu dari sebuah buku online oleh Leonid Shifrin dan contoh dengan tiga slot:

multiFoldList[f_, start_, args__List] := 
 FoldList[f @@ Prepend[#2, #] &, start, {args}\[Transpose]] 
____
multiFoldList[#1 (1 + #2) - #3 &, 1000, {.01, .02, .03}, {100, 200, 
  300}]
___
{1000, 910., 728.2, 450.046}

Ini sangat istimewa tetapi ini membuat trik dan ekstensi sudah disertakan.

Untuk saat ini akhirnya, saya ingin merujuk ke artikel ikhtisar ini

alternatif-ke-prosedural-loop-dan-iterasi-daftar-dalam-matematis /

yang mencakup beberapa contoh menggunakan Fold dan Nest dan membandingkannya dalam situasi yang berbeda dengan alternatif bawaan. Ini semua cukup bagus dan menawarkan pengetahuan yang lebih dalam tentang apa yang Nestbisa dan bisa dilakukan dan apa yang tidak. Saya membandingkan built-in Nestdengan built-in dan kombinasi dan Compositions lainnya.

Telusuri dokumentasi Mathematica untuk Iterator untuk mendapatkan definisi ini sebagai definisi yang lebih baik untuk nilai input n dan beberapa penjelasan untuk pemilihan paradigma Mathematica tentang itu.

Ada dua definisi untuk Ekspresi dalam dokumentasi Mathematica, satu untuk sel dan satu lagi untuk penerjemah Bahasa Wolfram. Jadi panduan pencarian seperti itu menjadi masukan yang didedikasikan untuk kegunaan WolframAlpha

Lihat FixedPoint sebagai built-in yang secara historis dikelompokkan dengan Nest dan untuk generasi pengguna Mathematica sebagai built-in Nest yang membatasi untuk iterasi tak terbatas, aplikasi. Tutorial terkenalnya adalah Menerapkan fungsi berulang kali.

menentukan rentang untuk indeks yang dapat ditangani oleh Mathematica berdasarkan Bahasa Wolfram.

Jadi itulah yang kurang dimiliki Nest dan sejenisnya dan Prodcut.