METODE GELEMBUNG ( BUBBLE SORT )

METODE GELEMBUNG ( BUBBLE SORT )

A.      Pengertian Bubble Sort

Bubble Sort adalah salah satu algoritma untuk sorting data, atau kata lainnya mengurutkan data dari yang terbesar ke yang terkecil atau sebaliknya (Ascending atau Descending).

Bubble sort (metode gelembung) adalah metode/algoritma pengurutan dengan dengan cara melakukan penukaran data dengan tepat disebelahnya secara terus menerus sampai bisa dipastikan dalam satu iterasi tertentu tidak ada lagi perubahan. Jika tidak ada perubahan berarti data sudah terurut. Disebut pengurutan gelembung karena masing-masing kunci akan dengan lambat menggelembung ke posisinya yang tepat.

                        Metode pengurutan gelembung (Bubble Sort) diinspirasikan oleh gelembung sabun yang berada dipermukaan air. Karena berat jenis gelembung sabun lebih ringan daripada berat jenis air, maka gelembung sabun selalu terapung ke atas permukaan. Prinsip di atas dipakai pada pengurutan gelembung.

Algoritma bubble sort adalah salah satu algoritma pengurutan yang paling simple, baik dalam hal pengertian maupun penerapannya. Ide dari algoritma ini adalah mengulang proses pembandingan antara tiap-tiap elemen

array dan menukarnya apabila urutannya salah. Pembandingan elemen-elemen ini akan terus diulang hingga tidak perlu dilakukan penukaran lagi. Algoritma

ini termasuk dalam golongan algoritma comparison sort, karena menggunakan perbandingan dalam operasi antar elemennya. Berikut ini adalah gambaran dari algoritma bubble sort. Misalkan kita mempunyai sebuah array dengan.  Elemen-elemen “4 2 5 3 9”. Proses yang akan terjadi apabila digunakan algoritma bubblesort adalah sebagai berikut.

Pass pertama

(4 2 5 3 9) menjadi (2 4 5 3 9)

(2 4 5 3 9) menjadi (2 4 5 3 9)

(2 4 5 3 9) menjadi (2 4 3 5 9)

(2 4 3 5 9) menjadi (2 4 3 5 9)

Pass kedua

(2 4 3 5 9) menjadi (2 4 3 5 9)

(2 4 3 5 9) menjadi (2 3 4 5 9)

(2 3 4 5 9) menjadi (2 3 4 5 9)

(2 3 4 5 9) menjadi (2 3 4 5 9)

Pass ketiga

(2 3 4 5 9) menjadi (2 3 4 5 9)

(2 3 4 5 9) menjadi (2 3 4 5 9)

(2 3 4 5 9) menjadi (2 3 4 5 9)

(2 3 4 5 9) menjadi (2 3 4 5 9)

Dapat dilihat pada proses di atas, sebenarnya pada pass kedua, langkah kedua, array telah terurut. Namun algoritma tetap dilanjutkan hingga pass kedua berakhir. Pass ketiga dilakukan karena definisi terurut dalam algoritma bubblesort adalah tidak ada satupun penukaran pada suatu pass, sehingga pass ketiga dibutuhkan untuk memverifikasi keurutan array tersebut.

B.      Algoritma Bubble Sort

1.    Membandingkan data ke-i dengan data ke-(i+1) (tepat bersebelahan). Jika tidak sesuai maka tukar (data ke-i = data ke-(i+1) dan data ke-(i+1) = data ke-i). Apa maksudnya tidak sesuai? Jika kita menginginkan algoritme menghasilkan data dengan urutan ascending (A-Z) kondisi tidak sesuai adalah data ke-i > data ke-i+1, dan sebaliknya untuk urutan descending (A-Z).

2.    Membandingkan data ke-(i+1) dengan data ke-(i+2). Kita melakukan pembandingan ini sampai data terakhir. Contoh: 1 dgn 2; 2 dgn 3; 3 dgn 4; 4 dgn 5 … ; n-1 dgn n.

3.    Selesai satu iterasi, adalah jika kita sudah selesai membandingkan antara (n-1) dgn n. Setelah selesai satu iterasi kita lanjutkan lagi iterasi berikutnya sesuai dengan aturan ke-1. mulai dari data ke-1 dgn data ke-2, dst.

