Laporan Praktikum

Algoritma dan Pemrograman

AP - 11
PROYEK

Nama : M. Lahia, Alvitto, Hanafi

NPM : 14, 35, 42
Hari/Tanggal : Rabu, 23 Desember 2020
Waktu : 13.30-15.00
Asisten : David

LABORATORIUM KOMPUTASI
DEPARTEMEN FISIKA
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
UNIVERSITAS PADJADJARAN
2020
II. Latar Belakang
Sebagai seorang calon ilmuwan atau calon fisikawan di masa yang akan
datang, dimana sudah bisa diterawang bahwa masa depan akan identik dengan
kemajuan teknologi yang sangat pesat, apalagi di bidang komputerisasi, maka
sepatutnya seorang calon ilmuwan ini mendalami ilmu mengenai komputerisasi
dan juga yang paling penting adalah, penerapannya dalam konsep dan
penyelesaian kasus kasus fisika baik yang sederhana maupun yang sangat
kompleks.
Dengan hadirnya bahasa pemograman komputer, maka mudahlah bagi
seorang calon ilmuwan untuk mempelajari dan kedepannya yaitu untuk
mengaplikasikan bidang keilmuan fisikanya dalam sebuah hasil temuan fisika
yaitu sistem komputer. Dengan perkembangan jaman yang ada, makin
berkembanglah juga sistem komputer sehingga pengaplikasian dari konsep serta
model fisika dapat dilakukan lewat komputer dapat berkembang ke hal yang
lebih kompleks
Pada proyek ini kami akan mencoba untuk mengaplikasikan suatu konsep
fisika yang sangat dasar dan juga sederhana, namun tidak bisa dipungkiri bahwa
konsep ini merupakan dasar dari seluruh konsep yang ada di fisika, yaitu konsep
mekanika. Kita ketahui bahwa mekanika dibagi menjadi dua, yaitu Dinamika
dan juga kinematika, pada kesempatan kali ini kami akan mengaplikasikan
konsep kinematika, yaitu yang berlaku pada sistem bidang datar satu dimensi,
yaitu gerak lurus beraturan dan juga gerak lurus berubah beraturan. Penerapan
konsep fisika ini ke dalam program yang digunakan yaitu python, adalah berupa
kalkulator untuk menghitung seluruh aspek yang dapat ditemukan dari konsep
kinematika antara lain kecepatan, percepatan, posisi, jarak, serta waktu tempuh
dengan menggunakan beberapa operasi matematika sederhana dan menengah
yang dijalankan juga melewati program python sehingga hasil yang diperoleh
dari kalkulator ini dengan bantuan sistem komputer dapat menemukan hasil dari
suatu masalah dengan akurat.
III. Tujuan
Adapun tujuan dari perancangan proyek aplikasi konsep fisika dalam
program python antara lain:
A. Mampu untuk mengaplikasikan semua modul yang telah dipelajari
sebelumnya ke dalam program python yang terintegrasi
B. Mampu untuk menyusun sebuah program python yang dapat
menyelesaikan masalah dari sebuah konsep fisika.

IV. Fenomena Fisika

III.1 Gerak
Dalam mekanika klasik kita dapat menjelaskan gerak dengan cara mengabaikan
penyebab atau yang membuat benda bergerak, dalam mekanika cara tersebut
disebut kinematika. Untuk dapat menjelaskan gerak maka diperlukan besaran-
besaran yang bekerja pada gerak tersebut sehingga dengan adanya besaran
tersebut suatu gerak dapat dideskripsikan seperti berapa kecepatannya, arah
geraknya hingga letaknya pada saat tertentu, dengan besaran-besaran pula kita
dapat menentukan kondisi benda tersebut di waktu selanjutnya.
Dalam fisika kita mengkategorikan jenis gerak menjadi tiga yaitu gerak translasi,
gerak rotasi, dan gerak getaran. Pada proyek ini kami mengkhususkan penjelasan
tentang gerak translasi. Gerak translasi merupakan gerak yang terjadi pada
bidang datar contohnya seperti kendaraan yang sedang bergerak di jalan. Dalam
proyek ini kami mensimulasikan gerak translasi pada ruang 1 dimensi yang
sederhana serta dalam gerak translasi suatu benda yang bergerak kita sebut
sebagai partikel dimana partikel ini dilambangkan sebagai titik, titik ini yang
akan menggantikan bentuk benda karena saat benda bergerak kita asumsikan
seluruh bagian dari benda tersebut memiliki kecepatan yang sama sehingga
tanpa mempedulikan ukuran dan bentuk benda tersebut dijadikan sebuah titik
yang menandakan letak benda.

III.2 Posisi
Dalam menjelaskan suatu gerak benda kita membutuhkan sumbu koordinat.
Dalam proyek ini karena kami menjelaskan gerak pada ruang 1 dimensi maka
yang digunakan adalah sumbu x saja pada koordinat.
Saat melokasikan suatu objek berarti mencari tahu posisinya relatif terhadap
suatu titik rujukan dalam artian kita harus menentukan posisi awalnya.
Umumnya posisi awal dideskripsikan sebagai titik asal yang ditandai angka 0
atau origin dari suatu sumbu.

Dari gambar tersebut dapat diketahui bahwa benda menempuh jarak sebesar 80
meter sedangkan benda hanya berpindah 20 meter sehingga untuk menentukan
perpindahan dapat diketahui dari :
∆𝑥 = 𝑥1 − 𝑥0
Dimana kita ketahui bahwa benda bergerak 50 meter ke kanan dan posisi akhir
benda bergerak ke kiri 30 meter sehingga perpindahan benda adalah 20 meter ke
kanan sedangkan jarak total yang ditempuh benda adalah 80 meter.
Jarak tentunya merupakan besaran skalar karena hanya memberikan nilai
sedangkan perpindahan adalah besaran skalar karena selain nilai juga memiliki
arah.

III.3 Kecepatan Rata-Rata dan Laju Rata-Rata

Untuk menjelaskan seberapa cepat suatu benda bergerak maka dalam fisika kita
menggunakan istilah kecepatan, dimana kecepatan adalah besarnya perpindahan
dibagi waktu tempuh atau :
∆𝑥
𝑣̅ =
∆𝑡
Persamaan tersebut merupakan persamaan untuk mencari kecepatan rata-rata
(𝑣̅ ). Dimana Δx merupakan perpindahan, sehingga kecepatan merupakan
besaran turunan vektor yang menunjukan perpindahan terhadap waktu,
sementara kelajuan rata-rata menunjukan gerak benda sebagai jarak tempuh
terhadap waktu sehingga kelajuan merupakan besaran skalar yang didefinisikan
:
𝑑
𝑠̅ =
∆𝑡

Cara yang biasa dipakai untuk melihat peribahan posisi terhadap waktu adalah
menggunakan grafik seperti yang kita lihat dari persamaan tersebut yang
menyerupai cara untuk menentukan gradien dari garis lurus, sehingga kita dapat
menunjukan seberapa cepat benda bergerak terhadap waktu dengan :

Sehingga dapat kita ketahui bahwa kecepatan rata-rata benda (𝑣̅ ) merupakan
gradien dari garis lurus tersebut yang artinya semakin besar sudut (α) yang
dibentuk maka benda semakin bergerak cepat.

III.4 Kecepatan Sesaat

Kita dapat menggunaikan kecepatan rata-rata atau kelajuan rata-rata untuk
mengetahui seberapa cepat benda bergerak. Namun “seberapa cepat” lebih
umum merujuk kepada seberapa cepat benda pada suatu interval waktu sesaat
sehingga kita membutuhkan kecepatan sesaat. Kecepatan sesaat didapat dari
memperkecil interval waktu Δt mendekati 0 sehingga dapat kita gunakan limit
dalam matematika untuk mencari kecepatan rata-rata :
∆𝑥 𝑑𝑥
𝑣 = lim =
∆𝑡→0 ∆𝑡 𝑑𝑡
Persamaan tersebut dapat menunjukan pula turunan dari sebuah fungsi atau garis
singgung. Kecepatan sesaat tidak memiliki arah.
III.5 Percepatan
Kita tahu bahwa ketika kecepatan dari partikel berubah ketika partikelnya
bergerak atau saa posisinya bergerak terhadap waktu. Ketika kecepatan dari
partikel bertambah maka terjadi percepatan. Kita dapat mendeskripsikan
perubahan kecepatan terhadap waktu sebagai percepatan rata-rata saat
perubahannya konstan artinya percepatan dapat dijelaskan sebagai :
∆𝑣
𝑎̅ =
∆𝑡
Sehingga grafiknya akan menjadi :

