Untuk mencari akar pada sistem persamaan non-linier, bisa digunakan 4 buah metode, yaitu Metode Bagi Dua (Bisection), Metode Posisi Palsu (Regula Falsi), Metode Newton-Raphson, dan Metode Tali Busur (Secant). Di bawah ini adalah penjelasan singkat mengenai metode-metode tersebut berikut algoritma pascal-nya.

1. Metode Bagi Dua (Bisection)

Metode bagi dua (bisection) merupakan salah satu metoda pencarian akar tipe pengurung pada persamaan tak-linier. Suatu fungsi f(x) yang kontinu terhadap akar r ditentukan 2 buah titik awal a0 dan b0 yang nilai fungsinya berlainan tanda sebagai tebakan awal. Lalu, Kita tetapkan titik tengah dari interval kedua titik tersebut dengan 3 kemungkinan:

a. f(c)= 0, artinya titik c merupakan akar f(x).

b. f(a)f(c)< 0, artinya akar berada pada interval [a,c].

c. f(b)f(c)< 0, artinya akar berada pada interval [c,b].

apabila kasus b dan c terjadi maka interval pengapit akar tersebut dinamakan sebagai a dan b baru. Lakukan iterasi kembali hingga criteria penghentian iterasi dan kita akan mendapatkan nilai akar dari fungsi f(x).

contoh :

carilah akar dari f (t) := t5 -7 dengan melakukan iterasi sampai galatnya ɛ ≤ 10-4 !

program bisection_method;

var
    xa,xb  : real;    {tebakan awal}
    xrnew  : real;    {titik tengah}
    xrold  : real;    {tebakan awal untuk menghitung error relatif}
    eps    : real;    {kriteria pemberhentian iterasi}
    i      : integer;

function f(t : real):real;    {membuat fungsi f(t) agar bisa digunakan berulang2}
begin
    f:= t*t*t*t*t-7;
end;

begin
     i:=0;              {inisialisasi untuk proses iterasi}
     write('this is the roots seeker using bisection method');
     writeln;
     writeln;
     write('xa= ');readln(xa); {input batas pertama}
     writeln;
     writeln;
     write('xb= ');readln(xb);  {input batas kedua}
     writeln;
     xrold:= 2*xb-xa;
     {tebakan awal untuk menghitung error relatif (membuat titik tengah awal)}
     if (f(xb)*f(xa)>0) or (f(xb) = f(xa)) then
     {apabila f(a)*f(b)>0 atau f(a) = f(b), program error}
        begin
            writeln ('Wrong Interval!');
        end
     else
      begin
        eps := 1;
        while eps>10E-5 do      {iterasi berhenti apabila error relatif <10E-4  }
        begin
         xrnew:=(xb+xa)/2;    {titik tengah c didapat dari rumus c=(a+b)/2}
         if f(xrnew)*f(xa)< 0 then xb:=xrnew;
         {apabila f(c)*f(a)< 0 maka a baru=a,b baru=c}
         if f(xrnew)*f(xb)< 0 then xa:=xrnew;
         {apabila f(c)*f(b)< 0 maka a baru=c,b baru=b}

         eps:=abs((xrnew-xrold)/(xrnew));   {error relatif = |(c-xrold)/c|}
         i:=i+1;        {proses iterasi}
         write('iteration |'); writeln('epsilon');
         write(i,'         |'); writeln(eps:5:9); {output error relatif}
         xrold:=xrnew; {nilai sebelumnya diganti dengan nilai c yang baru}
        end;
        writeln;
        writeln('we are seeking the root with 10^-4 as it epsilon');
        write('the root is ',xrnew:5:9);   {output hasil akar dari fungsi}
      end;
     readln;
     readln;
end.

hasil eksekusi pada pascal :


2. Metode Posisi Palsu (Regula Falsi)

Metode posisi palsu (regula falsi) termasuk tipe metode pengurung. Metode ini dikembangkan dengan harapan bisa mencapai kekonvergenan dengan cepat. Seperti metode bagi-dua, metode posisi palsu dimulai dengan dua titik awal a0 dan b0 sedemikian sehingga f(a0) dan f(b0) berlawanan tanda. Metode ini kemudian berlanjut dengan menghasilkan berturut-turut selang [ak, bk] yang semuanya berisi akar f. Nilai c didapat dari iterasi

