Minggu, 15 Mei 2011

METODE NEWTON RAPHSON

Diposkan oleh youhanez.blogspot.com di 21:50


Algoritma Metode Newton Raphson:
  1. Definisikan fungsi f(x) dan f1(x)
  2. Tentukan toleransi error (e) dan iterasi maksimum (n)
  3. Tentukan nilai pendekatan awal x0
  4. Hitung f(x0) dan f’(x0)
  5. Untuk iterasi I = 1 s/d n atau |f(xi)|> e
R  Hitung f(xi) dan f1(xi)
R  Akar persamaan adalah nilai xi yang terakhir diperoleh.



1.      Program menghitung nilai x dari persamaan f(x) : x2 + 3x – 10 dengan menggunakan metode Newton Rapshon.

Deksripsi :
            Metode Newton Rapshon menggunakan formula atau algoritma untuk mendapatkan nilai x maka :
*. x[n+1] = x[n] – f(x)/f`(x)
*.  Parameter awal x diinput dan nilai e = 0.0005
*.  f(x) = fungsi persamaan x2 + 3x – 10 = 0, maka x = 2 atau x = -5, jadi kita menginputkan bilangan x awal apabila mendekati 2 maka hasil x akhir = 3, dan apabila mendekati = -5 maka hasil x akhir = 5
*.  f`(x) = fungsi turunan pertama f(x) 2x + 3
*.  nilai e = 0.0005
*.  kondisi dimana perulangan berhenti nilai mutlak (Absolute) |x[n+1] – x[n]| < e, dimana hasil x[n] = x.

a. Listing Program
#include <stdio.h>
#include <math.h>
#include <conio.h>


float Fungsi(float x);
float FungsiTurunan(float x);

main()
{
      int n=0;
   float x[100];
   float e = 0.0005;
   printf("           Program Newton Rapshon         \n");
   printf("           ======================         \n\n");
   printf("Persamaan Fungsi f(x) : \n");
   printf("     x*x + 3x - 10         \n\n");
   printf("x(n+1)                : \n");
   printf("     x(n)-(f(xn)/f'(xn))     \n\n");
   printf("Nilai e = 0.0005\n\n");


   printf("Masukkan nilai x Awal : "); scanf("%f",&x[0]);

   printf("==================================================================\n");
   printf("!  n  !    xn     !   f(xn)   !  f'(xn)  ! f(xn)/f'(xn) ! x(n+1) !\n");
   printf("==================================================================\n");

   do
   {
   x[n+1] = x[n] - (Fungsi(x[n])/FungsiTurunan(x[n]));
   printf("!  %d  !  %2.4f   !   %2.4f  !  %2.4f  !    %2.4f    ! %2.4f !\n", n, x[n],Fungsi(x[n]), FungsiTurunan(x[n]),Fungsi(x[n])/FungsiTurunan(x[n]),x[n+1]);
   n++;
   }while(abs(x[n-1]-x[n-2])>e);
   printf("!  %d  !  %2.4f   !   %2.4f  !  %2.4f  !    %2.4f    ! %2.4f !\n", n, x[n],Fungsi(x[n]), FungsiTurunan(x[n]),Fungsi(x[n])/FungsiTurunan(x[n]),x[n+1]);
   printf("==================================================================\n\n");
   printf("Jadi, Hasil yang memenuhi dari persamaan tersebut x = %2.4f", x[n]);
   getch();
}

float Fungsi(float x)
{
      return pow(x,2)+(3*x)-10;
}

float FungsiTurunan(float x)
{
      return 2*x+3;
}







b. Output Program
Jika x awal = 2.5

Jika x awal = -5.5

Read more...
Diposting oleh Eko Avangedsevenfold di 19.55 0 komentar

METODE REGULA FALSI (Posisi Palsu)

Diposkan oleh youhanez.blogspot.com di 21:42

Seperti metode pembelahan, metode posisi palsu dimulai dengan dua titik a 0 dan b 0 sedemikian sehingga f (a 0) dan f (b 0) adalah tanda yang berlawanan, yang berarti dengan teorema nilai antara bahwa fungsi f memiliki akar dalam interval [a 0, b 0], dengan asumsi kontinuitas fungsi f.. Metode hasil dengan memproduksi suatu urutan menyusut interval [a k, k b] yang semuanya mengandung akar dari f.
Pada k  nomor iterasi, jumlahnya:
c_k = \ frac {f (b_k) a_k-f (a_k) b_k} {f (b_k)-f (a_k)}
Seperti yang dijelaskan di bawah ini, k c adalah akar dari garis sekan melalui (k, f (k a)) dan (b k, f (b k)). . Jika f (k a) dan f (c k) memiliki tanda yang sama, maka kita menetapkan suatu k +1 = c k dan b k k +1 = b, jika kita menetapkan a k +1 = b k dan k + 1 = k c. Proses ini diulang sampai akar adalah cukup didekati dengan baik.
Rumus di atas juga digunakan dalam metode sekan, tapi metode sekan selalu mempertahankan dua poin terakhir dihitung, sedangkan metode posisi palsu mempertahankan dua titik yang tentunya bracket akar. Di sisi lain, satu-satunya perbedaan antara metode posisi palsu dan metode pembelahan adalah bahwa yang kedua menggunakan k c = (a k + k b) / 2.

