Komputasi teknik dengan menggunakan Perangkat lunak...

Komputasi teknik dengan menggunakan Perangkat lunak Matlab

Oleh : Ir. M.Syahril Gultom, MT

Staf Pengajar Departemen Teknik Mesin FT USU

DEPARTEMEN TEKNIK MESIN

FAKULTAS TEKNIK UNIVERSITAS SUMATERA UTARA

2007

M. Syahril Gultom : Komputasi Teknik dengan Menggunakan Perangkat Lunak Matlab, 2007 USU Repository © 2007

Komputasi teknik dengan menggunakan Perangkat lunak Matlab

Oleh :

Ir. M.Syahril Gultom, MT Staf Pengajar Departemen Teknik Mesin FT USU

P e n d a h u l u a n

Mana kala suatu persoalan yang diselesaikan secara matematis analitis tidak lagi

mampu ataupun menjadi begitu sulit diperoleh penyelesaiannya, maka analisa

numerik menjadi alternatif pemecahan yang mudah diterapkan dengan kemampuan

processing komputer berkecepatan tinggi saat ini .

Dalam hal yang menyangkut komputasi teknik tidak sedikit kasus kasus yg ditemui

ketika dalam pemodelan matematisnya telah dibentuk , ternyata tidak dapat

diselesaikan secara teknik analitis, ataupun terbentur dengan proses penyelesaian yg

rumit dan berbelit belit.

Pemodelan matematis pada kasus kasus keteknikan yang identik dengan bentuk

suatu fungsi yangg ingin dicari nilai akarnya yang mewakili besaran tertentu dari

masalah keteknikan akan menjadi mudah dengan pemanfaatan metode metode

numerik yang sudah dikenal .

Disini, dipaparkan teknik iterasi dan aplikasi dengan menggunakan prangkat lunak

Matlab dalam kasus menentukan akar akar persamaan dari suatu fungsi .

Dengan menggunakan metode Newton – Rhapson dan metode Secant dalam

penentuan akar akar dari suatu fungsi , perogam dilaksanakan pada sejumlah

perhitungan secara iteratif dalam memperoleh hasil pendekatan (aproksimasi)

terhadap nilai eksas dari akar akar fungsi yang dipecahkan .


A p l i k a s i M a t l a b

Teknik iterasi digunakan untuk mendapatkan pemecahan dari persamaan-

persamaan. Formula yang memberikan jawaban nilai numerik yang eksak terhadap

sebuah persamaan hanya ada pada kondisi yang sangat sederhana. Pada umumnya,

kita harus menggunakan pendekatan (aproksimasi). Metode iterasi dimulai dengan

sebuah nilai inisial (initial guess) (yang nilainya mungkin kurang tepat) dan

kemudian menghitung setahap-demi-setahap untuk mendekati (secara umum nilai

ini kemudian menjadi lebih baik dan lebih baik) sebuah solusi yang tidak diketahui

dari sebuah persamaan.

M-file : approot.m

Menggunakan algoritma iterasi yang sederhana yang di usulkan pada tahun 1999

oleh John H. Mathews dan Kurtis D. Fink (NUMERICAL METHODS Using

MATLAB). Kode matlab yang ditampilkan ini telah di perbaiki untuk memberikan

kemudahan bagi komputasi teknik. Algoritma ini bertujuan meng-evaluasi sebuah

vektor dari perkiraan lokasi akar dari sebuah fungsi f yang disimpan di dalam *.m

file yang berbeda. Dalam hal ini , diperkenankan untuk merubah fungsi dan

melakukan pendekatan (perkiraan) akar-akar fungsi tersebut.

% Input - f adalah object function disimpan di dalam M-file f.m

% - X adalah vector dari abscissas

% - epsilon adalah tolerance

% Output - R adalah vector perkiraan lokasi akar-akar fungsi

while 1

clear, clf,clc

fprintf( '\n===========================================\n' );

fprintf( ' Approximative Root Method \n' );

i = 1;

fprintf( '** Give the X abscissa values:\n');


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/approot.m

while 1

km = input( '' );

X(i) = km;

i=i+1;

kont = input( 'Type 1 to continue, or 0 to stop adding X values: ' );

if kont == 0, break; end

end

while 1

fprintf( '\n Input the tolerance value, epsilon = ')

