Mencari Nilai Akar dengan Menggunakan Metode Babylon

26 August 2010 by · Leave a Comment 
  

Dari dulu saya selalu bingung cara mencari nilai suatu akar dengan pasti. Setiap kalkulator scientific bisa “menebak” nilai dari suatu akar bilangan. Sampai suatu saat di kelas TPB di kampus dalam mata kuliah kalkulus, saya mengenal lebih dalam apa itu limit. Kita bisa menggunakan limit untuk mencari pendekatan suatu nilai dari fungsi yang kita cari termasuk mencari nilai dari fungsi akar. Dasar saya emang bodoh, saya tidak begitu memahami prinsip limit ini.

Pada sebuah buku pemrograman, saya menemukan algoritma bagaimana mencari nilai akar dengan menggunakan fungsi Babylon. Fungsi ini menggunakan looping atau perulangan untuk mendapatkan nilai yang lebih presis. Syarat agar perhitungan kita berhenti dari perulangan, kita harus menetapkan suatu batasan atau nilai toleransi.

Algoritma Babylon bisa dituliskan seperti ini:

  1. Ambil nilai yang akan dicari nilai akarnya, misalkan bilangan ini adalah x.
  2. Kita akan menggunakan variabel lain yaitu y. Jika x>2, maka nilai y kita set nilainya menjadi x/2, namun jika 0<x<=2, maka kita set nilai y=1
  3. Cari nilai y baru yang diperoleh lewat perhitungan y = { (y + x/y)/2 }. Ingat nilai y yang di sebelah kiri adalah nilai y yang ingin kita cari, sedangkan nilai y yang di sebelah kanan adalah nilai y yang kita peroleh dari langkah 2 di atas.
  4. Tentukan batas toleransi, misalnya Epsilon E = 5×10-15.
  5. Jika E < | y*y – x |, ulang dan kembali ke langkah 3 dengan nilai y adalah nilai y yang terakhir. Jika E > | y*y -x |, ikuti langkah 6.
  6. Nilai akar x yang kita cari adalah nilai y yang tadi kita peroleh.

Contohnya kita ingin mencari nilai akar 5.

  1. Nilai x = 5.
  2. x > 2, maka nilai y=x/2 atau y = 2,5
  3. y = { (y + x/y)/2 } = (2,5 + 5/2,5)/2 = 2,25
  4. E = 5×10-8
  5. y*y – x = 2,25*2,25 – 5 = 0,0625
  6. x – y*y = 5 – 2,25*2,25 = -0,0625
  7. Kita bandingkan nilai Epsilon dengan hasil di atas. E =5×10-8 lebih kecil dari salah satu nilai di atas. 5×10-8 < -0,0625, jadi kita ulangi lagi langkahnya.
  8. y = { (y + x/y)/2 } = (2,25 + 5/2,25)/2 = 2,2361..
  9. E = 5×10-15
  10. y*y – x = 2,2361*2,361 – 5 = 1,929×10-4
  11. x – y*y = 5 – 2,2361*2,361 = -1,929×10-4
  12. Kita bandingkan nilai Epsilon dengan hasil di atas. E =5×10-8 lebih kecil dari salah satu nilai di atas. 5×10-8 < 1,929×10-4, jadi kita ulangi lagi langkahnya.
  13. y = { (y + x/y)/2 } = (2,2361 + 5/2,2361)/2 = 2,236067978..
  14. E = 5×10-15
  15. y*y – x = 2,23606*2,3606 – 5 = 1,88×10-9
  16. x – y*y = 5 – 2,23606*2,3606 = -1,88×10-9
  17. Kita bandingkan nilai Epsilon dengan hasil di atas. E = 5×10-8 lebih besar dari salah satu nilai di atas. 5×10-8 > 1,88×10-9. Karena syarat E > | y*y -x | sudah terpenuhi, maka perulangan dihentikan.

Nilai akhir y adalah hasil akar dari nilai x. Jadi akar 5 adalah 2,236067978. Tentunya nilai ini adalah pendekatan. Jika teman-teman menghitung nilai akar 5 langsung dari kalkulator, nilainya (hampir) sama dengan nilai dengan menggunakan cara Babylon. Untuk mendapatkan nilai yang lebih presisi, kita bisa menggunakan nilai Epsilon yang lebih rendah dari nilai di atas, namun dengan nilai di atas pun, saya bisa mendapatkan kepresisian 9 angka di belakang koma dengan 2 kali perulangan. Jangan-jangan hasil perhitungan akar dari kalkulator yang sering kita pakai, itu menggunakan cara Babylon ya :D

Untuk programnya, bisa menggunakan C++ atau bahasa lain. Contoh di bawah ini adalah program mencari akar dengan nilai epsilon 5×10-15.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/*
	compile with g++ (MinGW)
	ex : g++ square.cpp -o square
*/
 
#include <iostream>
#include <iomanip>
using namespace std;
 
/*deklarasi fungsi babylon*/
double	babylon(double);
 
/*fungsi utama*/
int main()
{
	double X;
	cout << "Input bilangan yang akan dicari akarnya : ";
	cin >> X;
	cout << "==============================\n";
	cout << "\t Y \t Y*Y \n";
	cout << "==============================\n";
 
	/*panggil fungsi babylon dengan parameter nilai akar yang dicari*/
	double y = babylon(X);
	cout << "==============================\n";
 
	/*set nilai kepresisian jika perlu*/
	cout << "Akar " << X << " adalah : " << setprecision(20) <<y << endl;
 
	return 0;
}
 
/*detail fungsi babylon*/
double babylon(double x){
	/*
		batas nilai toleransi (epsilon), atau epsilon
		usahakan nilai ini jangan terlalu besar atau terlalu kecil
	*/
	const double TOLERANSI = 5e-15;
	if(x < 0)
		return 0.0;
 
	/*jika
		x > 2 -> y = x/2
		x <= 2 -> y = 1
	*/
	double y = (x > 2 ? x/2 : 1);
 
	/*
		ulangi sampai syarat dipenuhi : epsilon > | y*y - x |
		jika sudah memenuhi syarat, maka nilai akar adalah nilai y
	*/
	do{
		y = (y + x/y) / 2;
		cout << setw(10) << y << setw(12) << y*y << "\n";
	}while(x > y*y + TOLERANSI || y*y > x + TOLERANSI);
	return y;
}

About Duken Marga
Engineer alumni Teknik Sipil ITB yang senang dengan programming, internet, application development, sains, teknologi, dan matematika.

What's in your mind?