4.    Proses akan berhenti jika tidak ada pertukaran dalam satu iterasi.

Contoh Kasus Bubble Sort :

Misalkan kita punya data seperti ini: 6, 4, 3, 2 dan kita ingin mengurutkan data ini (ascending) dengan menggunakan bubble sort. Berikut ini adalah proses yang terjadi:

Iterasi ke-1: 4, 6, 3, 2 :: 4, 3, 6, 2 :: 4, 3, 2, 6 (ada 3 pertukaran)

Iterasi ke-2: 3, 4, 2, 6 :: 3, 2, 4, 6 :: 3, 2, 4, 6 (ada 2 pertukaran)

Iterasi ke-3: 2, 3, 4, 6 :: 2, 3, 4, 6 :: 2, 3, 4, 6 (ada 1 pertukaran)

Iterasi ke-4: 2, 3, 4, 6 :: 2, 3, 4, 6 :: 2, 3, 4, 6 (ada 0 pertukaran) -> proses selesai

C.      Kompleksitas Algoritma Bubble Sort

Kompleksitas Algoritma Bubble Sort dapat dilihat dari beberapa jenis kasus, yaitu worst-case, average-case, dan best-case.

Ø  Kondisi Best-Case

Dalam kasus ini, data yang akan disorting telah terurut sebelumnya, sehingga proses perbandingan hanya dilakukan sebanyak (n-1) kali, dengan satu kali pass.

Proses perbandingan dilakukan hanya untuk memverifikasi keurutan data. Contoh Best-Case dapat dilihat pada pengurutan data “1 2 3 4” di bawah ini.

Pass Pertama

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

Dari proses di atas, dapat dilihat bahwa tidak terjadi penukaran posisi satu kalipun, sehingga tidak dilakukan pass selanjutnya. Perbandingan elemen dilakukan sebanyak tiga kali. Proses perbandingan pada kondisi ini hanya dilakukan sebanyak (n-1) kali. Persamaan Big-O yang diperoleh dari proses ini adalah O(n). Dengan kata lain, pada kondisi Best-Case algoritma Bubble Sort termasuk pada algoritma

lanjar.

Ø  Kondisi Worst-Case

Dalam kasus ini, data terkecil berada pada ujung array. Contoh Worst-Case dapat dilihat pada pengurutan data “4 3 2 1” di bawah ini.

Pass Pertama

(4 3 2 1) menjadi (3 4 2 1)

(3 4 2 1) menjadi (3 2 4 1)

(3 2 4 1) menjadi (3 2 1 4)

Pass Kedua

(3 2 1 4) menjadi (2 3 1 4)

(2 3 1 4) menjadi (2 1 3 4)

(2 1 3 4) menjadi (2 1 3 4)

Pass Ketiga