Dari grafik tersebut dapat diketahui pada detik keempat kecepatan telah
bertambah menjadi 20 m/s.
Dalam situasi lain terkadang jumlah dari percepatan rata-rata berbeda dari
interval waktu, karena itu digunakan percepatan sesaat sebagai limi dari
percepatan rata-rata saat Δt mendekati 0 :
𝑑𝑣
𝑎=
𝑑𝑡
Dengan kata lain, percepatan sebuah partikel pada suatu saat adalah tingkat di
mana kecepatabbya berubah pada saat itu. Secara grafis, percepatan pada suatu
titik adalah kemiringan kurva v(t) pada titik tersebut.

III.6 GLB dan GLBB

Gerak lurus dapat dibedakan menjadi dua jenis berdasarkan percepatannya.
Pada Gerak Lurus Beraturan (GLB) kecepatan benda konstan sehingga benda
tidak dipercepat (𝑎 = ∆𝑣1 − ∆𝑣0 = 0) kecepatan benda tersebut tidak berubah
sepanjang waktu tempuh benda, maka bila kecepatan digrafikan :

Berdasarkan grafik, benda berpindah terhadap waktu tetapi pada grafik (a)
garis tidak memiliki gradien sehingga hanya terbentuk garis lurus yang
menandakan kecepatan yang konstan.
0
𝑎̅ = =0
∆𝑡
sebab itulah benda bergerak secara beraturan.

Pada Gerak Lurus Berubah Beraturan (GLBB), benda dipercepat atau

kecepatan bertambah secara beraturan sehingga 𝑎 ≠ 0. Pada gerak ini benda
memiliki percepatan yang konstan, sehingga persamaan percepatan rata-rata
berlaku bagi gerak ini karena memiliki kecepatan awal dan akhir (∆𝑣1 − ∆𝑣0 ≠
0) dengan begitu bentuk grafik dari gerak ini :

Terlihat bahwa perpindahan benda memiliki grafik yang berbeda dari GLB
dimana pada grafik ini perpindahan memiliki grafik yang melengkung yang
diakibatkan dari kecepatan yang bertambah sehingga semakin waktu
bertambah maka perpindahan semakin bertambah, sementara itu pada grafik
percepatan memiliki garis yang datar akibat dari percepatan yang konstan
namun mengakibatkan grafik kecepatan memiliki gradien.
Dengan menurunkan persamaan-persamaan sebelumnya, pada Gerak Lurus
Berubah Beraturan didapatkan persamaan-persamaan :
Persamaan Kuantitas yang Hilang
𝑣 = 𝑣0 + 𝑎𝑡 ∆𝑥
1 𝑣
𝑥 − 𝑥0 = 𝑣0 𝑡 + 𝑎𝑡 2
2
𝑣 2 = 𝑣0 2 + 2𝑎∆𝑥 𝑡
1 𝑎
𝑥 − 𝑥0 = 𝑣0 𝑡 + (𝑣0 + 𝑣)𝑡
2
1 𝑣0
𝑥 − 𝑥0 = 𝑣𝑡 − 𝑎𝑡 2
2

IV. Deskripsi Proyek

Proyek kami ini merupakan program kalkulator fisika untuk fenomena

kinematika satu dimensi yaitu gerak lurus pada bidang datar. Dalam
pembuatannya, kami membuat kalkulator ini agar sistematis, efektif dan efisien
untuk dapat menyelesaikan persoalan kasus gerak lurus di bidang datar, dan
tentunya mudah digunakan oleh siapapun dengan memanfaatkan materi-materi
dari modul-modul yang telah diajarkan. Gerak lurus yang dimaksud ialah Gerak
Lurus Beraturan (GLB) dan Gerak Lurus Berubah Beraturan (GLBB).

Ketika program dijalankan nantinya user akan langsung berada dalam main
menu (menu utama) yang di dalamnya disajikan tiga pilihan menu yang dapat
dipilih sesuai keinginan user dengan menginputkan nomor menu yang ingin
dipilih. Ketiga menu tersebut antara lain :

1. Kasus GLB
2. Kasus GLBB
3. Exit Program
User akan diminta untuk menginput pilihannya begitu pemaparan menu selesai
disajikan. Kemudian setelah user menginput pilihannya, maka program akan
bekerja untuk mendeteksi menu berapa yang dipilih user menggunakan fungsi
pengkondisian yaitu if. Untuk pilihan 1, kasus GLB maka di dalamnya user
akan kembali diminta untuk menginputkan pilihannya karena tersedia empat
pilihan di dalamnya, tiga pilihan di antaranya adalah untuk mencari nilai
kecepatan benda (v), jarak tempuh benda (s), dan waktu tempuh benda (t).
Sedangkan satu pilihan lagi ialah pilihan “0: back to main menu”, untuk kembali
ke menu utama yaitu menu sebelumnya.

Sama halnya apabila user memilih pilihan nomor 2, kasus GLBB maka di
dalamnya user juga akan diminta untuk menginput pilihan yang ada di dalam
menu kasus GLBB. Menu yang ada di antaranya yaitu untuk mencari nilai
perpindahan, kecepatan, percepatan, dan menu yang terakhir adalah pilihan
untuk kembali ke menu utama. Dimana untuk pilihan kecepatan dan percepatan
masing-masing di dalamnya, user akan diminta untuk memilih kembali menu
mencari nilai kecepatan akhir, nilai kecepatan rata-rata, dan nilai kecepatan
sesaat. Dan untuk menu percepatan akan tersedia menu untuk mencari nilai
percepatan rata-rata dan nilai percepatan sesaat.

Untuk mekanisme programnya sendiri, ketika user telah memilih sampai ke

besaran apa yang akan dicari maka disitu user akan diminta untuk
menginputkan besaran yang telah diketahui, untuk mendapatkan hasil
perhitungan besaran yang dicari. Contohnya apabila user memilih mencari nilai
besaran kecepatan dalam kasus GLB, maka user akan diminta untuk menginput
nilai perpindahan (∆𝑥) dan waktu tempuh (𝑡) yang diketahui di soal. Hasil dari
mencari nilai suatu besaran tertentu bukan hanya berupa nilai nya saja yang
ditampilka tetapi juga akan program akan menampilkan grafik sesuai dengan
besaran yang dicari. Setelah user mendapatkan nilai besaran yang dicari dalam
contoh sebelumnya mencari nilai kecepatan pada kasus GLB, maka program
akan otomatis kembali ke dalam menu kasus GLB, sehingga setelah selesai
mencari nilai suatu besaran program tidak akan tertutup/ diakhiri dengan
sendirinya.

Kami membuat agar program tidak tertutup atau selesai dengan sendirinya
begitu program selesai menjalankan perintah dari user. Namun, kami membuat
agar program otomatis kembali ke menu kasus yang telah dipilih (GLB atau
GLBB). Tujuannya adalah agar ketika user telah selesai mencari satu besaran
tertentu, kemudian ingin mencari besaran lainnya, user tidak perlu repot-repot
untuk start ulang program, yang mana menurut kami hal itu cukup merepotkan.
Selain itu, kami akan membuat satu-satunya cara untuk menghentikan atau
keluar dari program ini dengan memilih menu nomor 3: Exit, pada menu utama
program. Untuk membuat program bisa berjalan sesuai dengan rencana kami
tersebut, maka kami akan menggunakan fungsi rekursi dalam listing program.
V. Flowchart
START

Masukkan Pilihan Kasus :

1: Kasus GLB
2: Kasus GLBB
3: Exit

OUTPUT : T
kasus yang 3 : Exit
dipilih (1/2)

Y
INPUT :
pilih perhitungan
besaran yang
tertera pada menu
kasus yang telah
dipilih

OUTPUT :
T Perhitungan
0: Main Menu
besaran yang
dipilih