Mencari akar dari garis potong.

220px-False_position_method.svg.png

Diberikan a dan b k k, kita mengkonstruksi line melalui titik (k, f (k a)) dan (b k, f (b k)), seperti yang ditunjukkan pada gambar di  atas. Perhatikan bahwa garis tersebut adalah garis potong atau akord dari grafik fungsi f. Dalam bentuk titik-lereng , hal itu dapat didefinisikan sebagai:
y - f (b_k) = \ frac {f (b_k)-f (a_k)} {b_k-a_k} (x-b_k).
Kita sekarang memilih k c menjadi akar dari garis ini, jadi c dipilih sedemikian sehingga
f (b_k) + \ frac {f (b_k)-f (a_k)} {b_k-a_k} (c_k-b_k) = 0.
 Penyelesaian persamaan ini memberikan persamaan di atas untuk k c.

Analisis.
Jika akhir titik awal a 0 dan b 0 dipilih sedemikian sehingga f (a 0) dan f (b 0) adalah tanda yang berlawanan, maka salah satu-titik akhir akan berkumpul ke akar f. Asimtotik, pada titik akhir-lain akan tetap tetap untuk semua iterasi mendatang, sementara titik akhir konvergensi menjadi diperbarui. Akibatnya, tidak seperti metode pembelahan , lebar braket tidak cenderung nol. Sebagai konsekuensinya, pendekatan linier untuk f (x), yang digunakan untuk memilih posisi palsu, tidak meningkatkan kualitas.
Salah satu contoh dari fenomena ini adalah fungsi :
f ( x ) = 2 x 3 − 4 x 2 + 3 x f (x) = 2 x 3 - 4 x 2 + 3 x
pada braket awal [-1,1]. Ujung kiri, -1, tidak pernah diganti dan dengan demikian lebar braket tidak pernah turun di bawah 1. Oleh karena itu, titik akhir kanan mendekati 0 pada laju linear (dengan laju konvergensi dari 2 / 3).
Meskipun kesalahpahaman untuk berpikir bahwa metode posisi palsu adalah metode yang bagus, adalah sama kesalahan untuk berpikir bahwa itu adalah unsalvageable. Modus kegagalan adalah mudah untuk mendeteksi (akhir titik-sama masih dipertahankan dua kali berturut-turut) dan mudah diatasi dengan berikutnya memilih posisi palsu dimodifikasi, seperti :
c_k = \ frac {\ frac {1} {2} f (b_k) a_k-f (a_k) b_k} {\ frac {1} {2} f (b_k)-f (a_k)}
 atau
c_k = \ frac {f (b_k) a_k-\ frac {1} {2} f (a_k) b_k} {f (b_k) - \ frac {1} {2} f (a_k)}
turunan-bobot salah satu titik akhir nilai untuk memaksa k c berikutnya terjadi pada sisi fungsi. Faktor dari 2 di atas terlihat seperti hack, tetapi menjamin konvergensi superlinear (asimtotik, algoritma akan melakukan dua langkah biasa setelah setiap langkah dimodifikasi). Ada cara lain untuk memilih rescaling yang memberikan tingkat konvergensi yang lebih baik superlinear.
Penyesuaian atas, dan modifikasi sejenis lainnya untuk PERATURAN Falsi disebut Algoritma Illinois. Ford (1995) merangkum dan menganalisa varian superlinear metode modifikasi dari posisi palsu. Dilihat dari bibliografi, PERATURAN dimodifikasi metode falsi yang terkenal di tahun 1970-an dan telah kemudian lupa atau misremembered dalam buku pelajaran saat ini.

CONTOH KODE PROGRAMNYA MENGGUNAKAN C++:
# Include <stdio.h>
# Include <math.h> 
  
double f( double x) 
{ 
    return cos(x) - x*x*x; 
} 
 
FalsiMethod ganda (double s, double t, double e, int m)
{ 
    int n,side=0; 
    double r,fr,fs = f(s),ft = f(t); 
    untuk (n = 1; <n = m; n + +)
    { 
        r = (fs*t - ft*s) / (fs - ft); 
        if (fabs(ts) < e*fabs(t+s)) break ; 
        fr = f (r);
        if (fr * ft > 0) 
        { 
           t = r; ft = fr; 
           jika (sisi ==- 1) fs / = 2;
           sisi = -1;
         }
        else if (fs * fr > 0) 
        { 
          s = r; fs = fr;
          if (== sisi +1) ft / = 2;
          side = +1;
         }
        lain break;
     }
    return r; return r;
}
int main( void ) 
{ 
    printf ("% 0.15f \ n", FalsiMethod (0, 1, 5E-15, 100));
    return 0; return 0;
} 
 
 
Setelah menjalankan kode di atas, jawaban akhir adalah sekitar 0,8654740331016
Read more...
Diposting oleh Eko Avangedsevenfold di 19.51 0 komentar
Langganan: Postingan (Atom)