1.

Perkenalan
Di dunia saat ini, para pendidik dan siswa sadar akan kebutuhan pendidikan sains komunitas
mengenai penggunaan komputasi dalam fisika. Tidak ada keraguan bahwa konvensional perhitungan
tangan sering melelahkan dan memakan waktu ketika jumlah input meningkat, dan / atau parameter
awal yang berbeda diperkenalkan dalam setiap skenario baru a masalah rumit. Lebih penting lagi,
teknik berbantuan komputer tidak bisa dihindari dalam analisis banyak sistem fisik (mis. mekanik
struktural, dan mekanika fluida) yang perilaku harus dipelajari baik secara visual maupun praktis
dalam kondisi dinamis yang berbeda. Meskipun pengetahuan teoritis yang diperoleh selama kuliah
adalah penting dan dapat memainkan peran penting dalam mempelajari prinsip-prinsip dasar,
interpretasi ilmiah dari suatu konsep terbatas. untuk kuliah penuh teori. Implementasi teknologi
komputer modern (mis. Animasi, objek dinamis, dan visualisasi fenomena fisika yang dipelajari)
meningkatkan kualitas siswa persepsi materi dan membantu mereka memahaminya [1]. Adalah
penting untuk mengajar siswa tentang metode komputasi, pengetahuan pemodelan, dan pengalaman
simulasi untuk mendorong mereka menciptakan solusi yang kuat dan praktis untuk masalah dunia
nyata yang akan mereka hadapi karir masa depan mereka [2, 3].
Asosiasi Guru Fisika Amerika merekomendasikan bahwa berbasis komputer aplikasi
dimasukkan ke dalam kurikulum fisika sarjana [4]. Topik dalam mekanika klasik sangat sesuai untuk
tujuan ini karena sangat cocok untuk itu pendekatan komputasi [5]. Sintesis pengembangan
kurikulum, ilmu komputer, ilmu komputer, dan pendidikan fisika akan bermanfaat bagi para ilmuwan
dan siswa ingin menulis simulasi mereka sendiri dan mengembangkan materi kurikuler mereka
sendiri [6]. Selain itu, untuk mendukung aplikasi berbasis komputer, dimasukkannya pengalaman
yang terkait dengan kursus dalam kurikulum akan menawarkan kesempatan luar biasa bagi siswa dan
praktisi disiplin khusus untuk memahami masalah teoritis secara visual [3].
Dalam sebuah studi yang dilakukan di International IT University di Kazakhstan, Daineko et
al [1] meneliti pengaruh penggunaan fisika laboratorium virtual (PVL) pada kinerja Kursus Fisika-1
dan Fisika-2. PVL dikembangkan dalam C # (. NET) berdasarkan XNA4.0 kerangka kerja dan
direalisasikan dengan penggunaan pemodelan 3D dengan menggunakan Blender dan Maya 3D
perangkat lunak. Para penulis mengimplementasikan paket perangkat lunak PVL yang terdiri dari
sembilan fisik percobaan (yaitu mesin Atwood, pendulum Maxwell, metode Clement – Desormes,
Stefan – Boltzmann konstan, sifat fotokonduktivitas semikonduktor, magnetik induksi, hukum arus
searah, hukum Ohm untuk arus bolak-balik, dan pengalaman Frank-Hertz) dari berbagai domain
fisika yang diintegrasikan ke dalam kurikulum tunggal. Studi ini menyimpulkan bahwa pengenalan
teknologi komputer yang inovatif, seperti laboratorium virtual, dapat digunakan selama kuliah untuk
meningkatkan pengalaman mengajar dan meningkatkan pendidikan kualitas, tanpa fasilitas besar dan
biaya material.
Investigasi pada penggabungan ilmu komputasi ke dalam fisika pengantar kursus
mengungkapkan hasil positif. Misalnya, di Universitas Maryland di AS, Redish dan Wilson [7]
mengusulkan lingkungan komputasi berbasis M.U.P.E.T. dimulai dari kursus fisika pengantar untuk
pemrograman siswa. Para penulis melihat beberapa manfaat mengajar fisika di lingkungan yang
terkomputerisasi. Penelitian menyimpulkan bahwa ketika alat sains komputasi dikombinasikan
dengan kursus fisika pengantar, siswa dapat mendiskusikan masalah dunia nyata (mis. gerakan
proyektil dengan hambatan udara) tanpa perlu pengetahuan matematika yang intensif.
Sebuah studi yang didasarkan pada bahasa pemrograman berorientasi objek dilakukan oleh
Lee dan Lee [8] di Universitas Soongsil di Korea membahas berbagai aspek pengembangan interaktif
perangkat lunak pendidikan fisika menggunakan Adobe Flash dan kode sumber ActionScript untuk
simu ??? lator. Mereka mendemonstrasikan tiga contoh simulasi interaktif (mis. Satu dimensi
kinematika: simulator bus; Hukum gerak Newton dan hukum gravitasi: gerak dua benda langit
berinteraksi dengan gravitasi; dan gerakan delapan benda langit di matahari sistem) berdasarkan pada
perangkat lunak Flash yang memungkinkan siswa untuk memahami konsep dasar dalam fisika. Para
penulis menyimpulkan bahwa siswa dapat memahami konsep yang relevan secara intuitif dengan
bantuan yang berorientasi objek dan kemampuan grafis yang kuat dari pemrograman.
Studi lain yang dilaporkan oleh Sherin [9] bertujuan untuk membandingkan kinerja dua yang
berbeda kelompok siswa (dari University of California, Berkeley, USA), kumpulan aljabar dan a
kolam pemrograman, di mana setiap kelompok terdiri dari lima pasang siswa. Dalam penelitian ini,
the kelompok fisika aljabar diminta untuk memecahkan masalah buku teks tradisional (mis. blok
shoved, pitch vertikal, hambatan udara, massa pada pegas, skater yang terdampar, kubus apung, dan
berlari masuk hujan). Para siswa dalam kelompok fisika pemrograman diminta untuk membuat satu
set simulasi gerakan fisik (mis. blok dorong, bola terjatuh, bola terlontar, hambatan udara, dan massa
pada pegas) di lingkungan pemrograman Boxer. Penulis menyimpulkan itu notasi aljabar formula
fisika tidak menunjukkan hubungan sebab akibat antara parameter, dan dengan demikian siswa
diarahkan untukmenemukan keberadaan keseimbangan antara dua sisi persamaan daripada hubungan
sebab akibat. Sebaliknya, pemrograman fisika siswa didorong untuk mencari berbagai fenomena
waktu dan mengekspresikan jenis tertentu intuisi kausal.
Dalam studi pemodelan multidomain fisik berbantuan komputer yang dilakukan di
Universitas Indonesia Ljubljana di Slovenia, Zupančič dan Sodja [10] memodelkan dua sistem
mekanik (yang terbalik pendulum dan helikopter laboratorium) menggunakan MATLAB-Simulink
dan Dymola-Modelica lingkungan dalam kerangka proyek aplikasi pendidikan. Untuk industri mereka
proyek aplikasi, penulis menggambarkan pemodelan dan kontrol termal dan radiasialiran dalam
bangunan, dan dua aplikasi dari produksi mineral-wol: pemodelan a sistem pendulum mekanik, dan
proses recuperator. Penelitian menyimpulkan bahwa MATLAB-Simulink adalah lingkungan yang
sangat berguna untuk desain sistem kontrol berdasarkan model linier. Demikian juga, lingkungan
berbasis Modelica dengan model terbalik dapat dapat digunakan dalam kontrol sistem mekanis.
Studi lain dilakukan oleh Bozkurt dan Ilik [11] di Universitas Selcuk di Turki untuk jelajahi
dampak pengajaran yang didukung oleh simulasi komputer interaktif pada siswa keyakinan tentang
fisika dan prestasi fisika. Dalam penelitian, simulasi (manusia yang bergerak dan energy skate park)
diuntungkan dari sumber daya pemrograman Java dan Flash. Menurut analisis penulis, penelitian
menyimpulkan bahwa kelompok yang menggunakan simulasi komputer lebih sukses daripada mereka
yang bekerja dengan metode tradisional, dan kursus dengan simulasi interaktif memiliki efek positif
pada kepercayaan siswa tentang fisika dan fisika prestasi.
Dalam penelitian lain yang dilakukan oleh Taub et al [12], di Weizmann Institute of Sains di
Israel, tujuan penelitian adalah untuk mengeksplorasi efek dari ilmu komputer pada pemahaman
konseptual siswa tentang fisika di balik formula. Alat pemrograman yang digunakan dalam penelitian
ini adalah Easy Java Simulasi dan Maxima. Untuk menilai dampak pembelajaran simulasi komputer
dalam pendidikan fisika, para siswa dikenakan tiga yang berbeda disiplin ilmu fisika: (i) kinematika
(simulasi meluncurkan roket dan mencegat sebuah roket musuh); (ii) dinamika (simulasi mobil yang
melaju di jalan melingkar); dan (iii) optik (simulasi objek yang terletak di depan lensa yang
diposisikan di depan cermin). Dengan bantuan pemrograman berorientasi objek dari sistem fisik,
analisis penulis menunjukkan bahwa masing-masing domain yang diimplementasikan berkontribusi
pada munculnya pengetahuan proses integrasi, dan mempromosikan pemahaman konseptual dari
konsep fisika.
Akhirnya, Sarabonda et al [13] menyelidiki kontribusi dari simulasi komputer pembelajaran
konsep fisika siswa (berat dan massa) dengan menerapkan simulasi berbasis pada perangkat lunak
Modellus. Dalam analisis, siswa dari empat sekolah di Portugal utara adalah dikenakan tiga skenario
berbeda: (i) hanya menggunakan kegiatan 'hands-on', (ii) hanya menggunakan simulasi komputer dan
(iii) menggunakan keduanya. Studi tersebut menyimpulkan bahwa penggunaan komputer simulasi
meningkatkan pembelajaran siswa tentang konsep-konsep fisika, ketika digunakan sendiri atau
bersama dengan kegiatan 'langsung'. Selain itu, penulis menekankan bahwa total keuntungan yang
dicapai dikaitkan dengan peran mediasi guru saat menggunakan komputer simulasi untuk
mengajarkan konsep berat dan massa.
Penelitian ini bertujuan untuk memperluas temuan positif yang dilaporkan dalam studi ini
berdasarkan penggunaan perhitungan dalam fisika. Tujuan utama penulis bukan pada teori analisis
masalah, tetapi pada pendekatan pemrograman berbantuan komputer. Untuk tujuan ini, dalam
makalah ini, tiga masalah pengantar dipertimbangkan: (i) gerakan proyektil beberapa partikel titik
diluncurkan secara bersamaan, (ii) periode osilasi sederhana bandul pada amplitudo besar, dan (iii)
debit air yang digerakkan gravitasi melalui a lubang bundar di bagian bawah tangki silinder yang
sumbu simetrisnya vertikal. Itu gerakan disimulasikan menggunakan skrip yang ditulis dalam
MATLAB. Deskripsi singkat tentang Fungsi MATLAB akan membuat penelitian ini minat pedagogis
untuk berbagai pembaca, termasuk mereka yang tidak memiliki pengalaman di MATLAB. Sebelum
kata penutup, keuntungan menggunakan MATLAB dibandingkan bahasa pemrograman lain
disediakan untuk pembaca. Penjelasan rinci tentang langkah-langkah yang diperlukan untuk menulis
algoritma disajikan, dankode operasional penuh termasuk dalam lampiran. Selanjutnya, hasil
komputasi dibandingkan dengan hasil eksperimen dalam kasus pendulum dan debit air masalah,
dengan menggunakan nilai-nilai koreksi-percepatan lintang akibat gravitasi. Luar biasa perjanjian
ditemukan.