epsilon = input('');

if epsilon < 1 & epsilon > 0; break; end

fprintf( ' \n Epsilon should be greater than 0 and less than 1!!! ')

fprintf( ' \n Repeat your input for tolerance value! ')

end

Y=f_test(X);

axes;

plot(X,Y,'r-o');

centaxes

yrange = max(Y)-min(Y);

epsilon2 = yrange*epsilon;

n=length(X);

m=0;

X(n+1)=X(n);

Y(n+1)=Y(n); for k=2:n,

if Y(k-1)*Y(k) <= 0,

m=m+1;

R(m)=(X(k-1)+X(k))/2;

end


s=(Y(k)-Y(k-1))*(Y(k+1)-Y(k));

if (abs(Y(k)) < epsilon2) & (s <= 0),

m=m+1;

R(m)=X(k);

end

end

fprintf(' The solutions are: \n');

if length(R) ~= 0

for k=1:length(R),

fprintf(' R(%u) = %6.2f \n', k, R(k));

end

else

fprintf(' No root values! ')

end

fprintf('\n============================================')

kont = input( 'Type 1 to continue, or 0 to stop: ' );


end


Kita gunakan fungsi f berikut sebagai contoh : f(x) = x3 + x2 - 1.25x - 0.75 . Gambar

yang dihasilkan dari algoritma diberikan dibawah ini :

Nilai-nilai perkiraan abscissas dimana fungsi f(x) mendekati X – axis adalah sebagai

berikut (R adalah vector dimana mereka disimpan):

R(1) = -1.75

R(2) = -1.25

R(3) = -1.00

R(4) = -0.75

R(5) = -0.25

R(6) = 0.75

R(7) = 1.25


Nilai diatas tidak berarti bahwa fungsi f(x) memiliki 7 akar. Algoritma menemukan

di koordinat-koordinat mana fungsi f(x) yang diberikan dengan titik-titik abscissa X

berikut : X0 = -3, X1 = -2.5, X2 = -2, X3 = -1.5, X4 = -1, X5 = -0.5, X6 = 0, X7 = 0.5, X8 =

1, X9 = 1.5, X10 = 2, X11 = 2.5, X12 = 3, X13 = 3.5 dengan toleransi epsilon = 0.01

M-file : secant_alg.m

Kemudian kita uji algoritma iterasi Secant. Kode Matlab dari algoritma yang

dipakai diperbaiki dari "NUMERICAL METHODS Using MATLAB" oleh John H.

Mathews dan Kurtis D. Fink. Kode matlab tersebut adalah sebagai berikut:

%function [p1,err,k,y]=secant(f,p0,p1,delta,epsilon,max1)

%Input - f is the object function input as a string 'f'

% - p0 and p1 are the initial approximations to a zero of f

% - delta is the tolerance for p1

% - epsilon is the tolerance for the function values y

% - max1 is the maximum number of iterations

%Output - p1 is the secant method approximation to the zero

% - err is the error estimate for p1

% - k is the number of iterations

% - y is the function value f(p1)

while 1

clear, clf,clc

fprintf( '\n============================================\n' );

fprintf( ' Secant Method \n' );

while 1

fprintf( ' \n The absciss extremes a and b (a < b)')

fprintf( ' \n a = '); a = input('');

fprintf( ' b = '); b = input('');

if a < b; break; end


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/secant_alg.m

fprintf( ' \n a should be less than b! ')

fprintf( ' \n Repeat your input for a and b! ')

end

fprintf( ' \n Now the function is plotted \n')

x=a:0.1:b;

f = feval('f306',x);

plot(x, f, 'b-');

centaxes

hold on;

fprintf( '** Give the Po, first initial abscissa value approximation to a zero of f:\n');

p0 = input('Initial approximation Po = ');

fprintf( '** Give the P1, second initial abscissa value approximation to a zero of f:\n');

p1 = input('Initial approximation P1 = ');

while 1

fprintf( '\n Input the tolerance value for P1, delta = ')

delta = input('');

if delta < 1 & delta > 0; break; end

fprintf( ' \n Delta should be greater than 0 and less than 1!!! ')


end

while 1

fprintf( '\n Input the tolerance value for the function Y values, epsilon = ')





end


while 1

fprintf( '\n Input the maximum number of iterations, N_max = ')

max1 = input('');