Y
INPUT :
s, t, vawal, a, persamaan
v, persamaan r
(masukkan sesuai
besaran yang ingin
dicari)

PROSES :
Hitung rumus

OUTPUT
hasiil

END
 VI. Program

VI.1 Listing

get_ipython().run_line_magic('matplotlib', 'notebook')
import matplotlib.pyplot as plt
import numpy as np
from sympy import *

def utama():
print('\n------------Main Menu------------')
print('1: Kasus GLB\n2: Kasus GLBB\n3: Exit')
pil = int(input('Masukkan Pilihan Anda : '))
if (pil == 1):
print('\n-----Anda memilih kasus GLB------
\nVariabel apa yang ingin anda cari')
return(menu1())
elif (pil == 2):
print('\n-----Anda memilih kasus GLBB-----
\nVariabel apa yang ingin anda cari')
return(menu2())
elif (pil == 3):
return('\n...Keluar Dari Program...\n')
else:
return('\nInput Yang Anda Masukkan Tidak Sesuai\n\n........S
ilahkan Ulangi Lagi........')

def menu1():
print('1: Kecepatan\n2: Perpindahan\n3: Waktu Tempuh\n0: Kembali
ke Menu Utama')
return(glb())

def menu2():
print('1: Kecepatan Awal\n2: Kecepatan Akhir\n3: Kec.Awal Jika D
iketahui Perpindahan\n4: Kec.Akhir Jika Diketahui Perpindahan\n5: Pe
rpindahan\n6: Percepatan\n7: Percepatan Jika Diketahui Perpindahan d
an Kecepatan Akhir\n8: Percepatan Jika Diketahui Perpindahan Saja\n9
: Waktu Tempuh Jika diketahui Perpindahan\n10: Waktu Tempuh Jika dik
etahui Percepatan\n11: Kecepatan Sesaat\n12: Percepatan Sesaat\n0: K
embali Ke Menu')
return(glbb())

def glb():
glb = int(input('Masukkan Pilihan Anda : '))
 def grafik_glb(i,j,k):

x = np.linspace(0,int(i),int(i+1))
y = np.linspace(0,int(j),int(i+1))

plt.title('Kecepatan %f m/s' % k)
plt.xlabel('Waktu (s)')
plt.ylabel('Perpindahan (m)')
plt.legend('v')
plt.grid(True, which='both')
plt.plot(x,y)
plt.show()

def grafik_kh1(n,i,j,k):
if n == 0:
return grafik_glb(i,j,k)
else:
return menu1()

if glb == 1:
print('\n------------Kecepatan------------')
s = float(input('perpindahan yang diketahui (m) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
v = s/t
print('Besarnya kecepatan : %.2f m/s\n\n------------
Kasus GLB------------'%v)

i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :

(0/1)"))
return grafik_kh1(i,t,s,v)

elif glb == 2:
print('\n-----------Perpindahan-----------')
v = float(input('masukkan nilai kecepatan (m/s) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
s = v*t
print('Besarnya perpindahan : %.2f m\n\n------------
Kasus GLB------------'%s)

i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :

(0/1)"))
return grafik_kh1(i,t,s,v)
elif glb == 3:
print('\n----------Waktu Tempuh-----------')
 v = float(input('kecepatan yang diketahui (m/s) : '))
s = float(input('perpindahan yang diketahui (m) : '))
t = s/v
print('Waktu tempuh yang diperlukan : %.2f s\n\n------------
Kasus GLB------------'%t)

i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :

(0/1)"))
return grafik_kh1(i,t,s,v)
elif glb == 0 :
return(utama())
else:
return('\nInput Yang Anda Masukkan Tidak Sesuai\n\n........S
ilahkan Ulangi Lagi........')
print('\n------------Kasus GLB------------')
return menu1()

def glbb():
glbb = int(input('Masukkan Pilihan Anda : '))

def grafik_kecepatan(t,v0,vt,a):

x = np.linspace(0,int(t),int(t+1))
y = np.linspace(int(v0),int(vt),int(t+1))

plt.title('Percepatan %f m/s^2' % a)
plt.xlabel('Waktu (s)')
plt.ylabel('Kecepatan (m/s)')
plt.legend('v')
plt.grid(True, which='both')
plt.plot(x,y)
plt.show()

def grafik_kh2(n,i,j,k,l):
if n == 0:
return grafik_kecepatan(i,j,k,l)
else:
return menu2()

if glbb == 1:
print('\n------------Kecepatan Awal------------')
a = float(input('percepatan yang diketahui (m/s^2) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
 vt = float(input('Kecepatan Akhir yang diketahui (m/s) : \n'
))
print('\n')
v0 = vt - (a*t)
print('Besarnya kecepatan Awal : %.2f m/s\n\n------------
Kasus GLBB------------'%v0)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 2:
print('\n-----------Kecepatan Akhir-----------')
a = float(input('percepatan yang diketahui (m/s^2) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
v0 = float(input('Kecepatan Awal yang diketahui (m/s) : \n')
)
print('\n')
vt = v0 + (a*t)
print('Besarnya kecepatan Akhir : %.2f m/s\n\n------------
Kasus GLBB------------'%vt)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 3:
print('\n----------Kec.Awal Jika Diketahui Perpindahan------
-----')
a = float(input('percepatan yang diketahui (m/s^2) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
vt = float(input('Kecepatan Akhir yang diketahui (m/s) : '))
s = float(input('perpindahan yang diketahui (m) : \n'))
print('\n')
v0 = (vt - (2*a*s) )**1/2
print('Besarnya Kecepatan Awal : %.2f m/s\n\n------------
Kasus GLBB------------'%v0)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 4:
print('\n----------Kec.Akhir Jika Diketahui Perpindahan-----
------')
a = float(input('percepatan yang diketahui (m/s^2) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
v0 = float(input('Kecepatan Awal yang diketahui (m/s) : '))
 s = float(input('perpindahan yang diketahui (m) : \n'))
print('\n')
vt = (v0 + (2*a*s) )**1/2
print('Besarnya kecepatan Akhir : %.2f m/s\n\n------------
Kasus GLBB------------'%vt)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 5:
print('\n----------Perpindahan-----------')
a = float(input('percepatan yang diketahui (m/s^2) : '))
t = float(input('waktu tempuh yang diketahui (s) : '))
v0 = float(input('Kecepatan Awal yang diketahui (m/s) : \n')
)
print('\n')
s = (v0*t) + ((1/2)*a*(t**2))
vt = (v0 + (2*a*s) )**1/2
print('Besarnya Perpindahan : %.2f m\n\n------------
Kasus GLB------------'%s)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 6:
print('\n----------Percepatan-----------')
t = float(input('waktu tempuh yang diketahui (s) : '))
v0 = float(input('Kecepatan Awal yang diketahui (m/s) : '))
vt = float(input('Kecepatan Akhir yang diketahui (m/s) : '))
print('\n')
a = (vt-v0)/t
print('Besarnya Percepatan : %.2f m/s^2\n\n------------
Kasus GLBB------------'%a)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 7:
print('\n---------
- Percepatan Jika Diketahui Perpindahan dan Kecepatan Akhir---------
--')
v0 = float(input('Kecepatan Awal yang diketahui (m/s) : '))
vt = float(input('Kecepatan Akhir yang diketahui (m/s) : '))
s = float(input('Perpindahan yang diketahui (m) : '))
print('\n')
 a = ((vt**2)-(v0**2))/(2*s)
t = (2*s)/(vt-v0)
print('Besarnya Percepatan : %.2f m/s^2\n\n------------
Kasus GLBB------------'%a)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 8:
print('\n---------
- Percepatan Jika Diketahui Perpindahan Saja-----------')
t = float(input('Waktu Tempuh yang Diketahui(s) : '))
v0 = float(input('Kecepatan Awal yang diketahui (m/s) : '))
s = float(input('Perpindahan yang diketahui (m) : '))
print('\n')
a = ((2*s) - (2*v0))/t
vt = (v0 + (2*a*s) )**1/2
print('Besarnya Percepatan : %.2f m/s^2\n\n------------
Kasus GLBB------------'%a)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 9:
print('\n----------Waktu Tempuh Jika diketahui Perpindahan--
---------')
v0 = float(input('kecepatan awal yang diketahui (m/s) : '))
vt = float(input('kecepatan akhir yang diketahui (m/s) : '))
s = float(input('perpindahan yang diketahui (m) : '))
print('\n')
t = (2*s)/(vt-v0)
print('Waktu tempuh yang diperlukan : %.2f s\n\n------------
Kasus GLBB------------'%t)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 10:

print('\n----------Waktu Tempuh Jika diketahui Percepatan---
--------')
v0 = float(input('kecepatan awal yang diketahui (m/s) : '))
vt = float(input('kecepatan akhir yang diketahui (m/s) : '))
a = float(input('perpindahan yang diketahui (m/s^2) : '))
print('\n')
t = (vt-v0)/a
 print('Waktu tempuh yang diperlukan : %.2f s\n\n------------
Kasus GLBB------------'%t)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) :
(0/1)"))
return grafik_kh2(i,t,v0,vt,a)

elif glbb == 11:

t = symbols('t')
print('\n----------Kecepatan Sesaat-----------')
r = (input('Masukkan Persamaan Vektor Posisi yang diketahui
(dlm variabel t) : '))
t1 = float(input('waktu kecepatan sesaat saat t (s) = '))
v = diff(r,t)
v1 = limit(v,t,t1)
print('Kecepatan Sesaatnya adalah = %s m/s'%v1)
print('\n\n------------Kasus GLBB------------')
return (menu2())
elif glbb == 12:
t = symbols('t')
print('\n----------Percepatan Sesaat-----------')
v = (input('Masukkan Persamaan Vektor Kecepatan yang diketah
ui (dlm variabel t) : '))
t1 = float(input('waktu percepatan sesaat saat t (s) = '))
a = diff(v,t)
a1 = limit(a,t,t1)
print('Percepatan Sesaatnya adalah = %s m/s^2'%a1)
print('\n\n------------Kasus GLBB------------')
return (menu2())
elif glbb == 0:
return(utama())
else:
return('\nInput Yang Anda Masukkan Tidak Sesuai\n\n........S
ilahkan Ulangi Lagi........')
print('\n------------Kasus GLB------------')
return menu2()

print('----------Selamat Datang---------')
print('------Kalkulator GLB & GLBB------')
print(utama())
VI.2 Tampilan

Gambar 6.1 Tampilan Awal Program Setelah Dijalankan.

Gambar 6.2 Menu Kasus GLB. Gambar 6.3 Menu Kasus GLBB.

Gambar 6.4 Tampilan Menu Gambar 6.5 Tampilan Jika Input

Exit Program. User Salah.
Gambar 6.6 Contoh Tampilan Hasil Perhitungan.

Gambar 6.7 Contoh Tampilan Grafik Dari Hasil

Perhitungan.
 VI.3 Analisa Program

Secara garis besar terdapat beberapa fungsi def untuk mempermudah program
aplikasi kami agar dapat berjalan dengan baik, diantaranya yaitu:

1. Def utama() adalah sebagai fungsi def untuk main menu program,
didalamnya terdapat tiga pilihan (kasus glb, kasus glbb, exit program).
2. Def menu1() adalah sebagai fungsi def untuk menampilkan list menu
pilihan pada kasus glb, didalamnya terdapat empat list pilihan besaran yang
dapat dicari untuk kasus glb (kecepatan, perpindahan, waktu tempuh, dan
pilihan untuk kembali ke main menu program).
3. Def glb() adalah sebagai fungsi def kasus glb untuk pengkondisian dari
pilihan menu besaran yang telah diinputkan sebelumnya, yang kemudian
akan diproses perhitungannya sesuai dengan nilai besaran apa yang ingin
dicari.
4. Def menu2() adalah sebagai fungsi def untuk list menu pilihan pada kasus
glbb, didalamnya terdapat empat list pilihan besaran yang dapat dicari pada
kasus glbb (kecepatan, perpindahan, percepatan, dan pilihan untuk kembali
ke main menu program).
5. Def glbb() adalah sebagai fungsi def kasus glbb untuk pengkondisian dari
pilihan menu yang telah diinputkan sebelumnya, yang kemudian akan
diproses perhitungannya sesuai dengan nilai besaran apa yang ingin dicari.

Pada program ini kami menggunakan 3 library yaitu matplotlib untuk membuat
grafik, numpy untuk pembuatan array yang akan diplotkan, sympy juga untuk
mengolah variabel-variabel pada kasus kecepatan sesaat :

import matplotlib.pyplot as plt

import numpy as np

from sympy import *

Pada library matplotlib modul yang digunakan adalah .pyplot untuk membuat grafik
baik GLB maupun GLB :
 Gambar 7.1 Tampilan Grafik GLB Gambar 7.2 Tampilan Grafik GLBB

Untuk membuat array sebagai data pada kedua sumbu maka digunakan perintah
.linspace() pada library numpy yang juga akan menjadikan kedua array tersebut
memiliki jumlah yang sama sehingga membentuk data berupa fungsi dan dapat
diplotkan.

Sementara itu library sympy akan digunakan untuk menyelesaikan kasus kecepatan
sesaat pada GLBB yang membutuhkan operasi turunan dan limit.

Fungsi di baris pertama ialah terdapat fungsi import matplotlib.pyplot as plt yang
berfungsi untuk membuka/memanggil library matplotlib agar dapat digunakan
dalam proses listingan, dengan menyingkat penamaannya sebagai plt menggunakan
fungsi as.

Baris berikutnya terdapat fungsi untuk membuka/memanggil library numpy

menggunakan perintah import, agar library tersebut dapat digunakan dalam proses
listing program.

• Fungsi def utama() seperti yang telah dijelaskan diawal tadi, dengan di
dalamnya terdapat listing berupa :
Fungsi print('\n------------Main Menu------------') yang akan menampilkan string
yang berada pada parameter fungsi print tersebut, sekaligus penanda bahwa
program sedang berada di bagian main menu.

Fungsi print('1: Kasus GLB\n2: Kasus GLBB\n3: Exit') untuk menampilkan list
pilihan menu apa saja yang tersedia di main menu.

Terdapat inisiasi variabel pil yang memberikan kesempatan kepada user untuk
menginputkan pilihannnya. Agar user dapat menginput pilihannya maka digunakan
fungsi input int(input('Masukkan Pilihan Anda : ')).

Fungsi pengkondisian if digunakan untuk megidentifikasi pilihan yang diinput oleh

user. Apabila user memilih pilihan nomor 1 (GLB), maka akan terdapat fungsi
print('\n-----Anda memilih kasus GLB------\nVariabel apa yang ingin anda cari')
dan kemudian diberikan perintah return terhadap def fungsi menu1(). Apabila user
memilih nomor pilihan nomor 2 (GLBB), maka akan terdapat fungsi print('\n-----
Anda memilih kasus GLBB-----\nVariabel apa yang ingin anda cari') dan
kemudian diberikan perintah return terhadap fungsi def menu2(). Apabila user
memilih pilihan nomor 3 (Exit Program), maka akan terdapat perintah
return('\n...Keluar Dari Program...\n'), dan program akan dihentikan. Namun, jika
user menginputkan selain ketiga pilihan diatas, maka program akan memberikan
peringatan bahwa input yang diberikan tidak sesuai dengan fungsi return('\nInput
Yang Anda Masukkan Tidak Sesuai\n\n......Silahkan Ulangi Lagi......').

• Fungsi def menu1() seperti yang telah dijelaskan diawal tadi, dengan di
dalamnya terdapat listing berupa :

Fungsi print('1: Kecepatan\n2: Perpindahan\n3: Waktu Tempuh\n0: Kembali ke

Menu Utama'), yang berfungsi untuk menampilkan list pilihan yang tersedia pada
kasus GLB.

Fungsi return(glb()) yang berfungsi sebagai pemanggilan fungsi glb() tersebut agar
dapat dijalankan.
 • Fungsi def glb() seperti yang telah dijelaskan diawal tadi, dengan di
dalamnya terdapat listing berupa :

Inisiasi variabel glb sebagai parameter input pilihan yang dimasukkan user dengan
fungsi glb = int(input('Masukkan Pilihan Anda : ')).

Pada setiap operasi penyelesaian kasus gerak lurus beraturan (GLB), grafik muncul
saat program berhenti sehingga user diberi pilihan untuk menampilkan grafik atau
melanjutkan program. Pengguna diminta memasukkan nilai i antara 0 atau 1
kemudian nilainya dimasukan ke variabel i pada pemanggilan fungsi menggunakan
return, begitu pula dengan variabel t, s, dan v yang sebelumnya telah diolah
dimasukan ke argumen fungsi tersebut :
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) : (0/1)"))
return grafik_kh1(i,t,s,v)
Setelah program membukan fungsi grafik_kh1() dengan membawa variabel-
variabel program akan membandingkan i yang telah menjadi n dengan 0, jika n
bernilai 0 maka program akan memanggil fungsi grafik_glb() jika selain dari 0
(else:) program akan mengembalikan pengguna ke fungsi menu1(), program
menggunakan variabel n (i) menjadi konstanta 0 sehingga variabel yang tersisa
adalah i, j, dan k kemudian dibawa menuju fungsi grafik_glb(i,j,k) :
def grafik_kh1(n,i,j,k):
if n == 0:
return grafik_glb(i,j,k)
else:
return menu1()
Setelah fungsi grafik_glb() terpanggil bersama ketiga variabel, fungsi memplotkan
variabel t dan s di mana masing-masing diplotkan ke sumbu x dan y melalui
grafik_kh1(i,t,s,v) kemudian masuk ke fungsi grafik_glb(i,j,k) sehingga t = i dan s
= j dengan v menjadi k. Kemudian di fungsi grafik tersebut dibentuk array dengan
.linspace() di mana 0 sebagai batas awal dan i (t) sebagai batas akhir untuk sumbu
x dan j (s) sebagai batas akhir untuk sumbu y, kemudian kedua array tersebut harus
berjumlah i+1 agar dapat membentuk fungsi sehingga dapat diplotkan ke grafik.
Seluruh variabel harus dalam bentuk integer dengan int() karena .linspace() tidak
dapat membentuk array dengan tipe data float :
def grafik_glb(i,j,k):

x = np.linspace(0,int(i),int(i+1))
y = np.linspace(0,int(j),int(i+1))

plt.title('Kecepatan %f m/s' % k)
plt.xlabel('Waktu (s)')
plt.ylabel('Perpindahan (m)')
plt.legend('v')
plt.grid(True, which='both')
plt.plot(x,y)
plt.show()

Pengkondisian if glb == 1 akan bekerja apabila user memasukkan pilihan nomor 1

(kecepatan).
Di dalam fungsi if glb == 1, terdapat fungsi pertamanya untuk menampilkan suatu
string di dalamnya yaitu :
print('\n------------Kecepatan------------'), yang berfungsi sebagai tampilan
sekaligus penanda bahwa user telah berada pada pilihan menu mencari besaran
kecepatan GLB.
Berikutnya terdapat inisiasi variabel s sebagai parameter input nilai perpindahan
yang diketahui di soal, dengan menggunakan perintah input,
s = float(input('perpindahan yang diketahui (m) : ')).
Dan fungsi float disini berfungsi agar nilai perpindahan yang dapat diinput oleh
user dapat berupa nilai pecahan/desimal.
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input,
t = float(input('waktu tempuh yang diketahui (s) : ')). Dan fungsi float disini
berfungsi agar nilai waktu tempuh yang dapat diinput oleh user dapat berupa nilai
pecahan/desimal.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran kecepatan yang
di-inisiasi dengan pemisalan variabel v = s/t.

Pada setiap operasi penyelesaian kasus gerak lurus beraturan (GLB), grafik muncul
saat program berhenti sehingga user diberi pilihan untuk menampilkan grafik atau
melanjutkan program. Pengguna diminta memasukkan nilai i antara 0 atau 1
kemudian nilainya dimasukan ke variabel i pada pemanggilan fungsi menggunakan
return, begitu pula dengan variabel t, s, dan v yang sebelumnya telah diolah
dimasukan ke argumen fungsi tersebut.
Setelah program membukan fungsi grafik_kh1() dengan membawa variabel-
variabel program akan membandingkan i yang telah menjadi n dengan 0, jika n
bernilai 0 maka program akan memanggil fungsi grafik_glb() jika selain dari 0
(else:) program akan mengembalikan pengguna ke fungsi menu1(), program
menggunakan variabel n (i) menjadi konstanta 0 sehingga variabel yang tersisa
adalah i, j, dan k kemudian dibawa menuju fungsi grafik_glb(i,j,k) dan grafik pun
akan ditampilkan atau muncul.
Berikutnya terdapat fungsi print('Besarnya kecepatan : %.2f m/s\n\n------------
Kasus GLB------------'%v), yang berfungsi untuk menampilkan hasil dari nilai
besaran kecepatan yang dicari. Serta akan menampilkan baris pertama dari tampilan
menu kasus GLB.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu1()), yang
berfungsi untuk memanggil fungsi menu1() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glb == 2 akan bekerja apabila user memasukkan pilihan nomor
2 (perpindahan).
Di dalam fungsi if glb == 2, terdapat fungsi yang pertama yaitu print('\n-----------
Perpindahan-----------'), sebagai tampilan sekaligus penanda bahwa user telah
berada pada pilihan menu mencari nilai besaran perpindahan GLB.
Berikutnya terdapat inisiasi variabel v sebagai parameter input nilai kecepatan yang
diketahui di soal, dengan menggunakan perintah input, v = float(input(' masukkan
nilai kecepatan (m/s) : ')). Dan fungsi float disini berfungsi agar nilai kecepatan
yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai waktu
tempuh yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran perpindahan yang
di-inisiasi dengan pemisalan variabel s=v*t.
Pada setiap operasi penyelesaian kasus gerak lurus beraturan (GLB), grafik muncul
saat program berhenti sehingga user diberi pilihan untuk menampilkan grafik atau
melanjutkan program. Pengguna diminta memasukkan nilai i antara 0 atau 1
kemudian nilainya dimasukan ke variabel i pada pemanggilan fungsi menggunakan
return, begitu pula dengan variabel t, s, dan v yang sebelumnya telah diolah
dimasukan ke argumen fungsi tersebut.
Setelah program membukan fungsi grafik_kh1() dengan membawa variabel-
variabel program akan membandingkan i yang telah menjadi n dengan 0, jika n
bernilai 0 maka program akan memanggil fungsi grafik_glb() jika selain dari 0
(else:) program akan mengembalikan pengguna ke fungsi menu1(), program
menggunakan variabel n (i) menjadi konstanta 0 sehingga variabel yang tersisa
adalah i, j, dan k kemudian dibawa menuju fungsi grafik_glb(i,j,k) dan grafik pun
akan ditampilkan atau muncul.
Berikutnya terdapat fungsi print('Besarnya perpindahan : %.2f m\n\n------------
Kasus GLB------------'%s), yang berfungsi untuk menampilkan hasil dari nilai
besaran perpindahan yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLB.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu1()), yang
berfungsi untuk memanggil fungsi menu1() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLB setelah program selesai menghitung
nilai besaran.
Pengkondisian elif glb == 3 akan bekerja apabila user memasukkan pilihan nomor
3 (waktu tempuh).
Di dalam fungsi if glb == 3, terdapat fungsi yang pertama yaitu print('\n----------
Waktu Tempuh-----------'), sebagai tampilan sekaligus penanda bahwa user telah
berada pada pilihan menu mencari nilai besaran waktu tempuh GLB.
Berikutnya terdapat inisiasi variabel v sebagai parameter input nilai kecepatan yang
diketahui di soal, dengan menggunakan perintah input, v = float(input(' masukkan
nilai kecepatan (m/s) : ')). Dan fungsi float disini berfungsi agar nilai kecepatan
yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Berikutnya terdapat inisiasi variabel s sebagai parameter input nilai perpindahan
yang dikethui di soal, dengan menggunakan perintah input, s =
float(input('perpindahan yang diketahui (m) : ')). Dan fungsi float disini berfungsi
agar nilai perpindahan yang dapat diinput oleh user dapat berupa nilai
pecahan/desimal.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran waktu tempuh
yang di-inisiasi dengan pemisalan variabel t=s/v.
Pada setiap operasi penyelesaian kasus gerak lurus beraturan (GLB), grafik muncul
saat program berhenti sehingga user diberi pilihan untuk menampilkan grafik atau
melanjutkan program. Pengguna diminta memasukkan nilai i antara 0 atau 1
kemudian nilainya dimasukan ke variabel i pada pemanggilan fungsi menggunakan
return, begitu pula dengan variabel t, s, dan v yang sebelumnya telah diolah
dimasukan ke argumen fungsi tersebut.
Setelah program membukan fungsi grafik_kh1() dengan membawa variabel-
variabel program akan membandingkan i yang telah menjadi n dengan 0, jika n
bernilai 0 maka program akan memanggil fungsi grafik_glb() jika selain dari 0
(else:) program akan mengembalikan pengguna ke fungsi menu1(), program
menggunakan variabel n (i) menjadi konstanta 0 sehingga variabel yang tersisa
adalah i, j, dan k kemudian dibawa menuju fungsi grafik_glb(i,j,k) dan grafik pun
akan ditampilkan atau muncul.
Berikutnya terdapat fungsi print('Waktu tempuh yang diperlukan : %.2f s\n\n----
--------Kasus GLB------------'%t), yang berfungsi untuk menampilkan hasil dari
nilai besaran waktu tempuh yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLB.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu1()), yang
berfungsi untuk memanggil fungsi menu1() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glb == 0 akan bekerja apabila user memasukkan pilihan nomor
0 (Kembali ke Main Menu).
Di dalam pengkondisian ini terdapat fungsi return(utama()) yang akan memanggil
fungsi utama() dimana fungsi tersebut merupakan tampilan menu utama dari
program, sehingga program akan berada kembali di main menu.

Pengkondisian else akan dapat bekerja apabila user menginputkan nomor menu
yang tidak tersedia pada pilihan.
Di dalam pengkondisian else, akan ditampilkan sebuah pesan bahwa input yang
dimasukkan user salah atau tidak sesuai dengan menggunakan fungsi
return('\nInput Yang Anda Masukkan Tidak Sesuai\n\n........Silahkan Ulangi
Lagi........').

• Fungsi def glbb ( ) seperti yang dijelaskan diawal tadi, dengan didalamnya
terdapat listing sebagai berikut :

Inisiasi variabel glbb sebagai parameter input pilihan yang dimasukkan user
dengan fungsi glbb = int(input('Masukkan Pilihan Anda : ')).

Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a :
i = int(input("Tampilkan grafik dan akhiri program? (Y/T) : (0/1)"))
return grafik_kh2(i,t,v0,vt,a)
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan() :
def grafik_kh2(n,i,j,k,l):
if n == 0:
return grafik_kecepatan(i,j,k,l)
else:
return menu2()
Saat program membuka fungsi grafik_kecepatan(), variabel i, j, k, dan l diubah
menjadi t, v0, vt, dan a. Waktu tempuh (t) selalu mengisi sumbu x maka pada
.linspace(), 0 menjadi batas awal sebagai waktu saat 0 dan t menjadi batas akhir
dengan jumlah nilai pada array t+1 yang sesuai dengan nilai t nantinya. Pada sumbu
y grafik GLBB, batas awal di linspace() adalah v0 dan batas akhir vt dengan jumlah
array-nya t+1 sehingga memiliki dimensi yang sama untuk diplotkan.
def grafik_kecepatan(t,v0,vt,a):

x = np.linspace(0,int(t),int(t+1))
y = np.linspace(int(v0),int(vt),int(t+1))

plt.title('Percepatan %f m/s^2' % a)
plt.xlabel('Waktu (s)')
plt.ylabel('Kecepatan (m/s)')
plt.legend('v')
plt.grid(True, which='both')
plt.plot(x,y)
plt.show()

Pengkondisian if glbb == 1 akan bekerja apabila user memasukkan pilihan nomor

1 (kecepatan awal).
Di dalam fungsi if glbb == 1, terdapat fungsi yang pertama yaitu fungsi :
print('\n------------Kecepatan Awal------------'), sebagai tampilan sekaligus
penanda bahwa user telah berada pada pilihan menu mencari besaran kecepatan
awal GLBB
Berikutnya terdapat inisiasi variabel a sebagai parameter input nilai percepatan
yang diketahui di soal, dengan menggunakan perintah input, a =
float(input('percepatan yang diketahui (m/s^2) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai yang
dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel vt sebagai parameter input nilai kecepatan
akhir yang dikethui di soal, dengan menggunakan perintah input, vt =
float(input('Kecepatan Akhir yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran kecepatan awal
yang di-inisiasi dengan pemisalan variabel v0 = vt – (a*t)
Berikutnya terdapat fungsi print('Besarnya kecepatan awal : %.2f m/s\n\n---------
---Kasus GLBB------------'%v0), yang berfungsi untuk menampilkan hasil dari nilai
besaran kecepatan awal yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glbb == 2 akan bekerja apabila user memasukkan pilihan nomor
2 (kecepatan akhir).
Di dalam fungsi if glbb == 2, terdapat fungsi yang pertama yaitu print('\n----------
--Kecepatan Akhir------------'), sebagai tampilan sekaligus penanda bahwa user
telah berada pada pilihan menu mencari besaran kecepatan akhir GLBB
Berikutnya terdapat inisiasi variabel a sebagai parameter input nilai percepatan
yang diketahui di soal, dengan menggunakan perintah input, a =
float(input('percepatan yang diketahui (m/s^2) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai yang
dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel v0 sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, v0 =
float(input('Kecepatan Awal yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran kecepatan akhir
yang di-inisiasi dengan pemisalan variabel vt = v0 + (a*t)
Berikutnya terdapat fungsi print('Besarnya kecepatan akhir : %.2f m/s\n\n--------
----Kasus GLBB------------'%vt), yang berfungsi untuk menampilkan hasil dari nilai
besaran kecepatan akhir yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glbb == 3 akan bekerja apabila user memasukkan pilihan nomor
3 (kecepatan awal jika diketahui perpindahan).
Di dalam fungsi if glbb == 3, terdapat fungsi yang pertama yaitu print('\n----------
--Kec.Awal Jika Diketahui Perpindahan------------'), sebagai tampilan sekaligus
penanda bahwa user telah berada pada pilihan menu mencari besaran kecepatan
awal GLBB jika diketahui perpindahan.
Berikutnya terdapat inisiasi variabel a sebagai parameter input nilai percepatan
yang diketahui di soal, dengan menggunakan perintah input, a =
float(input('percepatan yang diketahui (m/s^2) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai
pecahan/decimal
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai yang
dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel vt sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, vt =
float(input('Kecepatan Akhir yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel s sebagai parameter input nilai perpindahan
yang diketahui di soal, dengan menggunakan perintah input, s =
float(input('perpindahan yang diketahui (m) : ')). Dan fungsi float disini berfungsi
agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran kecepatan awal
yang di-inisiasi dengan pemisalan variabel v0 = (vt – (2*a*s))**1/2
Berikutnya terdapat fungsi print('Besarnya kecepatan awal : %.2f m/s\n\n---------
---Kasus GLBB------------'%v0), yang berfungsi untuk menampilkan hasil dari nilai
besaran kecepatan awal yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.
Pengkondisian elif glbb == 4 akan bekerja apabila user memasukkan pilihan nomor
4 (kecepatan akhir jika diketahui perpindahan).
Di dalam fungsi if glbb == 4, terdapat fungsi yang pertama yaitu print('\n----------
--Kec.Akhir Jika Diketahui Perpindahan------------'), sebagai tampilan sekaligus
penanda bahwa user telah berada pada pilihan menu mencari besaran kecepatan
akhir GLBB jika diketahui perpindahan.
Berikutnya terdapat inisiasi variabel a sebagai parameter input nilai percepatan
yang diketahui di soal, dengan menggunakan perintah input, a =
float(input('percepatan yang diketahui (m/s^2) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai yang
dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel vt sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, v0 =
float(input('Kecepatan Awal yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel s sebagai parameter input nilai perpindahan
yang diketahui di soal, dengan menggunakan perintah input, s =
float(input('perpindahan yang diketahui (m) : ')). Dan fungsi float disini berfungsi
agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran kecepatan akhir
yang di-inisiasi dengan pemisalan variabel vt = (v0 + (2*a*s))**1/2
Berikutnya terdapat fungsi print('Besarnya kecepatan akhir : %.2f m/s\n\n--------
----Kasus GLBB------------'%vt), yang berfungsi untuk menampilkan hasil dari nilai
besaran kecepatan akhir yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glbb == 5 akan bekerja apabila user memasukkan pilihan nomor
5 (percepatan).
Di dalam fungsi if glbb == 5, terdapat fungsi yang pertama yaitu print('\n----------
--Perpindahan------------'), sebagai tampilan sekaligus penanda bahwa user telah
berada pada pilihan menu mencari besaran perpindahan GLBB
Berikutnya terdapat inisiasi variabel a sebagai parameter input nilai percepatan
yang diketahui di soal, dengan menggunakan perintah input, a =
float(input('percepatan yang diketahui (m/s^2) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai yang
dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel v0 sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, v0 =
float(input('Kecepatan Awal yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran perpindahan yang
di-inisiasi dengan pemisalan variabel s = (v0*t) + ((1/2)*a*(t**2))
Berikutnya terdapat fungsi print('Besarnya perpindahan : %.2f m\n\n------------
Kasus GLBB------------'%s), yang berfungsi untuk menampilkan hasil dari nilai
besaran perpindahan yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glbb == 6 akan bekerja apabila user memasukkan pilihan nomor
6 (Percepatan).
Di dalam fungsi if glbb == 6, terdapat fungsi yang pertama yaitu print('\n----------
--Percepatan------------'), sebagai tampilan sekaligus penanda bahwa user telah
berada pada pilihan menu mencari besaran percepatan GLBB
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai yang
dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel v0 sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, v0 =
float(input('Kecepatan Awal yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel vt sebagai parameter input nilai kecepatan
akhir yang dikethui di soal, dengan menggunakan perintah input, vt =
float(input('Kecepatan Akhir yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran perpindahan yang
di-inisiasi dengan pemisalan variabel a = (vt – v0)/t
Berikutnya terdapat fungsi print('Besarnya percepatan : %.2f m/s^2\n\n-----------
-Kasus GLBB------------'%a), yang berfungsi untuk menampilkan hasil dari nilai
besaran percepatan yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.
Pengkondisian elif glbb == 7 akan bekerja apabila user memasukkan pilihan nomor
7 (Percepatan jika diketahui perpindahan dan kecepatan akhir).
Di dalam fungsi if glbb == 7, terdapat fungsi yang pertama yaitu print('\n----------
--Percepatan Jika Diketahui Perpindahan dan Kecepatan Akhir------------'),
sebagai tampilan sekaligus penanda bahwa user telah berada pada pilihan menu
mencari besaran percepatan GLBB jika diketahui perpindahan dan kecepatan akhir
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai waktu
tempuh yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel v0 sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, v0 =
float(input('Kecepatan Awal yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai waktu tempuh yang dapat diinput oleh user dapat berupa nilai
pecahan/decimal
Berikutnya terdapat inisiasi variabel vt sebagai parameter input nilai kecepatan
akhir yang dikethui di soal, dengan menggunakan perintah input, vt =
float(input('Kecepatan Akhir yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai waktu tempuh yang dapat diinput oleh user dapat berupa nilai
pecahan/decimal
Berikutnya terdapat inisiasi variabel a sebagai parameter input nilai perpindahan
yang diketahui di soal, dengan menggunakan perintah input, s =
float(input('Perpindahan yang diketahui (m) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran perpindahan yang
di-inisiasi dengan pemisalan variabel a = ((vt**2) – (v0**2))/(2*s)
Berikutnya terdapat fungsi print('Besarnya percepatan : %.2f m/s^2\n\n-----------
-Kasus GLBB------------'%a), yang berfungsi untuk menampilkan hasil dari nilai
besaran percepatan yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.

Pengkondisian elif glbb == 8 akan bekerja apabila user memasukkan pilihan nomor
7 (Percepatan jika diketahui perpindahan saja).
Di dalam fungsi if glbb == 8, terdapat fungsi yang pertama yaitu print('\n----------
--Percepatan Jika Diketahui Perpindahan Saja------------'), sebagai tampilan
sekaligus penanda bahwa user telah berada pada pilihan menu mencari besaran
percepatan GLBB jika diketahui perpindahan saja
Berikutnya terdapat inisiasi variabel t sebagai parameter input nilai waktu tempuh
yang dikethui di soal, dengan menggunakan perintah input, t = float(input('waktu
tempuh yang diketahui (s) : ')). Dan fungsi float disini berfungsi agar nilai waktu
tempuh yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Berikutnya terdapat inisiasi variabel v0 sebagai parameter input nilai kecepatan
awal yang dikethui di soal, dengan menggunakan perintah input, v0 =
float(input('Kecepatan Awal yang diketahui (m/s) : ')). Dan fungsi float disini
berfungsi agar nilai waktu tempuh yang dapat diinput oleh user dapat berupa nilai
pecahan/decimal
Berikutnya terdapat inisiasi variabel s sebagai parameter input nilai perpindahan
yang diketahui di soal, dengan menggunakan perintah input, s =
float(input('Perpindahan yang diketahui (m) : ')). Dan fungsi float disini
berfungsi agar nilai yang dapat diinput oleh user dapat berupa nilai pecahan/decimal
Lalu ada fungsi print (‘\n’) yang digunakan untuk membuat satu baris kosong agar
nanti hasil yang ditampilkan tampak lebih rapih.
Berikutnnya terdapat proses untuk menghitung nilai dari besaran perpindahan yang
di-inisiasi dengan pemisalan variabel a = (2*s)/(vt – v0)
Berikutnya terdapat fungsi print('Besarnya percepatan : %.2f m/s^2\n\n-----------
-Kasus GLBB------------'%a), yang berfungsi untuk menampilkan hasil dari nilai
besaran percepatan yang dicari. Serta akan menampilkan baris pertama dari
tampilan menu kasus GLBB
Untuk kasus gerak lurus berubah beraturan (GLBB), user juga diberi pilihan untuk
menampilkan grafik atau melanjutkan program. Sama seperti kasus GLB user
diminta memasukan nilai i dan nilainya dibawa oleh fungsi grafik_kh2() beserta
variabel t, v0, vt, dan a.
Variabel i, t, v0, vt, dan a kemudian disubtitusikan menjadi variabel n, i, j, k, dan l.
Sehingga jika i = 0 maka program akan memanggil fungsi grafik_kecepatan() selain
dari itu program akan kembali ke menu2(). Setelah n menjadi konstanta 0 maka
variabel yang tersisa i, j, k, dan l dibawa menuju fungsi grafik_kecepatan(), dan
grafik pun akan ditampilkan.
Fungsi terakhir dari pengkondisian ini, yaitu perintah return(menu2()), yang
berfungsi untuk memanggil fungsi menu2() tersebut agar program otomatis
kembali ke dalam pilihan menu kasus GLBB setelah program selesai menghitung
nilai besaran.

• GLBB 9

Pada saat nilai glbb = 9, program akan menjalankan kasus untuk mencari waktu
tempuh saat perpindahan diketahui. User akan diminta memasukan nilai dari v0, vt,
dan s dalam bentuk integer, kemudian variabel-variabel tersebut akan diolah untuk
mencari nilai t dengan rumus (2*s)/(vt-v0). Selanjutnya setelah t diketahu dan
ditampilkan nilainya program akan meminta user untuk memasukan nilai i yang
akan dimasukan ke fungsi grafik_kh2(), kemudian variabel-variabel yang tadi
didapat akan diplotkan ke dalam grafik jika i = 0 yang mana fungsi
grafik_kecepatan() akan dipanggil dan membuat grafik dari variabel-variabel yang
telah diketahui :
elif glbb == 9:
print('\n----------Waktu Tempuh Jika diketahui Perpindahan-
----------')
v0 = int(input('kecepatan awal yang diketahui (m/s) : '))
vt = int(input('kecepatan akhir yang diketahui (m/s) : '))
s = int(input('perpindahan yang diketahui (m) : '))
print('\n')
t = (2*s)/(vt-v0)
print('Waktu tempuh yang diperlukan : %.2f s\n\n----------
--Kasus GLBB------------'%t)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T)
: (0/1)"))
return grafik_kh2(i,t,v0,vt,a)

• GLBB 10

Pada saat nilai glbb = 10, program akan menjalankan kasus untuk mencari waktu
tempuh saat percepatan diketahui. User akan diminta memasukan nilai dari v0, vt,
dan a dalam bentuk integer sehingga nilai t didapat dari t = (vt-v0)/a. Selanjutnya
setelah t diketahu dan ditampilkan nilainya program akan meminta user untuk
memasukan nilai i yang akan dimasukan ke fungsi grafik_kh2(), kemudian
variabel-variabel yang tadi didapat akan diplotkan ke dalam grafik jika i = 0 yang
mana fungsi grafik_kecepatan() akan dipanggil dan membuat grafik dari variabel-
variabel yang telah diketahui :
elif glbb == 10:
print('\n----------Waktu Tempuh Jika diketahui Percepatan-
----------')
v0 = int(input('kecepatan awal yang diketahui (m/s) : '))
vt = int(input('kecepatan akhir yang diketahui (m/s) : '))
 a = int(input('perpindahan yang diketahui (m/s^2) : '))
print('\n')
t = (vt-v0)/a
print('Waktu tempuh yang diperlukan : %.2f s\n\n----------
--Kasus GLBB------------'%t)
i = int(input("Tampilkan grafik dan akhiri program? (Y/T)
: (0/1)"))
return grafik_kh2(i,t,v0,vt,a)

Pengkondisian elif glbb == 11 akan bekerja apabila user memasukkan pilihan

nomor 11 (mencari kecepatan sesaat).
Di dalam fungsi if glbb == 11, terdapat fungsi yang pertama yaitu t = symbols('t'),
yang gunanya adalah untuk mendefinisikan variabel t sebagai symbol, sehingga
dapat dilakukan operasi matematika aljabar terhadap variabel tersebut
menggunakan SymPy.
Berikutnya ada perintah print('\n----------Kecepatan Sesaat-----------') berfungsi
sebagai tampilan sekaligus penanda bahwa user telah berada pada pilihan menu
mencari nilai besaran kecepatan sesaat pada kasus GLBB.
Berikutnya terdapat inisiasi variabel r sebagai parameter input persamaan vector
posisi yang diketahui di soal, dengan menggunakan perintah input, r =
(input('Masukkan Persamaan Vektor Posisi yang diketahui (dlm variabel t) : ')).
Berikutnya terdapat inisiasi variabel t1sebagai parameter input nilai waktu sesaat
yang dikethui di soal, dengan menggunakan perintah input, t1 = float(input('waktu
kecepatan sesaat saat t (s) = ')). Dan fungsi float disini berfungsi agar nilai waktu
sesaat yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Berikutnnya terdapat proses untuk menghitung nilai turunan dari persamaan vector
posisi yang telah diinput yang di-inisiasi dengan pemisalan variabel v dan
menggunakan fungsi v = diff(r,t), yang bermakna diferensial fungsi persamaan r
terhadap variabel t.
Berikutnya ada perintah v1 = limit(v,t,t1), yang berguna untuk mensubstitusi nilai
waktu sesaat yang telah di input oleh user pada baris t1 sebelumnya.
Berikutnya ada perintah print ('Kecepatan Sesaatnya adalah = %s m/s'%v1), yang
berfungsi menampilkan hasil dari perhitungan kecepataan sesaat disaat waktu t1
sekon.
Berikutny ada fungsi print('\n\n------------Kasus GLBB------------') dan return
(menu2()) yang akan mengembalikan program secara otomatis ke pilihan menu
GLBB setelah selesai menghitung nilai besaran yang dicari.

Pengkondisian elif glbb == 12 akan bekerja apabila user memasukkan pilihan

nomor 12 (mencari percepatan sesaat).
Di dalam fungsi if glbb == 12, terdapat fungsi yang pertama yaitu t = symbols('t'),
yang gunanya adalah untuk mendefinisikan variabel t sebagai symbol, sehingga
dapat dilakukan operasi matematika aljabar terhadap variabel tersebut
menggunakan SymPy.
Berikutnya ada perintah print('\n----------Percepatan Sesaat-----------') berfungsi
sebagai tampilan sekaligus penanda bahwa user telah berada pada pilihan menu
mencari nilai besaran percepatan sesaat pada kasus GLBB.
Berikutnya terdapat inisiasi variabel v sebagai parameter input persamaan vector
kecepatan yang diketahui di soal, dengan menggunakan perintah input :
v = (input('Masukkan Persamaan Vektor Kecepatan yang diketahui (dlm
variabel t) : ')).
Berikutnya terdapat inisiasi variabel t1sebagai parameter input nilai waktu sesaat
yang dikethui di soal, dengan menggunakan perintah input, t1 = float(input('waktu
kecepatan sesaat saat t (s) = ')). Dan fungsi float disini berfungsi agar nilai waktu
sesaat yang dapat diinput oleh user dapat berupa nilai pecahan/desimal.
Berikutnnya terdapat proses untuk menghitung nilai turunan dari persamaan vector
posisi yang telah diinput yang di-inisiasi dengan pemisalan variabel a dan
menggunakan fungsi a = diff(v,t), yang bermakna diferensial fungsi persamaan
vector v terhadap variabel t.
Berikutnya ada perintah a1 = limit(a,t,t1), yang berguna untuk mensubstitusi nilai
waktu sesaat yang telah di input oleh user pada baris t1 sebelumnya.
Berikutnya ada perintah print('Percepatan Sesaatnya adalah = %s m/s^2'%a1),
yang berfungsi menampilkan hasil dari perhitungan percepatan sesaat disaat waktu
t1 sekon.
Berikutny ada fungsi print('\n\n------------Kasus GLBB------------') dan return
(menu2()) yang akan mengembalikan program secara otomatis ke pilihan menu
GLBB setelah selesai menghitung nilai besaran yang dicari.

Pengkondisian elif glbb == 0 akan bekerja apabila user memasukkan pilihan nomor
0 (Kembali ke Main Menu).
Di dalam pengkondisian ini terdapat fungsi return(utama()) yang akan memanggil
fungsi utama() dimana fungsi tersebut merupakan tampilan menu utama dari
program, sehingga program akan berada kembali di main menu.

Pengkondisian else akan dapat bekerja apabila user menginputkan nomor menu
yang tidak tersedia pada pilihan.
Di dalam pengkondisian else, akan ditampilkan sebuah pesan bahwa input yang
dimasukkan user salah atau tidak sesuai dengan menggunakan fungsi
return('\nInput Yang Anda Masukkan Tidak Sesuai\n\n........Silahkan Ulangi
Lagi........').

Lalu terdapat perintah print('----------Selamat Datang---------') dan print('------

Kalkulator GLB & GLBB------') yang akan ditampilkan pertama kali saat program
baru dijalankan. Kedua string tersebut bisa dibilang merupakan tulisan sambutan
selamat datang yang akan muncul dan ditampilkan kepada user ketika baru
menjalankan program.
Dan dibaris terakhir terdapat fungsi print(utama()) yang artinya program tersebut
akan memanggil serta menampilkan isi dari def fungsi utama yang telah dibuat di
baris-baris sebelumnya.
IV. Kesimpulan
A. Dengan mengaplikasikan materi dari modul-modul yang telah diajarkan,
praktikan dapat menyelesaikan sebuah program yang di dalamnya modul-
modul tersebut saling terintegrasi satu sama lainnya. Modul yang digunakan
dalam program ini antara lain :
• Operator dan Statement
• Struktur Kendali
• Fungsi
• Matplotlib dan Numpy
• Symbolic Math
B. Dengan mengaplikasikan modul-modul tersebut, sehingga praktikan dapat
membuat sebuah program yang bisa menyelesaikan persoalan Fisika dalam
kasus gerak lurus yaitu Gerak Lurus Beraturan dan Gerak Lurus Berubah
Beraturan.
 DAFTAR PUSTAKA

Halliday, Resnick, &Walker. (2010). Fisika Dasar. Edisi 1, Erlangga. Jakarta.

Serway.(2013). Physics for Scientist & Engineers. Ninth Edition, Cengange
Learning.