2. Kinematika gerakan proyektil

Bayangkan sekelompok siswa sedang mendiskusikan gerakan n bola yang diproyeksikan
dengan berbeda kecepatan awal u1 2, ,, u u ¼ n dan luncurkan sudut q1 2,, q q ¼ n di atas horisontal.
Mereka akan ingin mensimulasikan lintasan yang dihasilkan pada satu grafik dan menentukan waktu
penerbangan, jangkauan, dan tinggi maksimum yang dicapai oleh setiap bola. Perhitungan tangan
melelahkan semacam itu dilakukan dalam [14] dapat dihindari menggunakan perangkat lunak
komputer untuk menghidupkan gerakan.
Posisi bola ke-i (di mana saya adalah indeks berjalan dari 1 ke n) pada waktu t setelah
menjadi diluncurkan dari asalnya

xi = vit cos ϴi (1)

untuk posisi horizontal dalam arah gerakan, dan

1
yi = vit sin ϴ1 − gt2 (2)
2

untuk posisi vertikal ke atas, di mana g adalah akselerasi karena gravitasi. Persamaan (1)
menggunakan fakta bahwa komponen horisontal dari kecepatan bola adalah konstan selama gerakan
dengan a nilai vi cos ϴi, sedangkan komponen vertikal bervariasi dalam waktu sebagai

vyi = vi sin ϴi – gt (3)

Dengan mengatur persamaan (2) ke nol, waktu penerbangan bola ke-i ditemukan

2𝑣𝑖 sin 𝜃𝑖
Ti = 𝑔
(4)
dan waktu itu dapat disubstitusikan ke dalam persamaan (1) untuk menemukan rentang Ri. Demikian
juga setengahnya waktu penerbangan dapat disubstitusikan ke dalam persamaan (2) untuk
menemukan tinggi maksimum Hi yang dicapai oleh i bola th.

3. Periode osilasi pendulum sederhana