(2 1 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

Pass Keempat

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

(1 2 3 4) menjadi (1 2 3 4)

Dari langkah pengurutan di atas, terlihat bahwa setiap kali melakukan satu pass, data terkecil akan bergeser ke arah awal sebanyak satu step. Dengan kata lain, untuk menggeser data terkecil dari urutan keempat menuju urutan pertama, dibutuhkan pass sebanyak tiga kali, ditambah satu kali pass untuk memverifikasi. Sehingga jumlah proses pada kondisi best case dapat dirumuskan sebagai berikut. Jumlah proses = n2+n (3)

Dalam persamaan (3) di atas, n adalah jumlah elemen yang akan diurutkan. Sehingga notasi Big-O yang didapat adalah O(n2). Dengan kata lain, pada kondisi worst-case, algoritma Bubble Sort termasuk dalam kategori algoritma kuadratik.

Ø  Kondisi Average-Case

Pada kondisi average-case, jumlah pass ditentukan dari elemen mana yang mengalami penggeseran ke kiri paling banyak. Hal ini dapat ditunjukkan oleh proses pengurutan suatu array, misalkan saja (1 8 6 2). Dari (1 8 6 2), dapat dilihat bahwa yang akan mengalami proses penggeseran paling banyak adalah elemen 2, yaitu sebanyak dua kali.

Pass Pertama

(1 8 6 2) menjadi (1 8 6 2)

(1 8 6 2) menjadi (1 6 8 2)

(1 6 8 2) menjadi (1 6 2 8)

Pass Kedua

(1 6 2 8) menjadi (1 6 2 8)

(1 6 2 8) menjadi (1 2 6 8)

(1 2 6 8) menjadi (1 2 6 8)

Pass Ketiga

(1 2 6 8) menjadi (1 2 6 8)

(1 2 6 8) menjadi (1 2 6 8)

(1 2 6 8) menjadi (1 2 6 8)

Dari proses pengurutan di atas, dapat dilihat bahwa untuk mengurutkan diperlukan dua buah passing, ditambah satu buah passing untuk memverifikasi. Dengan kata lain, jumlah proses perbandingan dapat dihitung sebagai berikut. Jumlah proses = x2+x (4) Dalam persamaan (4) di atas, x adalah jumlah penggeseran terbanyak. Dalam hal ini, x tidak pernah lebih besar dari n, sehingga x dapat dirumuskan sebagai

Dari persamaan (4) dan (5) di atas, dapat disimpulkan bahwa notasi

big-O nya adalah O(n2). Dengan kata lain, pada kondisi average case algoritma Bubble Sort termasuk dalam algoritma kuadratik.

D.       Kelebihan dan Kelemahan Bubble Sort

Kelebihan :

·      Metode Buble Sort merupakan metode yang paling simpel

·      Metode Buble Sort mudah dipahami algoritmanya

Kelemahan:

Meskipun simpel metode Bubble sort  merupakan metode pengurutan yang paling tidak efisien.  Kelemahan buble sort adalah pada saat mengurutkan data yang sangat besar akan mengalami kelambatan luar biasa, atau dengan kata lain kinerja memburuk cukup signifikan ketika data yang diolah jika  data cukup banyak. Kelemahan lain adalah jumlah pengulangan akan tetap sama jumlahnya walaupun data sesungguhnya sudah cukup terurut. Hal ini disebabkan setiap data dibandingkan dengan setiap data yang lain untuk menentukan posisinya.

Sumber  :  http://buublesort.blogspot.com/

Kelompok 
Rahmansyah hidayat
Andika Pratama

Program Mencari Akar-akar Persamaan Suku Banyak (Metode Secant)

1. Persamaan yang dicari : 9x^4 + 2x^3 + 3x - 1 = 0
nilai awal x1 : 5
nilai awal x2 : 6
nilai error      : 0.00001
total iterasi    : 15

2. Kode program (bahasa C) :
/*mencari akar persamaan dari persamaan 9x^4 + 2x^3 + 3x - 1 = 0*/

#include<stdio.h>
#include<math.h>

double power(double, int);
double value(double);
double calculate(double, double);

main()
{
    double x1, x2, e;
    int itr;
    printf ("Input Nilai Awal x1 : ");
    scanf ("%lf", &x1);
    printf ("Input Nilai Awal x2 : ");
    scanf ("%lf", &x2);
    printf ("Input Nilai Error : ");
    scanf ("%lf", &e);
    printf ("Input Total Iterasi : ");
    scanf ("%i", &itr);

    int i=1;
    double xt, error=1.0000;

     printf("\n");
    printf ("+------------+--------+--------+--------+-----------+\n");
    printf ("|Iterasi ke- |   xl   |   xb   |   xt   |  |error|  |\n");
    printf ("+------------+--------+--------+--------+-----------+\n");

    for (i=1;(i<itr) && (error>e);i++)
    {
        xt = calculate(x1, x2);
        printf ("|     %3i    |%8.4lf|%8.4lf|%8.4lf|%11.6lf|\n", i, x1, x2, xt, cabs(value(xt)));
        error = cabs(value(xt));

        x1=x2;
        x2=xt;

    }
    printf ("+------------+--------+--------+--------+-----------+\n");
}

double power(double number, int power)
{
    double result = 1.00;

    if (power == 0.0)
    {
        return result;
    }

    int i;

    for (i = 1; i <= power; i++)
    {
        result *=number;
    }

    return result;
}

double value(double x)
{
    return ((4*(power(x,3))) - (15*(power(x,2))) + 17*x - 6);
}

double calculate(double xl, double xb)
{
    return (xb - ((xb-xl)/(value(xb)-value(xl)))*value(xb));
}

3. Hasil keluaran :

4. Hasil akhir :

x = 2

berhenti pada iterasi ke-11, di mana nilai error sudah 0

Nama : Adhia Saputra

NIM   : D1042131046

Teknik Informatika UNTAN 2013 (Reguler B)

PERBANDINGAN ANTARA METODA

PERBANDINGAN ANTARA METODA

Telah dijelas kan dari awal bab pertama yang masing kelompok telah menjelas kan masing-masing fungsi yang ada dalam contoh.

Kami akan menjelas kan keunggulan dari kelemahan dari setiap metoda di tinjau dalam penggunaan secara umum.

Faktor-faktor lain yang dapat mempegaruhi dan menentukan dalam pemilihan sebuah metoda adalah factor subyektif seorang pemogram. Tingkat kemampuan ,pengetahuan ,kebiasaan penggunaan,kecakapan tentang fungsi,atau bahkan fanatisme terhadap metoda tertentu mungkin justru akan mampu mengungguli factor obyektif lain.

Berikut perbandingan antar metoda untuk menghitung akar-akar persamaan suku banyak.

METODA NEWTON

Proses perhitungan akar-akar persamaan dengan pendekatan metode newton dimulai dengan menetapkan harga pendekatan awal akar persamaan yang di inputkan sebagai X dan Epsilon.

Proses pengulangan adalah melakukan proses berulang untuk menghitung nilai penambahan dan pendekatan. Proses perulangan akan berhenti jika harga X telah mencapai harga mutlak artinya, akar persamaan telah ditemukan atau jika cacah perulangannya telah mencapai 20 kali.

Penggunaan pendekatan metoda newton untuk menghitung akar-akar persamaan suku banyak  umum nya mempunyai efisiensi yang sangat baik dalam proses perhitungannya.

Prosedur perhitungannya relatif sederhana mudah dipahami. Pendekatan metode newton sangat baik digunakan jika kita dan merasa kurang yakin tentang fungsi derivative dan tidak dapat menetapkan harga awal (fungsi X) yang baik.

Terlepas dari semua keunggulan tersebut penggunaan metoda ini akan relatif mudah terjadi error pada hasil perhitungannya. Selain itu kecakapan dalam membuat fungsi derivatif  bisa jadi akan menjadi hambatan yang dihadapi untuk menerapkannya.

Kelebihan

-          Konvergensi yang dihasilkan lebih cepat.

Kekurangan

-          Tidak selalu menemukan akar (divergen)

-          Kemungkinan sulit dalam mencari f’(xn).

-          Penetapan harga awal (xn) yang sulit.

Metoda Secant

Metode secant terkadang disebut juga sebagai computed line approach. Pendekatan dengan metoda ini akan memerlukan 2 harga awal yaitu X1 dan X2. Harga awal tersebut berfungsi untuk menentukan harga-harga pendekatan baru. Metoda secant memiliki kelemahan-kelemahan yang dapat diidentifikasikan diantaranya jika penetapan harga awal tidak baik maka pendekatan dengan metoda secant hanya akan memberikan sangat sedikit kemungkinan harga akar-akar persamaan pada interval yang ditentukan. Kemungkinan lain dapat terjadi yaitu pada saat tertentu extrapolasi dari 2 titik pendekatan awal untuk harga-harga akar persamaan yang sudah sangat dekat dengan harga sebenarnya yang dicari justru akan menghasilkan titik baru yang semakin menjauhi akar persamaan yang sebenarnya. Umum nya pendekatan metoda secant dapat diterapkan dengan efisiensi yang cukup baik. Metoda ini juga baik digunakan apabila kita mempunyai pengetahuan dan kecakapan tentang fungsi, tetapi tidak begitu paham tentang fungsi derivarif. Metode Secant menyerupai metode Newton-Raphson. Jika turunan fungsi f(x) sulit diperoleh / dihitung, maka metode Secant menjadi alternatif yang baik bagi metode Newton-Raphson.

Kelebihan         : merupakan fungsi berkelanjuhan (continue)

Kekurangan    : analisis turunan

Metoda Successive Bisection

Hal-hal yang perlu diperhatikan dalam metode biseksi Fungsi harus kontinu pada interval  xn dan xn+1. Menentukan  xn dan xn+1 dapat diperoleh dengan membuat grafik fungsinya. Nilai toleransi (error) dapat ditentukan oleh pengguna ataupun didasarkan pada bidang ilmu dari permasalahan yang diselesaikan. Pendekatan metoda biseksi umumnya lebih menjamin keberhasilan perhitungan akar-akar persamaan daripada 2 pendekatan sebelumnya yaitu metoda newton dan secant dengan catatan apabila persamaan secara fungsinya continue pada semua tempat. Penggunaan pendekatan metoda biseksi memerlumakan paling banyak iterasi perulangan.

Kelebihan Metode Biseksi

-          Selalu berhasil menemukan akar (solusi) yang dicari, atau dengan kata lain selalu konvergen.

Kekurangan Metode Biseksi

-          Metode biseksi hanya dapat dilakukan apabila ada akar persamaan pada interval yang diberikan.

-          Jika ada beberapa akar pada interval yang diberikan maka hanya satu akar saja yang dapat ditemukan.

-          Memiliki proses iterasi yang banyak sehingga memperlama proses penyelesaian. Tidak memandang bahwa sebenarnya akar atau solusi yang dicari dekat sekali dengan batas interval yang digunakan.

Metoda fixed point

Metode Titik Tetap’ (fixed-point), yaitu suatu metode pendekatan numeris yang terbentuk dari reorganisasi PANLT sedemikian rupa sehingga dihasilkan 2 buah fungsi, di sisi yang satu hanya mengandung variabel bebasnya saja sedangkan di sisi lainnya berbentuk g(x), suatu fungsi dalam bentuk yang lain. Metode ini memerlukan 1 (satu) buah harga x (disebut sebagai xawal) sebagai ‘tebakan’ untuk memulai proses iterasi. Karena sifatnya yang kurang praktis, bahkan tidak efisien dan juga lambat dalam mencapai konvergensi. Pada beberapa fungsi persamaan bisa terjadi kemungkinan bahwa harga pendekatan akar-akar persamaan hasil perhitungan pada iterasi-iterasi selanjutnya justru semakin menjauh dari harga penyelesaian yang dicari, dan pendekatan metoda fixed point iteration tidak dapat diterapkan untuk menyelesaikan apa yang dicari. Hal ini berarti bahwa pendekatan metoda fixed point iteration tidak dapat diterapkan untuk semua fungsi persamaan. Ciri khas fungsi persamaan yang akan mengalami kegagalan konvergensi dan tidak akan ditemukan penyelesaian apabila menggunakan pendekatan metoda fixed point.

Tugas Kelompok :

1. Hery Supriza                   D1042131010

2. Ferdinand Panggabean   D1042131026

Metode Segi Empat Sembarang

Metode Segi Empat Sembarang 

RITA WAHYUNI (D1042131020)
YUNITA WULANDARI (D104231016)


    Metode segi empat sembarang adalah hampir sama dengan pendekatan metoda Simpson dan empat persegi panjang.
    Perbedaannya, pendekatan pada bidang yang digunakan kurva F(X) adalah berbentuk segi empat sembarang, tidak harus empat persegi panjang.


    Perhitungan integral dengan pendekatan metoda segi empat sembarang, umumnya memberikan hasil perhitungan yang lebih akurat.
    Selain itu akurasi hasil perhitungannya akan semakin bertambah jika cacah sub interval (=N) semakin banyak, sehingga ukuran lebar masing-masing sub interval = (P) semakin kecil.
    Solusi dalam bentuk algoritma untuk menghitung harga integral suatu fungsi dengan menggunakan pendekatan metoda segi empat sembarang :
        Secara relatif umumnya perhitungan fungsi integral dengan metoda simpson akan memberikan hasil yang akurat, kesalahn dalam perhitungan relatif lebih kecil.
    Pendekatan metoda empat persegi panjang relatif paling mudah di pahami dan sederhana namun mempunyai kelemahan yaitu kemungkinan terjadinya kesalahan perhitungan sangat besar.
    Sedangakan metode segi empat sembarang secara relatif memiliki keunggulan dan kelemahan diantara kedua metoda lainnya.


KESIMPULAN :
Semakin kecil lebar sub interval yang digunakan akan memberikan hasil yang lebih baik. Perbedaannya, bidang yang dipergunakan untuk pendekatan kurva fungsi dan metode yang akan memberikan hasil akhir perhitungan yang tingkat dapat saling diperbandingkan

Program mencari akar-akar persamaan suku banyak (Metoda Secant)

1. Persamaan yang dicari 7x^3 - 12x^4 + 16x - 4 = 0*

2. Code program

#include<stdio.h>
#include<math.h>

double power(double, int);
double value(double);
double calculate(double, double);

main()
{
    double x1, x2, e;
    int it;
    printf ("Tebakan pertama     : ");
    scanf ("%lf", &x1);
    printf ("Tebakan kedua       : ");
    scanf ("%lf", &x2);
    printf ("Masukan eror        : ");
    scanf ("%lf", &e);
    printf ("Berapa kali iterasi : ");
    scanf ("%i", &it);
    printf ("%lf",e);

    int i=1;
    double xt, fxt;

    printf("\n");
    printf ("Iterasi ke-    xl      xb    xt        |f(xt)|  \n");
    for (i=1;i<it;i++)
    {
        xt = calculate(x1, x2);
        printf ("  %3i     %8.4lf%8.4lf %8.4lf %11.6lf \n", i, x1, x2, xt, cabs(value(xt)));
        fxt = cabs(value(xt));

        x1=x2;
        x2=xt;

    }

}

double power(double number, int power)
{
    double result = 1.00;

    if (power == 0.0)
    {
        return result;
    }

    int i;

    for (i = 1; i <= power; i++)
    {
        result *=number;
    }

    return result;
}

double value(double x)
{
    return ((7*(power(x,3))) - (12*(power(x,4))) + 16*x - 4);
}

double calculate(double xl, double xb)
{
    return (xb - ((xb-xl)/(value(xb)-value(xl)))*value(xb));
}

3. Hasil iterasi;

4. Hasil Terakhir
 Interasi ke 14 0.2462 seperti gambar di atas


Nama: Tito Anggoro
NIM  : D1042131014

Source Code Metode Secant

Pembahasan : 

Membuat Program aplikasi untuk menghitung akar persamaan suku banyak dengan metode secant.

1. Persamaan yang dicari akarnya

mencari akar persamaan dari persamaan x^x - x + 1^-x = 0

Nilai awal          : 0

Nilai Akhir         : 1

Nilai Error         : 0.00001

Jumlah Literasi : 10

2. Kode program menggunakan bahasa c :

#include <stdio.h>

#include <math.h>

#define max 100

double fungsix(double);

main(){

 double x[max]={0.5}, fx[max], e=0.0001,abso[max];

 int i =0, n=0,j=0,k=0, temp=0;

 printf("Masukan nilai awal     : ");

 scanf("%lf", &x[0]);

 printf("Masukan nilai akhir    : ");

 scanf("%lf", &x[1]);

 printf("Masukan nilai error    : ");

 scanf("%lf", &e);

 printf("Masukan jumlah iterasi : ");

 scanf("%d", &n);

 puts(" no    x\t     fx         absolut fx");

 while(i<=(n-1)){

  fx[i] = fungsix(x[i]);

  fx[i+1] = fungsix(x[i+1]);

  x[i+2] = x[i+1] - fx[i+1] * (x[i+1] - x[i]) / (fx[i+1] - fx[i]);

  fx[i+2] = fungsix(x[i+2]);

  abso[i] = fx[i+2];

  if (fx[i+2] < 0 )

   abso[i] *=-1;

  printf("%3d  %9lf  %15.9lf %9lf\n",i+1,x[i+2], fx[i+2], abso[i]);

  if ( abso[i] < e )

   break;

  i++;

 }

}

double fungsix (double a){

 double hasil;

 hasil = a*a - (a+1)*(exp(-a));

 return hasil;

}

3. Hasil iterasi

                         x                       fx                      absolut fx

Iterasi ke 1 : 0.790988          -0.186365200             0.186365

Iterasi ke 2 : 0.877433          -0.010840048             0.010840

Iterasi ke 3 : 0.882772           0.000505707             0.000506

Iterasi ke 4 : 0.882534          -0.000001244             0.000001

4. Hasil akhir

x = 0.882534

NAMA : ADE SUMOKO

NIM    : D1042131030

Program untuk mencari akar persamaan suku banyak menggunakan metode secant

1. Persamaan yang dicari
    Persamaan yang dicari akarnya adalah 4x^3 - 15x^2 + 17x - 6 = 0
    dengan tebakan awal -1 dan 3 dan nilai error 0.00001

2. Code Program (Bahasa C)

/*mencari akar persamaan dari persamaan 4x^3 - 15x^2 + 17x - 6 = 0*/

#include<stdio.h>
#include<math.h>

double power(double, int);
double value(double);
double calculate(double, double);

main()
{
    double x1, x2, e;
    int it;
    printf ("Input First Guess      : ");
    scanf ("%lf", &x1);
    printf ("Input Second Guess     : ");
    scanf ("%lf", &x2);
    printf ("Input Error Value      : ");
    scanf ("%lf", &e);
    printf ("Input Total Iteration  : ");
    scanf ("%i", &it);

    int i=1;
    double xt, fxt=1.0000;

    printf("\n");
    printf ("+------------+--------+--------+--------+-----------+\n");
    printf ("|Iterasi ke- |   xl   |   xb   |   xt   |  |f(xt)|  |\n");
    printf ("+------------+--------+--------+--------+-----------+\n");

    for (i=1;(i<it) && (fxt>e);i++)
    {
        xt = calculate(x1, x2);
        printf ("|     %3i    |%8.4lf|%8.4lf|%8.4lf|%11.6lf|\n", i, x1, x2, xt, cabs(value(xt)));
        fxt = cabs(value(xt));

        x1=x2;
        x2=xt;

    }
    printf ("+------------+--------+--------+--------+-----------+\n");
}

double power(double number, int power)
{
    double result = 1.00;

    if (power == 0.0)
    {
        return result;
    }

    int i;

    for (i = 1; i <= power; i++)
    {
        result *=number;
    }

    return result;
}

double value(double x)
{
    return ((4*(power(x,3))) - (15*(power(x,2))) + 17*x - 6);
}

double calculate(double xl, double xb)
{
    return (xb - ((xb-xl)/(value(xb)-value(xl)))*value(xb));
}


3. Hasil Iterasi

 

4. Hasil Akhir
X = 2

Nama : Richart Mevil Adhitya
NIM : D1042131008

Program mencari akar-akar persamaan suku banyak (metoda secant)

1.Persamaan yang dicari 5x^4 - 20x^3 + 12x^2 - 3 = 0


2.Code program:
         
#include<stdio.h>
#include<math.h>

double power(double, int);
double value(double);
double calculate(double, double);

main()
{
    double x1, x2, e;
    int it;
    printf ("Tebakan pertama     : ");
    scanf ("%lf", &x1);
    printf ("Tebakan kedua       : ");
    scanf ("%lf", &x2);
    printf ("Masukan eror        : ");
    scanf ("%lf", &e);
    printf ("Berapa kali iterasi : ");
    scanf ("%i", &it);
    printf ("%lf",e);

    int i=1;
    double xt, fxt;

    printf("\n");
    printf ("Iterasi ke-    xl      xb    xt        |f(xt)|  \n");
    for (i=1;i<it;i++)
    {
        xt = calculate(x1, x2);
        printf ("  %3i     %8.4lf%8.4lf %8.4lf %11.6lf \n", i, x1, x2, xt, cabs(value(xt)));
        fxt = cabs(value(xt));

        x1=x2;
        x2=xt;

    }

}

double power(double number, int power)
{
    double result = 1.00;

    if (power == 0.0)
    {
        return result;
    }

    int i;

    for (i = 1; i <= power; i++)
    {
        result *=number;
    }

    return result;
}

double value(double x)
{
    return ((5*(power(x,4))) - (20*(power(x,3))) + 12*(power(x,2))- 3);
}

double calculate(double xl, double xb)
{
    return (xb - ((xb-xl)/(value(xb)-value(xl)))*value(xb));
}


3.Hasil iterasi:




4.Hasil akhir:
   iterasi ke-12 -0.3834 seperti pada gambar diatas.




Nama  :   Doni Harianto
Nim    :  D1042131028