if max1 > 1; break; end

fprintf( ' \n The number of iterations should be greater than 1!!! ')

fprintf( ' \n Repeat your input for the number of iterations value! ')

end

% inisial dari fungsi secant

for k=1:max1

p2=p1-feval('f306',p1)*(p1-p0)/(feval('f306',p1)-feval('f306',p0));

err=abs(p2-p1);

relerr=2*err/(abs(p2)+delta);

p0=p1;

p1=p2;

y=feval('f306',p1);

if (err<delta)|(relerr<delta)|(abs(y)<epsilon),break,end

end

fprintf('\n==============RESULTS================')

fprintf('\n P1 is the Secant approximation to zero = %12.6f', p1);

fprintf('\n Err is the error estimate for P1 = %12.6f', err);

fprintf('\n K is the number of iterations = %u', k);

fprintf('\n Y is the function value f(P1) = %12.6f', y);

fprintf('\n============================================')

kont1 = input( 'Type 1 to continue, or 0 to stop: ' );

if kont1 == 0, break; end

end


Penjelasan dari bebeapa variable input yang diberikan ke dalam algoritma Secant

dapat dibaca pada bagian comments pada awal dari kode matlab diatas. Kemudian,

algoritma dijalankan untuk contoh fungsi berikut: f(x) = x-cos(x) yang terdapat pada