Pendulum sederhana adalah model ideal [15] yang terdiri dari partikel titik massa m melekat
pada ujung string L. panjang tak terhindarkan bermassa panjang ketika dipindahkan dari nya posisi
kesetimbangan vertikal, bob berayun ke depan dan ke belakang. Hukum kedua Newton memunculkan
ke persamaan diferensial gerak [16]:

𝑑2 𝜃 𝑔
𝑑𝑡 2
+ 𝐿 sin 𝜃 = 0 (5)

Ungkapan ini juga dapat diperoleh dari konservasi energi mekanik. Jika diasumsikan bahwa sudutnya
kurang dari 0,1 rad (atau sekitar 6 °) sehingga θ ≪ 1, maka sin θ ≈ θ dalam radian. Karena kasus,

𝑑2 𝜃
+ 𝜔2 𝜃 = 0 (6)
𝑑𝑡 2

di mana 𝜔 = √𝑔/𝐿 adalah frekuensi sudut osilasi (harus dibedakan dengan cermat kecepatan sudut
𝑑𝜃/𝑑𝑡). Kesalahan dalam pendekatan sudut kecil ini adalah urutan 𝜃 3 (dari seri Taylor untuk dosa θ).
Jika perpindahan sudut awal adalah θ0 dan bob adalah dilepaskan dari diam, maka solusi untuk
persamaan (6) adalah

𝑔
𝜃0 cos(√ 𝐿 𝑡) dimana 𝜃0 ≪ 1 (7)

Gerakan ini harmonik sederhana dengan periode

𝐿
𝑇0 = 2𝜋√𝑔 dimana 𝜃0 ≪ 1. (8)

Periode ini tidak tergantung pada amplitudo 𝜃0, properti yang dikenal sebagai isokronisme, sebagai
ditemukan oleh Galileo [17, 18].
Namun, untuk amplitudo yang lebih besar periode T lebih besar dari T0. Dalam hal ini,
periode dapat diperluas dalam seri Legendre [18] sebagai

𝐿 (2𝑛)! 2 𝜃
𝑇 = 2𝜋√𝑔 ∑∞
𝑛=0 {[(2𝑛 𝑛!)2 ] 𝑠𝑖𝑛
2𝑛
( 20 )} (9)

Sebuah pendekatan yang sangat baik disediakan oleh metode rata-rata aritmatika-geometris [19],
yang memprediksi

𝐿 2
𝑇 ≈ 8𝜋 √𝑔 (1 + √𝐶𝑂𝑆 𝜃 2 ) (10)

dengan kesalahan relatif kurang dari 1% untuk sudut hingga 163 °.

4. Pengeluaran air dari tangki silindris vertikal
Air yang mengalir keluar dari lubang melingkar dalam sebuah tangki adalah contoh aliran
yang tidak stabil karena fluida massa di dalam volume kontrol (CV) bervariasi dengan waktu. Yaitu,
dmCV ≠ 0 di mana dmCV adalah rate dari perubahan massa dalam CV [3, 20]. Menggunakan hukum
Torricelli, laju aliran volumetrik adalah

𝐶𝑑 √2𝑔𝑧 𝜋𝑑02
𝑄= 4
(11)

di mana Cd adalah koefisien debit mulai dari nilai 0 hingga 1, z adalah waktu yang bervariasi jarak
dari permukaan bebas air di tangki ke lubang, lakukan adalah diameter lubang, dan g adalah
percepatan gravitasi. Dengan tidak adanya kerugian kental dan vena contracta [21], Cd akan sama
dengan 1.
Dengan menggunakan persamaan kontinuitas, persamaan (11) dapat diintegrasikan untuk
tangki vertikal bagian dalam diameter D untuk menemukan waktu T yang diperlukan untuk
permukaan air mengalir ke ketinggian h di atas lubang sebagai

ℎ 𝜋𝐷2
𝑇 ℎ ∫ℎ 4
0
∫0 𝑑𝑡 == − ∫ℎ 𝑑𝑧 (12)
0 𝐶𝑑√2𝑔𝑧𝜋𝑑2 /4
0

dimulai dengan air saat istirahat pada ketinggian awal h0. Melakukan integral memberi

1 𝐷 2 2 0.5
𝑇(ℎ) = (𝐶 ) (𝑑 ) (𝑔) (√ℎ0 − √ℎ) (13)
𝑑 0

5. Prosedur komputasi
Simulasi berbasis komputer dilakukan dengan menulis skrip dalam MATLAB R2018a pada 64 bit
Sistem Windows 10. Prosedur komputasi selangkah demi selangkah diringkas sebagai berikut.
Langkah 1. Kosongkan memori sistem dan atur format output. 'Jendela Editor' (untuk a M-
File baru) dibuka di MATLAB. Semua isi memori sistem saat ini dan semua variabel di ‘Command
Window’ terhapus, dan visual ‘Command Window’ dan perintah output dikustomisasi menggunakan
fungsi bawaan jelas (yang melepaskan semua variabel dari ‘Workspace’ saat ini dan dari memori
sistem), clc (yang menghapus semua input dan output perintah dari tampilan dan rumah kursor), dan
format pendek (yang mengatur output format tampilan ke format desimal tetap berskala dengan empat
digit setelah titik desimal).

Langkah 2. Atur parameter input. Di ‘Jendela Editor’, tugas dibuat untuk masing-masing
variabel input menggunakan input fungsi bawaan: (a) untuk gerakan proyektil — luncurkan sudut (θ1,
θ2,...., θn), kecepatan awal (v1, v2,...., vn), jumlah n bola yang diproyeksikan, dan penaikan gravitasi g; (b)
untuk osilasi pendulum — panjang L string, amplitudo sudut θ0, dan percepatan gravitasi g; dan (c)
untuk debit air — ketinggian awal h0, tinggi akhir h, diameter D dari tangki air, diameter d0 lubang,
koefisien debit Cd, dan percepatan gravitasi g.

Langkah 3. Tentukan formula. Persamaan dikodekan menggunakan fungsi bawaan yang

berbeda sesuai dengan metode simbolik dan numerik yang digunakan: (a) untuk gerakan proyektil
komponen horisontal dan vertikal dari kecepatan awal υ0x dan υ0y, total waktu penerbangan T,
rentang R, dan tinggi maksimum H dari setiap bola dihitung menggunakan fungsi bawaan cosd
(cosinus argumen dalam derajat), sind (sinus argumen dalam derajat), dan maks (mengembalikan
elemen terbesar dalam array); (B) untuk osilasi pendulum — perkiraan sudut kecil, Seri Legendre,
dan metode rata-rata aritmatika-geometrik diimplementasikan menggunakan built-in fungsi pi (nilai
π), syms (pintasan untuk variabel simbolik), gamma (fungsi gamma), sin (sinus argumen dalam
radian), symsum (penjumlahan simbolis dari suatu seri), ganda (konversi nilai menjadi presisi ganda),
dan sqrt (akar kuadrat); dan (c) untuk debit air— waktu T untuk permukaan air mengalir ke
ketinggian h di atas lubang ditentukan menggunakan fungsi bawaan syms, pi, sqrt, int (integrasi
simbolik), dobel, @ (fungsi handle), quad (integrasi numerik berdasarkan quadrature Simpson
adaptif), dan fix (putaran a skalar ke bilangan bulat terdekat dengan nol). Selain itu, kode timer
stopwatch tic dan toc adalah digunakan untuk mengukur waktu CPU atau waktu yang berlalu untuk
analisis dalam hitungan detik.

