Bagaimana Anda merencanakan fungsi 3d dengan python?

Matematika itu indah, dan perangkat lunak yang kita miliki di ujung jari kita merupakan cara yang tak ternilai untuk menjelajahi keindahan itu. Belum pernah sebelumnya kita dapat memvisualisasikan dan bereksperimen dengan objek matematika sedemikian rupa sehingga dapat diakses

Hari ini, saya ingin menguraikan langkah-langkah yang diperlukan untuk memplot fungsi dua variabel menggunakan Python

Sepanjang jalan, kita akan belajar tentang beberapa prosedur NumPy yang akan membuat Anda memanipulasi matriks seperti seorang penyihir. Saya telah memecah proses menjadi tiga langkah konseptual yang juga akan membantu menyegarkan matematika yang mendasarinya

Terakhir, saya menyatukan semuanya menjadi fungsi yang dapat Anda gunakan di luar kotak, jadi jangan ragu untuk melewatinya jika hanya itu yang Anda butuhkan.

Tentukan Domain Fungsi

Fungsi matematika adalah peta yang mengambil elemen dari satu set dan menghubungkannya dengan satu elemen dari set lainnya. Kumpulan input pertama ini disebut domain fungsi. Dalam kasus kami, domain akan terdiri dari tupel bilangan real

Meskipun ada banyak bilangan real tak terhingga di dalam interval apa pun, kami jelas tidak dapat menyimpan himpunan tak terhingga untuk domain kami. Agar plot kita terlihat bagus, cukup mengambil sampel poin yang cukup dalam domain kita sehingga produk akhir akan terlihat halus dan tidak bergerigi secara tidak wajar

Dengan pemikiran ini, kita dapat mendefinisikan domain kita dan menyimpannya dalam satu set array dalam tiga langkah

1. Tentukan batasan untuk masing-masing dari dua variabel dalam domain kita

x_interval = (-2, 2)
y_interval = (-2, 2)

2. Titik sampel dalam setiap interval ini

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

3. Ambil produk Cartesian dari dua set sampel ini untuk menghasilkan dua larik yang (ketika ditumpuk) membentuk satu set pasangan terurut yang dapat kita hitung fungsinya

X, Y = np.meshgrid(x_points, y_points)

Dalam mendefinisikan domain kami, kami menggunakan beberapa alat berguna dari NumPy

• np.linspace. Fungsi ini menghasilkan barisan bilangan real yang berjarak sama sepanjang beberapa interval. Saya juga menemukan sepupunya,

  x_points = np.linspace(x_interval[0], x_interval[1], 100)
  y_points = np.linspace(y_interval[0], y_interval[1], 100)

  _0, berguna untuk hal-hal seperti membuat kisi nilai hyperparameter untuk dicoba dalam pemodelan

• x_points = np.linspace(x_interval[0], x_interval[1], 100)
  y_points = np.linspace(y_interval[0], y_interval[1], 100)

  _1. Dokumentasi mengatakan yang terbaik — meshgrid menghasilkan “matriks koordinat dari vektor koordinat. ” Jika Anda menumpuk matriks koordinat satu di atas yang lain, Anda mendapatkan kisi tupel yang dapat Anda gunakan sebagai input ke fungsi dua variabel

Hitung Nilai Fungsi

Langkah selanjutnya adalah mengaitkan nilai keluaran dengan setiap titik di domain masukan kami. Ini adalah titik di mana kita bisa bermain-main dengan fungsi yang berbeda. Saya menemukan “Functions 3D. Contoh” halaman web untuk menjadi sumber inspirasi yang baik

Kami dapat menghitung rangkaian keluaran kami dalam tiga langkah, sekali lagi

1. Definisikan fungsi matematika kita sebagai fungsi Python dari dua input skalar

def func3d(x, y):
    return -np.sin(10 * (x**2 + y**2)) / 10

2. Menghasilkan versi vektor dari fungsi yang dapat dipanggil pada vektor atau matriks input

func3d_vectorized = np.vectorize(func3d)

3. Hitung array keluaran dari dua array domain kami

Z = func3d_vectorized(X, Y)

Fungsi

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

Plot Fungsinya

Dari titik ini, semuanya berjalan dengan cara yang hampir sama seperti saat membuat plot 2D dengan Matplotlib. Hanya beberapa nama argumen dan metode yang perlu diubah untuk menghasilkan visualisasi 3D yang indah

1. Siapkan figur plot dan kapak dengan

   x_points = np.linspace(x_interval[0], x_interval[1], 100)
   y_points = np.linspace(y_interval[0], y_interval[1], 100)

   3

plt.figure(figsize=(20, 10))
ax = plt.axes(projection=’3d’)