f306.m. (isi m-file f306.m adalah :

function fv=f306(x);

fv=x-cos(x);

Fungsi tersebut diberikan untuk interval a = -10, b = 10 dan terlihat seperti dibawah

ini :


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/f306.m

Parameter-parameter input yang lain adalah: P0 = -1.67, P1 = -2.21, delta = 0.002,

epsilon = 0.012, N_max = 100 dan hasilnya diambil dari (command) Matlab window:

P1 is the Secant approximation to zero = 0.737000

Err is the error estimate for P1 = 0.064575

K is the number of iterations = 5

Y is the function value f(P1) = -0.003488

Inisial dari Fungsi Secant terlihat pada kode diatas sebagai berikut :

for k=1:max1

p2=p1-feval('f306',p1)*(p1-p0)/(feval('f306',p1)-feval('f306',p0));

err=abs(p2-p1);


p0=p1;

p1=p2;

y=feval('f306',p1);


end

M-file : newt_n.m

Metode iterasi yang ditelaah berikutnya adalah Newton. Kode matlab dikembangkan

dari kode yang ditulis oleh Nakamura. Algoritma dijalankan untuk fungsi yang

sama: f(x) = x-cos(x) yang diberikan dalam f306.m. Kode lain dari fungsi Newton di

berikan didalam fnewton.m.

% Newt_n(f_name, x0) finds a root of a function by

% Newton iteration


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/newt_n.m

http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/f306.m

http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/fnewton.m

% f_name: the function name that defines the equation

% to solve

% x0: an initial guess.

% improved after Copyright S. Nakamura, 1995

% function x = Newt_n(f_name, x0)

while 1

clear, clf,clc

fprintf( '\n============================================\n' );

fprintf( ' Newton Iteration Method (without graphics) \n' );

fprintf( '** Give the Xo abscissa value approximation:\n');

x0 = input('Initial guess Xo = ');

x = x0; xb=x-999;

n=0; del_x = 0.01;

while abs(x-xb)>0.000001

n=n+1; xb=x;

if n>300 break; end

y=feval('f306', x);

y_driv=(feval('f306', x+del_x) - y)/del_x;

x = xb - y/y_driv;

fprintf(' n=%3.0f, x=%12.5e, y = %12.5e, ', n,x,y)

fprintf(' yd = %12.5e \n', y_driv)

end

fprintf('\n Final answer = %12.6e\n', x);

fprintf('\n============================================')



end


The initial X0 abscissa value approximation and the results are given below exactly the

same way they are listed by the algorithm in the Matlab command window:

============================================

Newton Iteration Method (without graphics)

** Give the Xo abscissa value approximation:

Initial guess Xo = -1.23

n= 1, x=2.51938e+001, y = -1.56424e+000, yd = 5.91981e-002

n= 2, x=2.49622e+000, y = 2.41957e+001, yd = 1.06600e+000

n= 3, x=4.33557e-001, y = 3.29509e+000, yd = 1.59750e+000

n= 4, x=7.66219e-001, y = -4.73920e-001, yd = 1.42463e+000

n= 5, x=7.39300e-001, y = 4.56807e-002, yd = 1.69701e+000

n= 6, x=7.39086e-001, y = 3.59955e-004, yd = 1.67745e+000

n= 7, x=7.39085e-001, y = 8.07423e-007, yd = 1.67730e+000

Final answer = 7.390851e-001

============================================Type 1 to continue, or 0 to

stop:

M-file dari : fnewton.m

function [res, it]=fnewton(func,dfunc,x,tol)

% Finds a root of f(x) = 0 using Newton's method.

% Example call: [res, it]=fnewton(func,dfunc,x,tol)

% The user defined function func is the function f(x),

% The user defined function dfunc is df/dx.

% x is an initial starting value, tol is required accuracy.

it=0; x0=x;

d=feval(func,x0)/feval(dfunc,x0);

while abs(d)>tol


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/fnewton.m

x1=x0-d;

it=it+1;

x0=x1;

d=feval(func,x0)/feval(dfunc,x0);

end;

res=x0;

M-file : newt_g.m

Sekarang metode Newton diatas (newt_n) dianalisa kembali dengan contoh kode

berikut beserta fitur grafiknya :

% Newt_g(f_name, x0, xmin, xmax, n_points)

% finds a root of a function f_name by

% newton iteration (with graphics)

% improved after Copyright S. Nakamura, 1995

while 1

clear, clf,clc

fprintf( '\n============================================\n' );

fprintf( ' Newton Iteration Method (with graphics) \n' );

fprintf( '** Give the Xmin and Xmax abscissa values:\n');

while 1

xmin = input( 'Xmin = ' );

xmax = input( 'Xmax = ' );

if xmin < xmax; break; end

fprintf( ' \n Xmin has to be less than Xmax!!! ')

fprintf( ' \n Repeat your input for Xmin and Xmax values! ')

end

fprintf( '\n Input the number of points\n ')

n_points = input('N_points = ');


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/newt_g.m

fprintf( '\n Input an initial guess\n ')

x0 = input('Xo = ');

clf, hold off

% xmin, xmax: min and max for plotting

del_x=0.001;

wid_x = xmax - xmin; dx = (xmax- xmin)/n_points;

xp=xmin:dx:xmax; yp=feval('f306', xp);

plot(xp,yp); xlabel('x');ylabel('f(x)');

title('Newton Iteration'),hold on

ymin=min(yp); ymax=max(yp);wid_y = ymax-ymin;

yp=0.*xp; plot(xp,yp)

x = x0; xb=x+999; n=0;

while abs(x-xb)>0.000001

if n>300 break; end

y=feval('f306', x);

plot([x,x],[y,0],'--');

plot(x,0,'o')

fprintf(' n=%3.0f, x=%12.5e, y=%12.5e\n', n,x,y);

xsc=(x-xmin)/wid_x;

if n<4,

text(x, -wid_y/20, [ num2str(n)], 'FontSize', [16]),

end

y_driv=(feval('f306', x+del_x) - y)/del_x;

xb=x;

x = xb - y/y_driv; n=n+1;

plot([xb,x],[y,0],':')

end

plot([x x],[0.02*wid_y 0.2*wid_y])

text( x, 0.25*wid_y, 'Final solution','FontSize', [16])


plot([x (x-wid_x*0.004)],[0.02*wid_y 0.05*wid_y])

plot([x (x+wid_x*0.004)],[0.02*wid_y 0.05*wid_y])

axis([xmin,xmax,ymin*1.2,ymax*1.2])

fprintf('\n============================================')



end

Sebagai contoh algoritma diatas di jalankan dengan input dan hasil persis seperti

terlihat didalam Matlab command window:

============================================

Newton Iteration Method (with graphics)

** Give the Xmin and Xmax abscissa values:

Xmin = -10

Xmax = 10

Input the number of points

N_points = 30

Input an initial guess

Xo = -1.56

n= 0, x=-1.56000e+000, y=-1.57080e+000

n= 1, x=2.46019e+004, y=2.46029e+004

n= 2, x=-2.79821e+003, y=-2.79763e+003

n= 3, x=1.23465e+004, y=1.23455e+004

n= 4, x=7.16039e+002, y=7.15068e+002

n= 5, x=-2.26678e+002, y=-2.27563e+002

n= 6, x=1.98154e+002, y=1.99127e+002

n= 7, x=-6.11256e+001, y=-6.09906e+001

n= 8, x=-3.04890e+001, y=-3.10893e+001

n= 9, x=-1.32181e+001, y=-1.40131e+001


n= 10, x=2.23598e+001, y=2.32926e+001

n= 11, x=-1.40845e+001, y=-1.41371e+001

n= 12, x=9.98146e+003, y=9.98227e+003

n= 13, x=-1.39418e+004, y=-1.39427e+004

n= 14, x=-4.87296e+003, y=-4.87202e+003

n= 15, x=-1.23669e+003, y=-1.23715e+003

n= 16, x=-5.81733e+002, y=-5.80875e+002

n= 17, x=-1.97658e+002, y=-1.96692e+002

n= 18, x=6.80764e+001, y=6.75690e+001

n= 19, x=-4.19595e+002, y=-4.19785e+002

n= 20, x=-2.07767e+002, y=-2.08679e+002

n= 21, x=1.45265e+002, y=1.44534e+002

n= 22, x=5.93973e+001, y=6.03547e+001

n= 23, x=1.25486e+001, y=1.15488e+001

n= 24, x=7.97007e-001, y=9.81568e-002

n= 25, x=7.39794e-001, y=1.18581e-003

n= 26, x=7.39085e-001, y=4.46683e-007

======================================Type 1 to continue, or 0 to stop:


Representasi grafik dari jalannya algoritma diatas adalah sebagai berikut :

M-file : newton_raphson_polynom.m

Metode berikutnya adalah yang diusulkan oleh Newton-Raphson. Kode matlab yang

dibuat adalah pengembangan dari newton_raphson.m (diusulkan di dalam

"NUMERICAL METHODS Using MATLAB" oleh John H. Mathews dan Kurtis D.

Fink) dan di khususkan untuk kasus fungsi-fungsi polynomial karena turunan

pertama analitiknya dapat dihitung dengan mudah.


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/newton_raphson_polynom.m

http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/newton_raphson.m

%function [p0,err,k,y]=newton(f,df,p0,delta,epsilon,max1)

%Input - f is the object function input as a string 'f'

% - df is the derivative of f input as a string 'df'

% - p0 is the initial approximation to a zero of f

% - delta is the tolerance for p0

% - epsilon is the tolerance for the function values y

% - max1 is the maximum number of iterations

%Output - p0 is the Newton-Raphson approximation to the zero

% - err is the error estimate for p0

% - k is the number of iterations

% - y is the function value f(p0)

while 1

clear, clf,clc

fprintf( '\n============================================\n' );

fprintf( ' Newton-Raphson Method. Polynomial examples \n' );

while 1

km = input( '** The degree of the polynom ? N = ' );

if km>1 break; end

fprintf(' Input is invalid: Repeat.\n')

end

while 1

fprintf( '\n Input the polynomial coefficients ')

fprintf( '\n like [x^N x^N-1 ... x^1 x^0]'); coef = input('');

if length(coef) == km+1; break; end

fprintf( ' \n Number of coefficients do not match with the polynomial degree ')

fprintf( ' \n Repeat your input for coefficients! ')

end


while 1

fprintf( ' \n The absciss extremes a and b (a < b)')

fprintf( ' \n a = '); a = input('');

fprintf( ' b = '); b = input('');

if a < b; break; end

fprintf( ' \n a should be less than b! ')

fprintf( ' \n Repeat your input for a and b! ')

end

fprintf( ' \n Now the polynomial function is plotted ')

x=a:0.1:b;

f = polyval(coef,x);

plot(x, f, 'b-');

centaxes

hold on;

for i=1:km+1

pow_def(i) = km - i + 1; % diagonal elements

end;

dev1_coef=pow_def.*coef;

dev1_coef=dev1_coef(1:km)

df=polyval(dev1_coef, x)

fprintf( ' \n Now the 1st derivative of the polynomial function is plotted \n')

plot(x, df,'c-'); % the analytical 1st derivative

hold on;

fprintf( '** Give the Po initial abscissa value approximation to a zero of f:\n');

p0 = input('Initial approximation Po = ');


while 1

fprintf( '\n Input the tolerance value for Po, delta = ')

delta = input('');

if delta < 1 & delta > 0; break; end

fprintf( ' \n Delta should be greater than 0 and less than 1!!! ')


end

while 1

fprintf( '\n Input the tolerance value for the function Y values, epsilon = ')





end

while 1

fprintf( '\n Input the maximum number of iterations, N_max = ')

max1 = input('');

if max1 > 1; break; end

fprintf( ' \n The number of iterations should be greater than 1!!! ')

fprintf( ' \n Repeat your input for the number of iterations value! ')

end


for k=1:max1

p1=p0-polyval(coef,p0)/polyval(dev1_coef,p0);

err=abs(p1-p0);


p0=p1;

y=polyval(coef,p0);


end

fprintf('\n==============RESULTS================')

fprintf('\n Po is the Newton-Raphson approximation to zero = %12.6f', p0);

fprintf('\n Err is the error estimate for Po = %12.6f', err);

fprintf('\n K is the number of iterations = %u', k);

fprintf('\n Y is the function value f(Po) = %12.6f', y);

fprintf('\n============================================')

kont1 = input( 'Type 1 to continue, or 0 to stop: ' );

if kont1 == 0, break; end

end


Sebagai contoh, digunakan fungsi polynomial yang sebelumnya : f(x) = x3 + x2 -

1.25x - 0.75. Input dan output dari algoritma diambil dari Matlab command window

============================================

Newton-Raphson Method. Polynomial examples

** The degree of the polynom ? N = 3

Input the polynomial coefficients

like [x^N x^N-1 ... x^1 x^0][1 1 -1.25 -0.75]

The absciss extremes a and b (a < b)

a = -10

b = 10

Now the 1st derivative of the polynomial function is plotted

** Give the Po initial abscissa value approximation to a zero of f:

Initial approximation Po = -2.34

Input the tolerance value for Po, delta = 0.034

Input the tolerance value for the function Y values, epsilon = 0.023

Input the maximum number of iterations, N_max = 10

==============RESULTS================

Po is the Newton-Raphson approximation to zero = -1.500155

Err is the error estimate for Po = 0.010475

K is the number of iterations = 4

Y is the function value f(Po) = -0.000386

============================================Type 1 to continue, or 0 to

stop:


Figure window memperlihatkan fungsi f(x) dan turunan pertamanya :

M-file : fzero_root.m

Aplikasi kali ini adalah perbandingan grafik sederhana antara akar yang didekati

dengan cursor dan yang eksak. Kode berikut menggunakan fungsi Matlab

plotapp,dimana Plottapp mem-plot sebuah fungsi untuk memperkirakan sebuah

akar tertentu dengan menggunakan cursor. Fungsi Matlab Fzero adalah fungsi yang

digunakan untuk menentukan akar yang eksak.


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/fzero_root.m

Dibawah ini diperlihatkan Figure Window dan command window dari contoh yang

dijalan dengan menggunakan fungsi f306.m

============================================

Approximate root is 0.75

Exact root is 0.73906

========================================Type 1 to continue, or 0 to stop:

M-file : mat_root.m

x=-4:.1:0.5;

plot(x,f306(x)); grid on;


http://www.eeng.dcu.ie/%7Eee317/Matlab_Examples/iter/mat_root.m

xlabel('x');ylabel('f(x)');

title('f(x)=x-cos(x)');

root=fzero('f306',1.65,0.00005);

fprintf('\n============================================')

fprintf('\nThe root of this equation is %6.4f\n',root);

fprintf('\n============================================')

Aplikasi sederhana diatas menggunakan fungsi Matlab fzero untuk menghitung akar

ekasak dari fungsi f306.m.


Daftar pustaka .

1. Jhon H.Mathews ……………………………………Nunerical method using

MATLAB , 1999.

2. Steven C.Chapra, Raymond P.Canale………. ......Numerical Methods for

Engineers , 2 nd Edition 1988

3. V.Rajarama…………………………………………Computer oriented Numerical

Methods ,3 rd Ed , Feb 1996

4. Steven C. Chapra …………………………………..Introduction to Computing for

Engineer, 1982.


Komputasi teknik dengan menggunakan Perangkat lunak...

Documents

Transcript of Komputasi teknik dengan menggunakan Perangkat lunak...