Langkah 4. Keluarkan hasilnya. Format output dibuat menggunakan fungsi fprintf bawaan.
Fungsi ini menentukan angka titik-mengambang% d1.d2 dengan lebar digit d1 memiliki d2 digit
setelah titik desimal. Itu juga dapat menyertakan karakter kontrol / n untuk memulai baris baru.
Setelah menjalankan skrip di ‘Jendela Editor’, array numerik dan karakter yang dihasilkan dikirim ke
‘Jendela Perintah’ dan disimpan di ‘Ruang Kerja’.

Langkah 5. Buat animasi. Objek garis primitif, dalam hal yang berbasis waktu gerakan
dianimasikan, dibuat menggunakan garis fungsi bawaan menggunakan data yang disimpan dalam
vektor x dan y. Seperti opsi dalam perintah baris, ‘LineStyle’ seperti ‘-’, ‘LineWidth’ seperti ‘2’,
‘Warna’ seperti ‘r’, ‘Penanda’ seperti ‘.’, Dan ‘MarkerSize’ seperti ‘40 are ditentukan untuk
mengontrol penampilan dan perilaku garis dan spidol.

Selain itu, fungsi bawaan berikut ini diperkenalkan untuk meningkatkan simulasi lingkungan:
sumbu (yang menetapkan batas sumbu dan rasio aspek), sumbu sama (yang menggunakan hal yang
sama panjang untuk unit data di sepanjang setiap sumbu), judul (yang menambahkan judul yang
ditentukan ke sumbu atau bagan), xlabel (yang memberi label sumbu-x dari sumbu atauz bagan saat
ini), ylabel (yang memberi label sumbu-y dari sumbu atau bagan saat ini), kotak aktif (yang
menampilkan kotak di sekitar sumbu aktif), kotak aktif (yang menampilkan garis kisi utama untuk
sumbu atau bagan saat ini), set (yang menentukan nilai untuk properti nama objek yang
diidentifikasi), gcf (yang mengembalikan sumbu atau bagan saat ini untuk gambar saat ini), findall
(yang menemukan objek teks untuk label sumbu x), gcf (yang mengembalikan pegangan gambar saat
ini), tahan (yang menahan plot saat ini di memori sambil menambahkan kurva baru ke sana), sprintf
(yang memformat string data), dan jeda (yang sementara menghentikan eksekusi).

Langkah 6. Hidupkan gerakannya. Pada langkah terakhir, ‘untuk indeks = nilai, pernyataan,
loop akhir dibangun untuk mengeksekusi sekelompok pernyataan beberapa kali. Untuk saat ini
masalah, nilai dibuat sebagai vektor waktu dengan menggunakan fungsi built-in linspace (yang
mengembalikan vektor baris n titik spasi secara merata dalam interval [0, T] untuk gerakan proyektil,
[θ0, −θ0] untuk osilasi pendulum, dan [0, T] untuk debit air). Fungsi set digunakan untuk
menampilkan nama properti dan nilai objek garis yang dibuat pada Langkah 5. Untuk gerakan
proyektil dan osilasi pendulum, plot fungsi membuat grafik garis dua dimensi (2D) dari data y versus
nilai x yang sesuai. Untuk mensimulasikan gerakan proyektil dan debit air, the Fungsi sprintf
digunakan untuk memformat data waktu sebagai string. Untuk masalah debit air, animasi permukaan
air yang mengalir bebas diwarnai menggunakan fungsi fill (yang membuat poligon 2D yang
ditentukan oleh x dan y dengan warna ‘ColorSpec’) atau tambalan (yang menciptakan a tambalan
padat memiliki bentuk yang ditentukan oleh vektor koordinat x dan y). Di semua skrip, built-in fungsi
M (r) = getframe diimplementasikan untuk menangkap sumbu saat ini seperti yang muncul di layar
sebagai bingkai film. Di sini M adalah struktur yang berisi data gambar, dan r menunjukkan
indeksnya. Untuk osilasi pendulum, fungsi film digunakan untuk memutar film yang direkam
ditentukan oleh matriks yang kolomnya adalah frame yang diproduksi oleh getframe, menggunakan
sumbu saat ini sebagai target default. Itu kode film (M, n <0) memutar film | n | waktu. Nilai negatif
dari n berarti bahwa setiap siklus adalah bermain maju dan kemudian mundur.

Gambar 1. Masalah gerakan proyektil: (a) tangkapan layar yang diambil pada titik perantara selama
animasi; (B) tangkapan layar di akhir animasi; dan (c) isinya dari jendela ‘Ruang Kerja’ setelah skrip
selesai.

6. Simulasi berbasis MATLAB

Perhitungan dilakukan untuk setiap masalah dengan menjalankan skrip MATLAB yang disajikan
dalam tabel A1 – A5 dari lampiran. Skrip dievaluasi di ‘Jendela Editor’ dan output untuk berbagai
variabel input ditunjukkan pada Gambar 1-3. Pertimbangan dari 'Waktu yang berlalu adalah keluaran
K detik' dari kode Timer Stopwatch 'Command Window' menunjukkan bahwa perhitungan yang
memakan waktu dapat dihindari bantuan perangkat lunak komputasi. MATLAB menyediakan
platform pendidikan yang sangat baik untuk mengamati hasil secara numerik dan visual. Penghematan
ini memungkinkan siswa untuk menghabiskan lebih banyak waktu belajar dan mempraktekkan
masalah untuk input yang berbeda. Meski perhitungannya waktu yang diperlukan untuk masalah
osilasi pendulum lebih tinggi dari itu untuk masalah lainnya karena solusi simbolis yang diterapkan
untuk menjumlahkan seri Legendre, berbasis MATLAB pendekatan tetap memuaskan dalam hal
kecepatan eksekusi. Penggunaan CPU maksimum yang tercatat di Task Manager adalah 17%, 4%,
dan 18% saat mensimulasikan gerakan proyektil, osilasi pendulum, dan masalah pembuangan air,
masing-masing, di MATLAB. Perbedaan dalam permintaan CPU ini berasal dari ukuran waktu vektor
yang terlibat dan jumlah bingkai film yang diambil. Script MATLAB tambahan adalah disajikan
dalam tabel A4 dan A5 dari lampiran untuk osilasi pendulum, dan output nasional yang diperoleh dari
kode-kode ini disajikan pada Gambar 4 dan 5.