2. Pilih metode plotting objek axes dan panggil pada data fungsi kita

ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                cmap=’terrain’, edgecolor=None)

3. Tetapkan atribut plot lainnya, seperti judul dan label sumbu

ax.set(xlabel=”x”, ylabel=”y”, zlabel=”f(x, y)”, 
       title=”Cool Function”)

Untuk metode dan argumen plot lainnya, lihat tutorial mplot3d. Untuk peta warna lainnya untuk argumen cmap, lihat tutorial peta warna Matplotib

Menyatukan Semuanya

Untuk membuat prosesnya lebih dapat direproduksi, saya telah mengemas semua langkah ini bersama-sama ke dalam fungsi Python untuk menghasilkan plot permukaan yang cepat

Sekarang, mengemas dan memodulasi utilitas perencanaan masih sedikit seni, dan itu tergantung pada preferensi pribadi. Terutama dengan perpustakaan seperti Matplotlib, yang berevolusi dari alat plotting yang dimaksudkan terutama untuk penggunaan interaktif (plot MATLAB), mungkin terasa sedikit tidak wajar mengadaptasi urutan kode yang meminta efek sampingnya menjadi sesuatu yang lebih fungsional

Di bawah ini adalah pertimbangan utama yang saya buat dalam membungkus kode plotting 3D. Saya cenderung harus membuat keputusan serupa saat membuat utilitas perencanaan lainnya

Parameter untuk diekspos

Kenop utama yang ingin saya sesuaikan adalah domain fungsi, perincian tempat kisi domain dibuat, dan fungsi aktual yang akan digunakan untuk menghasilkan output. Oleh karena itu, ini adalah tiga argumen pertama saya

Kadang-kadang saya suka juga mengekspos parameter metode plotting atau pengaturan atribut untuk objek figure atau axes. Dalam hal ini, saya mengekspos atribut judul sebagai sesuatu yang dapat saya atur selama pemanggilan fungsi awal saya

Menggunakan x_points = np.linspace(x_interval[0], x_interval[1], 100)y_points = np.linspace(y_interval[0], y_interval[1], 100)_4 atau x_points = np.linspace(x_interval[0], x_interval[1], 100)y_points = np.linspace(y_interval[0], y_interval[1], 100)5

Saya suka menggunakan

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

Ingat, nama

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

Mengembalikan objek

Saya memiliki preferensi untuk pemrograman fungsional, jadi saya mencoba merancang bahkan fungsi plotting saya agar terasa seperti tidak memiliki efek samping. Dengan menggunakan

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

Meskipun secara teknis ini tidak menghilangkan efek samping Matplotlib, melainkan membersihkannya sebelum mereka dapat melakukan apa pun, itu masih cukup untuk memuaskan saya.

Mengembalikan objek figur dan sumbu memungkinkan penyesuaian atau perubahan lebih lanjut. Misalnya, untuk mengubah ukuran gambar, Anda dapat memanggil

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

X, Y = np.meshgrid(x_points, y_points)

Kesimpulan

Sekarang, kita mengetahui langkah-langkah yang diperlukan untuk menghasilkan visualisasi 3D agar keindahan matematika lebih mudah diakses di ujung jari kita

Untuk meninjau, langkah-langkahnya adalah

1. Tentukan domain fungsi. Titik sampel di sepanjang variabel input kami menggunakan np.linspace, dan buat kisi input menggunakan

   x_points = np.linspace(x_interval[0], x_interval[1], 100)
   y_points = np.linspace(y_interval[0], y_interval[1], 100)

   1
2. Hitung nilai fungsi. Tentukan fungsi dari dua variabel — lalu gunakan

   X, Y = np.meshgrid(x_points, y_points)

   3 untuk menerapkannya ke input grid kita
3. Plot fungsinya. Buat figur dan sumbu Matplotlib dengan

   X, Y = np.meshgrid(x_points, y_points)

   4– lalu panggil metode plotting, dan tetapkan parameter tambahan

Anda juga harus melihat bagaimana saya mengemas kode menjadi sesuatu yang dapat digunakan kembali. Saya secara singkat membahas desain antarmuka, berbicara tentang parameter mana yang akan diekspos secara langsung, metode internal mana yang akan digunakan untuk meneruskan argumen menggunakan

X, Y = np.meshgrid(x_points, y_points)

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

Jangan ragu untuk membagikan fungsi paling keren yang Anda temukan. Poin bonus jika Anda memasukkan kode Anda. Selamat merencanakan

Bagaimana Anda membuat grafik fungsi 3D dengan Python?

Bagaimana Anda memplot kotak 3D dengan Python?

Bagaimana Anda memplot array 3D dengan Python?

Bisakah Python membuat grafik 3D?