c = b – f(b) ((b-a)/(f(b)- f(a))

Seperti yang diterangkan sebelumnya, c adalah akar dari garis melalui (a, f(a)) dan (b, f(b)). Jika f(a) dan f(c) memiliki tanda yang sama, maka kita menetapkan abaru = c dan bbaru = b. Jika tidak, kita menetapkan abaru = a dan bbaru = c. Proses ini diteruskan hingga akar dihampiri dengan cukup baik.

contoh :

carilah akar dari f (t) := t5 -7 dengan melakukan iterasi sampai galatnya ɛ ≤ 10-4 !


program regula_falsi;

var
    xa,xb  : real;    {tebakan awal}
    xrnew  : real;    {titik tengah}
    xrold  : real;    {tebakan awal untuk menghitung error relatif}
    eps    : real;    {kriteria pemberhentian iterasi}
    i      : integer;

function f(t : real) : real;        {membuat fungsi f(t) agar bisa digunakan berulang2}
begin
    f:= t*t*t*t*t-7;
end;

begin
     i:=0;                          {inisialisasi untuk proses iterasi}
     write('this is the roots seeker using bisection method');
     writeln;
     writeln;
     write('xa= ');readln(xa);      {input batas pertama}
     writeln;
     writeln;
     write('xb= ');readln(xb);      {input batas kedua}
     writeln;
      xrold:= 2*xb-xa; {tebakan awal untuk menghitung error relatif}
     if (f(xb)*f(xa)>0) or (f(xb) = f(xa)) then
     {apabila f(a)*f(b)>0 atau f(a) = f(b), program error}
        begin
            writeln ('Wrong Interval!');
        end
     else
        begin
          eps := 1;
          while eps>10E-5 do     {iterasi berhenti apabila error relatif <10E-4  }
          begin
             xrnew:=xb-((f(xb)*(xb-xa))/(f(xb)-f(xa)));
             {titik potong c di garis x}
             if f(xrnew)*f(xa)< 0 then xb:=xrnew;
             {apabila f(c)*f(a)< 0 maka a baru=a,b baru=c}
             if f(xrnew)*f(xb)< 0 then xa:=xrnew;
             {apabila f(c)*f(b)< 0 maka a baru=c,b baru=b}

             eps:=abs((xrnew-xrold)/(xrnew));   {error relatif = |(c-xrold)/c|}
             i:=i+1;     {proses iterasi}
             write('iteration |'); writeln('epsilon');
             write(i,'         |'); writeln(eps:5:9); {output error relatif}
             xrold:=xrnew; {nilai sebelumnya diganti dengan nilai c yang baru}
          end;
          writeln;
          writeln('we are seeking the root with 10^-4 as it epsilon');
          write('the root is ',xrnew:5:9);   {output hasil akar dari fungsi}
        end;
     readln;
     readln;
end.

hasil eksekusi program algoritma pada pascal :


3. Metode Newton-Raphson

Metode Newton-Raphson merupakan salah satu metode terbuka untuk menemukan akar dari persamaan tak-linier. Hal pertama yang dilakukan pada metode ini adalah menentukan tebakan awal x0 yang cukup dekat dengan akar yang sebenarnya.  Lalu, kita hampiri fungsi dengan garis singgung. Garis ini akan memotong di sumbu-x. Misalkan ƒ : [ab] → R adalah fungsi yang dapat diturunkan dengan hasil bilangan riil R. Dari hasil perpotongan garis singgung dan sumbu-x didapat x1, kita bisa mendapatkannya dari rumus

x1= x0 – f(x0)/f’(x0)

ƒ’(x0) merupakan turunan dari ƒ(x0). Metode ini biasanya akan mendekati nilai akar dengan syarat tebakan awal cukup dekat pada akar tersebut, dan ƒ’(x0) ≠ 0. iterasi dilakukan sampai kriteria pemberhentian.

 

Contoh :

carilah akar dari f (t) := t5 -7 dengan melakukan iterasi sampai galatnya ɛ ≤ 10-4 !


program newton_raphson;

var
   x0       : real;   {tebakan awal yang denkat dengan akar}
   x1       : real;   {nilai tebakan untuk menghitung error relatif}
   eps      : real;   {kriteria pemberhentian iterasi}
   i        : integer;

function f (t : real) : real;  {membuat fungsi f(t) agar bisa digunakan berulang2}
begin
   f:= t*t*t*t*t-7;
end;

function fd (t : real) : real;   {membuat turunan dari fungsi f(t)}
begin
   fd:= 5*t*t*t*t;
end;

begin
    x1:=0;      {inisialisasi untuk nilai tebakan awal untuk perhitungan error relatif}
    i:=0;       {inisialisasi untuk proses iterasi}
    writeln ('this is the roots seeker using newton rhapson method');
    writeln;
    write ('x0= '); readln (x0);    {input tebakan awal yang dekat dg akar}
    writeln;
    eps := 1;
    if (abs(fd(x0))<10E-12) then    {nilai turunan tidak boleh mendekati nol}
      begin
        writeln ('The function derivative at that point close to zero!’);
      end
    else
      begin
       while eps>10E-5 do {iterasi berhenti apabila error relatif <10E-4  }
       begin
         x1:= x0 - (f(x0)/fd(x0));
         {titik perpotongan di sumbu-x dengan garis singgung fungsi}
         eps := abs ((x1-x0)/(x1)); {error relatif = |(x1-x0)/x1|}
         i := i+1;                  {proses iterasi}
         write ('iteration |'); writeln ('epsilon');
         write (i,'         |'); writeln(eps:5:9);  {output error relatif}
         x0:=x1;    {nilai sebelumnya diganti dengan nilai c yang baru}
       end;
       writeln;
       writeln ('we are seeking the root with 10^-4 as its epsilon');
       write ('the root is ',x1:5:9);         {output hasil akar dari fungsi}
      end;
    readln;
   readln;
end. 

4. Metode Tali Busur (Secant)

Metode ini dikembangkan dari metode Newton-Raphson. Berbeda dengan metode Newton-Raphson, metode ini menghilangkan fungsi turunan pada proses iterasinya dan mengganti dengan hampiran turunannya yang mudah dihitung. Untuk h yang kecil x = xn , dan h = xn-1 – xn, maka akan diperoleh :

f’(x)= lim (f(x+h)-f(x))/h ~ (f(x+h)-f(x))/h ~ (f(xn-1)-f(xn))/(xx-1 – xn)

Apabila rumus di atas disubstitusikan ke dalam persamaan metode Newton-Raphson maka akan diperoleh metode secant

xn+1 = xn – f(xn) (xn-1 – xn)/ (f (xn-1)-f(xn))

Contoh :

carilah akar dari f (t) := t5 -7 dengan melakukan iterasi sampai galatnya ɛ ≤ 10-4 !


program secant;

var
   x0, x1  : real;  {titik tebakan awal x0 dan x1}
   x2      : real;  {titik potong sumbu-x dengan garis perpanjangan x0 dan x1}
   xrold   : real;  {nilai tebakan awal untuk menghitung error relatif}
   eps     : real;  {kriteria pemberhentian iterasi}
   i       : integer;

function f (t : real) : real;
{membuat fungsi f(t) agar bisa digunakan berulang2}
begin
   f:= t*t*t*t*t-7;
end;

begin
    i := 0;     {inisialisasi untuk proses iterasi}
    writeln ('this is the roots seeker using secant method');
    writeln;
    write ('x0= '); readln (x0);  {input tebakan awal x0}
    writeln;
    writeln;
    write ('x1= '); readln(x1);   {input tebakan awal x1}
    writeln;
    xrold := 2*x1-x0;
    {nilai tebakan awal untuk menhitung error relatif}
    eps := 1;
    if  (abs ((f(x1)-f(x0)/(x1-x0))) < 10E-12) then
    {garis perpanjangan titik x0 dan x1 harus berpotongan dengan sumbu-x}
     begin
       writeln ('the line extension between that two points don’t cut the x-axis’);
     end
    else
     begin
       while eps>10E-5 do
       {iterasi berhenti apabila error relatif <10E-4  }
       begin
        x2 := x1-((f(x1)*(x1-x0))/(f(x1)-f(x0)));
       {titik perpotongan di sumbu-x dengan garis perpanjangan titik x0 dan x1}
        x0 := x1;
        x1 := x2;
        eps := abs((x2-xrold)/(x2)); {error relatif = |(x2-xrold)/x2|}
        i := i+1;                    {proses iterasi}
        write ('iteration |'); writeln('epsilon');     {output error relatif}
        write (i,'         |');writeln(eps:5:9);
        xrold := x2;    {nilai sebelumnya diganti dengan nilai c yang baru}
       end;
     writeln;
     writeln ('we are seeking the root with 10^-4 as its epsilon');
     write ('the root is ',x2:5:9);          {output hasil akar dari fungsi}
     end;
    readln;
    readln;
end.

hasil eksekusi pada pascal :


Semoga bermanfaat..

salam cHadsquarepants

About these ads