7. Perbandingan dengan studi eksperimental

Untuk memvalidasi analisis komputasi, prediksi diuji secara eksperimental dalam 2017–2018 Spring
Term dengan partisipasi aktif 60 mahasiswa sarjana di Universitas Yildiz Techical di Istanbul, Turki,
dalam program sarjana CEV2232 ‘Mekanisme Fluida untuk

Gambar 2. Masalah osilasi pendulum: (a) tangkapan layar selama animasi; (b) a tangkapan layar di
akhir animasi; dan (c) isi dari jendela sp Ruang Kerja ’ setelah menyelesaikan skrip.

Gambar 3. Masalah debit air: (a) tangkapan layar selama animasi; (b) a tangkapan layar di akhir
animasi; dan (c) isi dari jendela sp Ruang Kerja ’ setelah menyelesaikan skrip.
Gambar 4. Output yang diperoleh dengan menjalankan skrip pada tabel A4.

Gambar 5. Output skrip pada tabel A5: (a) hasil numerik (berdasarkan variabel input, nilai energi, dan
waktu yang berlalu) dalam ‘Jendela Perintah’ dan (b) grafik potensi dan energi kinetik selama
setengah siklus osilasi

Gambar 6. Pengaturan eksperimental untuk (a) percobaan bandul dan (b) tangki percobaan debit.

Pengukuran osilasi pendulum dan debit air dilakukan. Setiap siswa diminta untuk mengukur
periode osilasi dan waktu pengosongan menggunakan arloji atau ponsel telepon. Setiap percobaan
diulang tiga kali untuk menentukan reproduktifitasnya. Silinder lulus polipropilen 1 L (produk Isolab
# 025.01.600) dan tahan karat pendulum baja (produk Isolab # S.049.01.200.001) digunakan dalam
pengaturan eksperimental, seperti difoto pada gambar 6. Pertama, nilai percepatan gravitasi g pada
lokasi laboratorium dihitung secara numerik [22], dan kemudian diverifikasi menggunakan pendulum
sederhana. Nilai teoretisnya sebagai fungsi garis lintang 𝜑 adalah

(14)

kutub khatulistiwa 𝜑 sedangkan nilai eksperimentalnya adalah (dari persamaan (10))

(15)

Di sini, g45, gpole, dan gequator, masing-masing, 9,806 m s − 2 di 45 ° lintang, 9,832 m s − 2 di kutub,
dan 9,780 m s − 2 di khatulistiwa. Garis lintang untuk lab adalah 41 ° 02′36.60 ′ N sehingga =
41,0435 °. Panjang tali adalah L = 0,99 m, dan perpindahan sudut awal adalah θ0 = 10 °.
Persamaan (14) memprediksi gtheor = 9,802 m s – 2. Eksperimen pendulum dilakukan selama
sepuluh osilasi menghasilkan periode osilasi rata-rata Texp = 1,999 ± 0,036 s, jadi gexp = 9,819 m s −
2 dari persamaan (15). Secara eksperimental, waktu pengeluaran rata-rata ditemukan menjadi 355 ± 1
s, yang setuju dengan nilai yang dihitung menggunakan persamaan (13). Di akhir percobaan, para
siswa diminta untuk memberikan komentar anonim tentang itu. Beberapa dari mereka direproduksi di
bawah ini (di mana M menunjukkan seorang siswa laki-laki dan F a siswi).
• M: ‘Eksperimen sangat berguna dan membesarkan hati saya karena visualisasi bidang teoretis dalam
kehidupan nyata, berkat aktivitas pendidikan ini. '
• F: ‘Saya percaya bahwa aplikasi ini adalah upaya yang tak terlupakan, menarik, dan luar biasa itu
telah menjadikan penghitungan teoretis dan analisis berbasis komputer menjadi lebih permanen. '
• M: think Saya pikir itu mengalami validasi analisis komputasi secara visual meningkatkan
pemahaman konsep-konsep utama untuk masalah masing-masing. '
• F: ‘Saya telah mengalami kuliah yang komprehensif dan berbasis target dengan bantuan studi
eksperimental. "

8. Manfaat MATLAB dibandingkan bahasa pemrograman lain

MATLAB (berasal dari MATrix LABoratory) adalah paket perangkat lunak canggih yang
mencakup fungsi bawaan untuk mencapai berbagai tugas, dari operasi matematika hingga pemrosesan
gambar tiga dimensi. MATLAB menyediakan satu set lengkap alat pemrograman yang
memungkinkan pengguna untuk menyesuaikan program dengan spesifikasi mereka sendiri. Siswa
pemula yang mempelajari fungsi built-in akan siap menggunakan MATLAB. Kemudian, pendekatan
terbaik adalah mengajar mereka baik konsep pemrograman dan fitur fungsi lanjutan untuk karir masa
depan mereka [23]. Karena MATLAB mudah digunakan, ini adalah lingkungan komputasi yang
sempurna untuk ini tugas dalam pengajaran pemrograman dan teknik pemecahan masalah [2, 3, 23–
28].

Beberapa variabel matematika dapat dengan mudah dimasukkan ke dalam komputasi

MATLAB lingkungan sebagai matriks (r × c, di mana r> 1 dan c> 1), skalar (r × c, di mana r = c = 1),
array baris atau vektor horisontal (1 × c, di mana c> 1), dan array kolom atau vektor vertikal (r × 1, di
mana r> 1) [3]. Pendekatan ini memungkinkan perhitungan yang rumit dapat diselesaikan secara
efisien menggunakan berbagai fungsi bawaan dan / atau fungsi yang ditentukan pengguna dalam file-
M [3, 24]. Jadi, jika a masalah dapat dirumuskan dengan solusi berbasis matriks, MATLAB
dijalankan secara substansial lebih cepat daripada program serupa dalam bahasa tingkat tinggi.
Sementara MATLAB menyediakan pengguna kemudahan membuat matriks, matriks harus
didefinisikan dalam pemrograman C menggunakan perulangan seperti a 'for / end loop'. Selain itu,
keuntungan utama dari pemrograman MATLAB lebih dari C saat melakukan perhitungan numerik
adalah bahwa MATLAB ditafsirkan. Artinya, Anda bisa melihat hasilnya satu perintah sebelum Anda
melanjutkan ke yang berikutnya, tidak seperti pemrograman C di mana Anda harus kompilasi sumber
setiap kali Anda melakukan perubahan [29]. Program 'penghilangan angka' (mis. Pemrosesan data
numerik skala besar) umumnya lebih mudah untuk menulis dalam MATLAB dibandingkan dengan
program lain [24]. Sebagai contoh, Python adalah bahasa pemrograman tujuan umum yang
membutuhkan pustaka add-on untuk melakukan bahkan matematika dasar. Matriks dan array
matematika dalam Python membutuhkan pemanggilan fungsi, bukan operator alami, dan Anda harus
melacak perbedaan antara skalar, array satu dimensi (1D), dan Array 2D. MATLAB, di sisi lain, tidak
membuat perbedaan buatan antara skalar, 1D, 2D, dan array multidimensi. Tidak seperti Python,
kotak alat MATLAB menawarkan secara profesional mengembangkan, fungsionalitas diuji keras,
lapangan-mengeras, dan sepenuhnya didokumentasikan untuk ilmiah dan aplikasi teknik [30].
Demikian juga, berbeda dengan pemrograman R, MATLAB menyediakan (i) lingkungan
pengembangan dengan produktivitas tinggi, (ii) kotak alat dan aplikasi yang luas, (iii) lebih cepat
kinerja dan penyebaran yang mudah, dan (iv) jaminan kualitas dan keandalan [31]. Lebih lanjut,
MATLAB memiliki kelebihan sebagai berikut tambahan dibandingkan metode lain atau bahasa [32]:
(i) seseorang dapat melakukan operasi dari baris perintah sebagai canggih kalkulator dan kembangkan
program dan fungsi yang mengimplementasikan tugas berulang; (ii) menambahkan dua array bersama
hanya membutuhkan satu perintah baris tunggal, bukan untuk atau sementara loop; (iii) itu mudah
untuk memplot data dan kemudian menentukan warna, gaya garis, dan spidol dengan menggunakan
grafik alat interaktif; dan (iv) fungsinya dapat sangat diperluas dengan penambahan kotak alat (set
fungsi spesifik yang menyediakan fungsionalitas yang lebih khusus).

9. Keterangan penutup
Analisis komputasi ini memenuhi tujuan instruksional dan berbasis penelitian yang penting. Prinsip
dasar kinematika dan mekanika dari fisika pengantar dan rekayasa disimulasikan untuk tiga masalah
berbeda. Kode rinci disediakan (sebagai lampiran) dan ditulis menggunakan MATLAB. Poin utama
dari kode ini adalah ringkas menjelaskan, hasil kode dibandingkan dengan percobaan yang relevan,
dan dampak pendidikan dari seluruh pengalaman dibuktikan dengan pilihan komentar siswa dari kelas
60. Menggunakan properti kuat dan fleksibel dari MATLAB, terutama termasuk miliknya alat
numerik dan grafis, banyak aspek yang menantang dari skenario yang diperluas ini bisa diselidiki oleh
siswa. Hanya beberapa makalah sebelumnya [33] yang telah menyajikan MATLAB lengkap zkode,
perbandingan hasil simulasi dan eksperimen di tingkat fisika pengantar, dan pengujian lapangan dari
pekerjaan komputer dan praktikum dalam kursus aktual dengan koleksi evaluasi siswa langsung dari
proyek. Mengingat temuan positif dari karya ini, masa depan pekerjaan akan memperluas simulasi ini
ke topik teoretis dan eksperimental lainnya.
Lampiran
Kode MATLAB yang sepenuhnya dapat dieksekusi dari tiga masalah berbasis waktu dari teks utama
adalah disajikan dalam lima tabel berikut.

Table A1. Script for the projectile motion problem of 3 balls having different initial speeds
and launch angles.

%Ball motion problem (simulation of n balls) disp(' theta2 v02 vx2 vy2 tf2 xmax2 hmax2');
fprintf('%10.0f %6.0f %9.4f %9.4f %9.4f %9.4f %9.4f/n',table2);
%STEP 1 disp('————————————————————————
clear, clc '); table3=[theta3;v03;vx3;vy3;tf3;xmax3;hmax3]; disp(' theta3
format short v03 vx3 vy3 tf3 xmax3 hmax3');
disp(datestr(now,0)) fprintf('%10.0f %6.0f %9.4f %9.4f %9.4f %9.4f %9.4f n',table3);
toc
%STEP 2
theta1 = input('Enter the angle (deg) between velocity vector %STEP 5
and ground = ');
v01 = input('Enter initial velocity (m/s) = '); xmax = max([xmax1,xmax2,xmax3]);
theta2 = input('Enter the angle (deg) between velocity vector hmax = max([hmax1,hmax2,hmax3]);
and ground = ');
 Table A1. (Continued.)
v02 = input('Enter initial velocity (m/s) = '); f1 = line([0 xmax],[0 0],'linestyle','-','color','b','linewidth',4);
theta3 = input('Enter the angle (deg) between velocity vector f11 = line(0,0,'linestyle','none','marker','.','markersize',70,'color','b');
and ground = ');
v03 = input('Enter initial velocity (m/s) = '); f12 = line(0,0,'linestyle','none','marker','.','markersize',60,'color','r');
tic f13 = line(0,0,'linestyle','none','marker','.','markersize',40,'color','k');
axis([0 xmax 0 hmax]);
%STEP 3 %title('Projectile Motion')
%Horizontal and vertical components of the velocity vectors xlabel(' itHorizontal range (m)','FontSize',14,'FontWeight','Bold')
vx1 = v01*cosd(theta1); ylabel(' itVertical range (m)','FontSize',14,'FontWeight','Bold')
vy1 = v01*sind(theta1); box on
vx2 = v02*cosd(theta2); grid on
vy2 = v02*sind(theta2); set(gca,'FontSize',14,'FontWeight','Bold')
* set(findall(gcf,'type','text'),'FontSize',14,'FontWeight','Bold')
*
hold on
tt = title(sprintf('Maximum flight time: %0.4f sec', 0),'FontSize',14);
%Total flight times (sec) for the motion pause(5)
g = 9.807; %Gravitational acceleration (m/s2)
tf1 = 2*vy1/g; %STEP 6
tf2 = 2*vy2/g; tmax = max([tf1,tf2,tf3]);
tf3 = 2*vy3/g; t = linspace(0,tmax,200);
for r = 1:length(t)
%Maximum horizontal and vertical ranges (meters) for the x1(r) = vx1*t(r);
motion
xmax1 = vx1*tf1; h1(r) = vy1*t(r)-0.5*g*t(r)^2;
hmax1 = vy1*(tf1/2)-0.5*g*(tf1/2)^2; x2(r) = vx2*t(r);
xmax2 = vx2*tf2; h2(r) = vy2*t(r)-0.5*g*t(r)^2;
hmax2 = vy2*(tf2/2)-0.5*g*(tf2/2)^2; x3(r) = vx3*t(r);
xmax3 = vx3*tf3; h3(r) = vy3*t(r)-0.5*g*t(r)^2;
hmax3 = vy3*(tf3/2)-0.5*g*(tf3/2)^2; plot(x1(r),h1(r),'.b',x2(r),h2(r),'.r',x3(r),h3(r),'.k','LineWidth',1)
set(f1,'xdata',[0 xmax],'ydata',[0 0]);
%STEP 4 set(f11,'xdata',x1(r),'ydata',h1(r));
table1=[theta1;v01;vx1;vy1;tf1;xmax1;hmax1]; set(f12,'xdata',x2(r),'ydata',h2(r));
disp(' theta1 v01 vx1 vy1 tf1 xmax1 hmax1'); set(f13,'xdata',x3(r),'ydata',h3(r));
fprintf('%10.0f %6.0f %9.4f %9.4f %9.4f %9.4f %9.4f set(tt, 'String', sprintf('Maximum flight time: %0.4f sec', t(r)));
n',table1);
disp('—————————————————————'); M(r) = getframe;
table2=[theta2;v02;vx2;vy2;tf2;xmax2;hmax2]; end

Table A2. Script for the oscillation period of a simple pendulum.

%Pendulum oscillation #1 (periods, deviations, and disp('Computed periods (sec) and deviations from small-angle
simulation) approximation:');
disp(' T1(sec) T2(sec) T3(sec) ');
%STEP 1 disp('Simple harmonic Legendre Deviation(%)
Aritmetico Deviation(%)');
clear, clc fprintf('%10.4f %14.4f %10.4f %13.4f %11.4f n',table);
format short toc
disp(datestr(now,0))
%STEP 5
%STEP 2 f1 = line([-L L],[L L],'linestyle','-','color','k','linewidth',6);
L = input('Enter the length (m) of the pendulum = '); f2 = line([0 0],[L 0],'linestyle','-','color','k','linewidth',2);
tic f3 = line(0,0,'linestyle','none','marker','.','markersize',100,'color','b');
g = 9.807; %Gravitational acceleration (m/s2) axis([-L L -L L])
theta = input('Enter the angular displacement axis equal
(deg) = '); *
title(' itSimple Pendulum Motion','FontSize',14)
xlabel(' itHorizontal Range (m)','FontSize',14)
Eur. J. Phys. 39 (2018) 065803 K Yetilmezsoy and C E Mungan

Table A2. (Continued.)

%STEP 3 ylabel(' itVertical Range (m)','FontSize',14)
%Period for the small-angle approximation: box on
T1 = (2*pi)*((L/g)^0.5); grid on
set(gca,'FontSize',14,'FontWeight','Bold')
%Legendre series: set(findall(gcf,'type','text'),'FontSize',14,'FontWeight','Bold')
syms n hold on
M1 = gamma(2*n+1); pause(5)
M2 = 2^(2*n);
M3 = (gamma(n+1))^2; %STEP 6
M4 = (M1/(M2*M3))^2; theta2 = linspace(theta,-theta,10);
M5 = (sin(theta1/2))^(2*n); for r = 1:length(theta2)
M6 = M4*M5; x(r) = L*sind(theta2(r));
M7 = symsum(M6,0,inf); y(r) = L-L*cosd(theta2(r));
T21 = T1*M7; set(f1,'xdata',[-L L],'ydata',[L L]);
T2 = double(T21); set(f2,'xdata',[0 -x(r)],'ydata',[L y(r)]);
%Deviation from the small-angle approximation: set(f3,'xdata',[-x(r)],'ydata',[y(r)]);
D2 = ((T2-T1)/T2)*100; plot(-x(r),y(r),'.r')
M(r) = getframe;
%Arithmetic-geometric mean method: end
T3 = (4*T1)*((1+sqrt(cos(theta1/2)))^-2); xmax = max(x);
%Deviation from the small-angle approximation: ymax = max(y);
D3 = ((T3-T1)/T3)*100; disp(['Maximum horizontal displacement = ' num2str(xmax) ' m']);
disp(['Maximum vertical displacement = ' num2str(ymax) ' m']);
%STEP 4 movie(M,-10)
table = [T1;T2;D2;T3;D3];

Table A3. Script for water flowing out of a circular hole in a vertical cylindrical tank.

%Discharge of water from a vertical cylindrical tank (simulation) %STEP 5

f1 = line([-do/2 -d/2],[0 0],'linestyle','-','color','k','linewidth',4);
%STEP 1 f2 = line([-d/2 -d/2],[0 h],'linestyle','-','color','k','linewidth',4);
clear, clc f3 = line([do/2 d/2],[0 0],'linestyle','-','color','k','linewidth',4);
format short f4 = line([d/2 d/2],[0 h],'linestyle','-','color','k','linewidth',4);
disp(datestr(now,0)) f5 = line([-d/2 d/2],[h h],'linestyle','-','color','b','linewidth',4);
%axis([-2*d 2*d 0 h]);
%STEP 2 xlabel(' itHorizontal range (m)','FontSize',14,'FontWeight','Bold')
h = input('Enter the height (m) of the water tank, h = '); ylabel(' itHeight (m)','FontSize',14,'FontWeight','Bold')
hf = input('Enter the final height (m) of the water, hf = '); axis equal
d = input('Enter the diameter (m) of the water tank, d = '); box on
do = input('Enter the orifice diameter (m), do = '); grid on
Cd = input('Enter the discharge factor, Cd = '); set(gca,'FontSize',14,'FontWeight','Bold')
g = 9.807; %Gravitational acceleration (m/s2) set(findall(gcf,'type','text'),'FontSize',14,'FontWeight','Bold')
tic hold on
tt = title(sprintf('Time: %0.4f sec', 0),'FontSize',14);
%STEPS 3-4 patch([-d/2 d/2 d/2 -d/2],[0 0 h h],'blue') pause(5)
%Hand calculation
time = (1/Cd)*((d/do)^2)*((2/g)^0.5)*(sqrt(h)-sqrt(hf))
minute = fix(time/60) %STEP 6
second = (time/60 - minute)*60 t1 = linspace(0,time,1000);
toc for r = 1:length(t1)
K = (1/Cd)*((d/do)^2)*((2/g)^0.5);
%Symbolic-based solution h1(r) = (sqrt(h)-((t1(r)/K)))^2;
%syms z set(f1,'xdata',[-do/2 -d/2],'ydata',[0 0]);
%A = pi*(d^2)/4; set(f2,'xdata',[-d/2 -d/2],'ydata',[0 h]);

15
Eur. J. Phys. 39 (2018) 065803 K Yetilmezsoy and C E Mungan

Table A3. (Continued.)

%ao = pi*(do^2)/4; set(f3,'xdata',[do/2 d/2],'ydata',[0 0]);
%Eq = -(A/(ao*Cd))*1/(sqrt(2*g*z)); set(f4,'xdata',[d/2 d/2],'ydata',[0 h]);
%I1 = int(Eq,h,hf); %1000 mL filled set(f5,'xdata',[-d/2 d/2],'ydata',[h1(r) h1(r)]);
%time = double(I1) fill([-d/2 d/2 d/2 -d/2],[0 0 h h],'w')
%patch([-d/2 d/2 d/2 -d/2],[0 0 h h],'white')
%Numeric integration-based solution fill([-d/2 d/2 d/2 -d/2],[0 0 h1(r) h1(r)],'b')
%A = pi*(d^2)/4; %patch([-d/2 d/2 d/2 -d/2],[0 0 h1(r) h1(r)],'blue')
%ao = pi*(do^2)/4; %patch('Faces',[1 2 3 4],'Vertices',[-d/2 0; d/2 0; d/2 h1(r);...
%Eq = @(z) -(A./(ao.*Cd)).*1./(sqrt(2.*g.*z)); %-d/2 h1(r)],'FaceColor','blue');
%time = quad(Eq,h,hf) set(tt, 'String', sprintf('Time: %0.4f sec', t1(r)));
%minute = fix(time/60) M(r) = getframe;
%second = (time/60 - minute)*60 end

Table A4. Script that accepts the length of a massless inextensible string as an input and
returns three figures displaying the oscillation period, percent deviation, and horizontal
displacement.

%Pendulum oscillation #2 (amplitude-related graphs) subplot(3,1,1)

clear, clc plot(theta,T2,'-r','Linewidth',2)
format short hold on
disp(datestr(now,0)) plot(theta,T3,'-b','Linewidth',2)
L = input('Enter the length (m) of the pendulum = '); legend('Legendre series','Arithmetic-geometric mean','Location','NorthWest')
tic xlabel(' theta_{0}: Amplitude (deg)')
g = 9.807; %Gravitational acceleration (m/s2)) ylabel('T: Period (sec)')
%Period for the small-angle approximation: title(['Length: L = ' num2str(L) ' m, Period: T_{1} = ' num2str(T1) ' sec '])
T1 = (2*pi)*((L/g)^0.5); box on
grid on
theta = 1:1:90; set(gca,'FontSize',12,'FontWeight','Bold')
for r = 1:length(theta)
theta1(r) = theta(r)*pi/180; %Conversion to radian %Amplitude versus period deviation from the small-angle approximation
%Horizontal distance from equilibrium position subplot(3,1,2)
x(r)=sind(theta(r))*L; plot(theta,D2,'-r','Linewidth',2)
hold on
%Legendre series: plot(theta,D3,'-b','Linewidth',2)
syms n legend('Legendre series','Arithmetic-geometric mean','Location','NorthWest')
M1 = gamma(2*n+1); xlabel(' theta_{0}: Amplitude (deg)')
M2 = 2^(2*n); ylabel('Deviation percentage (%)')
M3 = (gamma(n+1))^2; title('Deviations from T_{1} (small-angle approximation period)')
M4 = (M1/(M2*M3))^2; box on
M5(r) = (sin(theta1(r)/2))^(2*n); grid on
M6(r) = M4*M5(r); set(gca,'FontSize',12,'FontWeight','Bold')
M7(r) = symsum(M6(r),0,inf);
T21(r) = T1*M7(r); %Amplitude versus horizontal displacement
T2(r) = double(T21(r)); subplot(3,1,3)
%Deviation from the small-angle approximation: plot(theta,x,'-k','Linewidth',2)
D2(r) = ((T2(r)-T1)/T2(r))*100; legend('Amplitude vs. Horizontal displacement','Location','NorthWest')
xlabel(' theta_{0}: Amplitude (deg)')
%Arithmetic-geometric mean method: ylabel('x distance from equilibrium (m)')
T3(r) = (4*T1)*((1+sqrt(cos(theta1(r)/2)))^-2); title('Horizontal displacement')
%Deviation from the small-angle approximation: box on
D3(r) = ((T3(r)-T1)/T3(r))*100; grid on
end set(gca,'FontSize',12,'FontWeight','Bold')
set(findall(gcf,'type','text'),'FontSize',12,'FontWeight','Bold')
%Amplitude versus period toc
 Table A5. Script that accepts as inputs the massless inextensible length L of the string, mass
m of the bob, and initial angular displacement θ0 and returns a plot of the variation of the
potential energy and kinetic energy during the first half-cycle.

%Pendulum oscillation #3 (energy curves) for r = 1:length(theta1)

clear, clc h(r) = L-L*cosd(theta1(r));
format short v(r) = sqrt(2*g*(h(1)-h(r)));
disp(datestr(now,0)) Ep(r) = m*g*h(r);
L=input('Enter the length (m) of the pendulum = '); Ek(r) = (1/2)*m*(v(r).^2);
m=input('Enter the mass (kg) of the bob = '); %theta Et(r) = Ep(r)+Ek(r);
is the angle between the pendulum and %the end
equilibrium line
theta=input('Enter the angular displacement (deg) = '); %Position, velocity and energy values
tic hmax = max(h);
vmax = max(v);
%Compute h, v, Ep, Ek and Et for theta Epmax = max(Ep);
%theta is the angle between the pendulum and the Ekmax = max(Ek);
%equilibrium line on the pivot point (or fixed point) table = [hmax;vmax;Epmax;Ekmax];
%h(1) is the inital height from which the bob is released. disp('Maximum values obtained during the oscillation of
pendulum:');
%For the position of theta, h(1) = L - L.cosd(theta) %i.e., If disp(' Height(m) Velocity (m/s) E_pot (J) E_kin(J)');
theta = 0 deg, it means that the bob is on the %equilibrium fprintf('%13.4f %12.4f %14.4f %10.4f n',table);
line and therefore h-initial will equal to zero. %So that the
potential energy will also equal to zero. %Plotting of energy curves on the same graph
plot(theta1,Ep,'-b','Linewidth',2)
%Symmetrical oscillation hold on
%theta1 includes the range of angles during the oscillation plot(theta1,Ek,'-r','Linewidth',2)
%i.e., for an angular displacement of theta = 40 deg, plot(theta1,Et,'-k','Linewidth',3)
%range of the oscillation can be considered between %-40
and 40 deg %Graphical details (legend, labels, titles, box and grid)
%i.e., -40 -39 -38 ... equilibrium line (0) 1 2 3 ... 40 legend('Potential energy (Joule)','Kinetic energy
%Increment rate is considered as 1 degree. (Joule)'... ,'Total energy (Joule)','Location','Best')
xlabel(' theta (deg)','FontSize',12)
%At the initial height of h(1), Epmax = m.g.h(1) = Et ylabel('Energy (Joule)','FontSize',12)
and Ek = 0
%For any h, Et = Ep + Ek title('Potential Energy - Kinetic Energy - Total
Energy','FontSize',12)
%m.g.h(1) = m.g.h + (1/2).m.(v^2) and box on
%v = (2.g.(h(1)-h))^0.5 or v = sqrt(2.g.(h(1)-h)) grid on
set(gca,'FontSize',12,'FontWeight','Bold')
g = 9.807; %Gravitational acceleration (m/s2)) set(findall(gcf,'type','text'),'FontSize',12,'FontWeight','Bold')
theta1 = [-theta:1:0 1:1:theta]; toc