ΑΡΙΘΜΗΤΙΚΕΣ ΜΕΘΟΔΟΙ, 04 0, Ο ΕΞΑΜΗΝΟ ΑΠΑΝΤΗΣΕΙΣ ΕΡΓΑΣΙΑ #: ΕΠΙΛΥΣΗ ΣΥΣΤΗΜΑΤΩΝ ΕΞΙΣΩΣΕΩΝ Ημερομηνία ανάρτησης εργασίας στην ιστοσελίδα του μαθήματος: 8 0 04 Ημερομηνία παράδοσης εργασίας: 0 04 Επιμέλεια απαντήσεων: Ι. Λυχναρόπουλος ΑΣΚΗΣΗ i. Επιλύστε με απαλοιφή Gauss μερικής οδήγησης το σύστημα: x x xx x x x H λύση του συστήματος προκύπτει από το Mathematica με την εντολή: LinearSolve[{{0,-,},{,,-},{,0,-}},{,,}]//N ή με την εντολή: Solve[{-y+z==,x+y-z==,x-z==}]//N και είναι η: x 0.8, x.90, x 0.96 Gauss με μερική οδήγηση 0 0 0 0.4 0.4 r r r r/ r r r 0 0 0 0 0.4 0.4 0 0.4 0.4 0 0.6.6 r r 0 r r /( ) -0 0 0.6.6 0 0.4 0.4 0 0.4 0.4 0. 0.66 r r r 0. 0.66 r r / 4.06 0 0.6.6 0 0 4.06.9 0 0.4 0.4 0. 0.66 0 0 0.968 Επομένως: x0.4x 0.4 x 0.4 0.4x x.x 0.66 x 0.66.x x 0.968 x 0.968 Εκτελώντας την προς τα πίσω αντικατάσταση παίρνουμε τελικά x 0.8 x.90 x 0.96 Κώδικας Fortran που επιλύει το συγκεκριμένο σύστημα με την μέθοδο Gauss με μερική οδήγηση:
program Gauss_partial_pivoting implicit none integer,parameter::n= real::a(n,n),b(n),x(n) real::e(n,n+) integer::i A(,:)=(/0,-,/) A(,:)=(/,,-/) A(,:)=(/,0,-/) b=(/,,/)!epayksimenos Pinakas E(:N,:N)=A E(:N,N+)=b call gauss_partial_pivot(e,n,x)!display Result Do i=,n print*,i,x(i) Enddo contains subroutine gauss_partial_pivot(a,n,x) integer,intent(in)::n real,intent(inout)::a(n,n+) real,intent(out)::x(n) real::v(:n),temp(n+) integer::i,k,pos real::s,pivot do k=,n-!pivoting pivot=maxval(abs(a(k:n,k))) pos=maxloc(abs(a(k:n,k)),); pos=k-+pos print* print* print*,k,' Pivot=',pivot,'Position=',pos!If pivot is not in the current row!exchange rows if (pos/=k) then temp=a(k,:) A(k,:)=A(pos,:) A(pos,:)=temp end if!end OF PIVOTING!Find column multipliers v(k+:n)=a(k+:n,k)/a(k,k)
!Use multipliers to eliminate column values reducing each row Do i=k+,n A(i,k:N+)=A(i,k:N+)-v(i)*A(k,k:N+) Enddo!Display multipliers and Array after each reduction step print* print*,'--------- Multipliers ------------' print '(00F0.)',v(k+:N) print*,'---------',k,'------------' do i=,n print '(00(F0.,:,","))',a(i,:)!Backward Substitution Do k=n,,- s=sum(a(k,k+:n)*x(k+:n)) X(k)=(A(k,N+)-s)/A(k,k) Enddo end subroutine End program ii. Αναφέρετε και εξηγείστε τα πλεονεκτήματα της απαλοιφής Gauss με μερική οδήγηση σε σχέση με την απαλοιφή Gauss χωρίς οδήγηση και με πλήρη οδήγηση Η απαλοιφή Gauss χωρίς οδήγηση έχει το μειονέκτημα πως, αν υπάρχει διαφορά τάξης μεγέθους στα στοιχεία του επαυξημένου πίνακα, ενδέχεται να δώσει εσφαλμένο αποτέλεσμα λόγω του συσσωρευμένου αριθμητικού σφάλματος. Αυτό συμβαίνει κυρίως όταν οι πολλαπλασιαστές που χρησιμοποιούνται στη μέθοδο έχουν μεγάλο μέγεθος. Το πρόβλημα αυτό αντιμετωπίζεται με την απαλοιφή Gauss με μερική οδήγηση, όπου το μέγεθος των πολλαπλασιαστών σε κάθε βήμα διατηρείται μικρό. Το ίδιο αποτέλεσμα επιτυγχάνεται και με την απαλοιφή Gauss με πλήρη οδήγηση, η οποία όμως απαιτεί περισσότερες πράξεις από την απαλοιφή Gauss με μερική οδήγηση, αυξάνοντας παράλληλα το υπολογιστικό κόστος. Βέβαια όταν το σύστημα είναι ιδιόμορφο (ill conditioned), δηλαδή η ορίζουσα του πίνακα συντελεστών να είναι πολύ κοντά στο μηδέν, καμία μέθοδος Gauss δεν μπορεί να αποφύγει το αριθμητικό σφάλμα. iii. Επιλύστε το παραπάνω σύστημα με την επαναληπτική μέθοδο Gauss Seidel και συγκρίνετε την αποτελεσματικότητα των απευθείας και των επαναληπτικών μεθόδων. Αναδιατάσσουμε τις εξισώσεις του συστήματος, έτσι ώστε στη διαγώνιο του πίνακα των συντελεστών να υπάρχουν μη μηδενικά στοιχεία με όσο γίνεται μεγαλύτερες τιμές. x x x x x x x Στη συνέχεια εφαρμόζουμε την επαναληπτική διαδικασία Gauss Seidel
(k) ( ) k x x ( k) ( ) ( ) k k x x x ( k) ( ) k x x όπου ( k), k 0,,... δηλώνει το επαναληπτικό βήμα. (0) (0) (0) (0) Με αρχική εκτίμηση της λύσης x = (x, x, x ) = (,,) για k 0 το σύστημα γίνεται: () x 0.8 () x 0.8.6 () x (.6) 0.9 To μέγιστο απόλυτο σφάλμα για το πρώτο βήμα προκύπτει ως () (0) x x 0. () (0) () (0) x x max x x max 0.6 και ισούται με 0.6. () (0) x 0.09 x Για k το σύστημα γίνεται: () x (0.9) 0.88 () x 0.88 0.9.9 () x (.9) 0.96 To μέγιστο απόλυτο σφάλμα για το δεύτερο βήμα προκύπτει ως () () x x 0.0 () () () () x x max x x max 0.009 και ισούται με 0.0. () () x 0.004 x Η διαδικασία επαναλαμβάνεται μέχρι να επιτευχθεί η σύγκλιση, δηλαδή μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 6. Κώδικας Fortran που επιλύει το συγκεκριμένο σύστημα με την μέθοδο Gauss Seidel: program Gauss_Seidel_method implicit none integer,parameter::n= real::a(n,n),b(n),x(n) integer::i A(,:)=(/,0,-/)
A(,:)=(/,,-/) A(,:)=(/0,-,/) b=(/,,/) x=(/,,/)!initial guess call Gauss_Seidel(A,B,N,X) do i=,n print*,x(i) contains subroutine Gauss_Seidel(A,B,N,X) integer,intent(in)::n real,intent(in)::a(n,n) real,intent(in)::b(n) real,intent(inout)::x(n) real::x_old(n) integer::i,k real::err open(0,file='results_seidel.txt') write(0,00) 0,.,x do k=,0000 x_old=x do i=,n x(i)=(b(i)-(sum(a(i,:i-)*x(:i-)) + sum(a(i,i+:n)*x_old(i+:n))))/a(i,i) err=maxval(abs(x_old(:)-x(:))) write(0,00) k,err,x print*,k,x,err if (err<e-6) exit close(0) 00 Format(i,",",e0.,","00(f0.,:,",")) end subroutine end program H εκτέλεση του προγράμματος για κριτήριο σύγκλισης το 0 6 δίνει τα ακόλουθα αποτελέσματα: Iter Abs Error x x x 0.00000.00000.00000 0.600E+00 0.80000.60000 0.94 0.4E 0 0.88.94 0.966 0.4E 0 0.80.90 0.968 4 0.89E 0 0.869.908 0.96 0.4E 04 0.8689.90 0.96 6 0.6E 0 0.8689.906 0.96 0.8E 06 0.8689.906 0.96
iv. Να υπολογιστεί η θετική ρίζα του συστήματος y x y cosx To σύστημα μπορεί να γραφεί σε μία εξίσωση απαλείφοντας το y ως: x cosx Η επίλυση της εξίσωσης θα γίνει με την μέθοδο Newton Raphson και στη συνέχεια το x που θα προκύψει το αντικαθιστούμε σε μία από τις δύο αρχικές εξισώσεις για να πάρουμε το y. Θέτουμε f ( x) x cosx. Επομένως f '(x) x sin x H γραφική παράσταση της συνάρτησης f ( x ) είναι η 4 - - - ( k ) ( k) ( k) f( x ) x x ( k ), k 0,,,... Η μέθοδος Newton Raphson γράφεται ως f '( x ) xk cosxk xk xk, k 0,,,... x sinx k k Επειδή μας ενδιαφέρει μόνο η θετική λύση, δίνουμε αρχική τιμή x0. Για k=0 η μέθοδος δίνει: x0 cosx0 x x0 x0 sinx0 cos x 0. sin Το απόλυτο σφάλμα στο πρώτο βήμα είναι xx0 0.. Για k= η μέθοδος δίνει: x cosx x x x sinx 0. cos0. x 0. 0. sin 0. Το απόλυτο σφάλμα στο δεύτερο βήμα είναι x x 0.0. Η διαδικασία επαναλαμβάνεται μέχρι να επιτευχθεί η σύγκλιση, δηλαδή μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 6. Κώδικας Fortran που επιλύει το συγκεκριμένη εξίσωση με την μέθοδο Newton Raphson:
program Newton_Raphson_Method implicit none real::x0,xnew,err_critirio,err,xold integer i,maxi print*, 'Initial guess'!read*, x0 x0= err_critirio=e-6 maxi=0000 open(0,file='results_newton_raphson.txt') err = 00. i = xold=x0 write(0,00) 0,xold,f(xold),df(xold),err print*, 0,xold,f(xold),df(xold),err do while ((i/=maxi).and.(err>=err_critirio).and.(abs(df(xold))>e-6)) xnew = xold - (f(xold)/df(xold)) err = abs(xnew - xold) write(0,00) i,xnew,f(xnew),df(xnew),err print*, i,xnew,f(xnew),df(xnew),err xold = xnew i = i + 00 Format(i,",",(F.4,","),E.) if ((err<err_critirio).and.(abs(df(xold))>e-6)) then print*, 'The root within the prescribed error limit is:',xold print*, 'The absolute error =',err print*,'the number of iteration performed before achieving' print*,'acceptable error limit is:',i - elseif((err>err_critirio).and.(abs(df(xold))>e-6)) then print*, 'The root is not reached within the error limit after prescribed number of iteration.' print*, 'The approximate root =',xold print*, 'The absolute error =',err elseif(abs(df(xold))<e-6) then print*, 'Newton''s method fails...derivative equal to zero.' endif contains real function f(x) real,intent(in)::x f= x**-*cos(x)+ end function
real function df(x) real::x df=*x+*sin(x) end function end program Η εκτέλεση του προγράμματος δίνει: Iter x f(x) f (x) Abs Err 0.0000 0.994.689 0.04 0.00.864 0.0E+00 0.4 0.00.46 0.0E 0 0.46 0.0000.99 0.E 0 4 0.46 0.0000.99 0.8E 06 Επομένως x 0.46 Αντικαθιστώντας την τιμή αυτή στην πρώτη εξίσωση του αρχικού συστήματος παίρνουμε: y 0.46.06 ΑΣΚΗΣΗ Επιλέξτε ένα σύστημα Ν εξισώσεων και επιλύστε το αριθμητικά με τις μεθόδους α) απαλοιφή Gauss, β) παραγοντοποίηση LU, γ) Jacobi, δ) Gauss Seidel και ε) S.O.R. x x x 4 x x x 4 x 9x x 4 x 4x 8x 4 Η λύση του συστήματος δίνεται από το Mathematica με την εντολή: LinearSolve[{{,0,-,},{-,-,0,},{,0,-9,},{,4,0,8}}, {,,-,}] και είναι η x 0.68, x 0.4, x 0.44, x4 0.406 ) Gauss 0 0 4 0 0 r r r r r r 0 9 0 9 4 0 8 4 0 8
0 0 4 4 0 0 4 r4 r4 r 9 8 r4 r4 r 9 8 0 0 0 0 4 8 4 0 8 0 4 0 0 4 4 0 0 4 9 8 r4 r4 r 9 8 0 0 9 0 0 4 9 0 4 0 0 0 0 0 9 0 0 0.8.4.4 ή 0 0.8.4.6 0 0 0 8.46.8 Επομένως το αρχικό σύστημα γράφεται και ως xx x4 x x x4 / x 0.8x.4x4.4 x.4 0.8x.4 x4/ ( ).8x.4x4.6 x.6.4 x4/ (.8) 8.46x4.8 x4.8 / 8.46 Με προς τα πίσω αντικατάσταση παίρνουμε την λύση x 0.68, x 0.4, x 0.44, x 0.406 4 Κώδικας Fortran που επιλύει το συγκεκριμένο πρόβλημα με την απαλοιφή Gauss: program Gauss_naive implicit none integer,parameter::n=4 real::a(n,n),b(n),x(n) real::e(n,n+) integer::i A(,:)=(/,0,-,/) A(,:)=(/-,-,0,/) A(,:)=(/,0,-9,/) A(4,:)=(/,4,0,8/) b=(/,,-,/)!epayksimenos Pinakas E(:N,:N)=A
E(:N,N+)=b call naive_gauss_elimination(e,n,x)!display Result Do i=,n print*,i, x(i) Enddo contains subroutine naive_gauss_elimination(a,n,x) integer,intent(in)::n real,intent(inout)::a(n,n+) real,intent(out)::x(n) real::v(:n) integer::i,k real::s Do k=,n-!find column multipliers v(k+:n)=a(k+:n,k)/a(k,k)!use multipliers to eliminate column values reducing each row Do i=k+,n A(i,k:N+)=A(i,k:N+)-v(i)*A(k,k:N+) Enddo!Display multipliers and Array after each reduction step print* print*,'--------- Multipliers ------------' print '(00F0.)',v(k+:N) print*,'---------',k,'------------' do i=,n print '(00(F0.,:,","))',a(i,:)!Backward Substitution Do k=n,,- s=sum(a(k,k+:n)*x(k+:n)) X(k)=(A(k,N+)-s)/A(k,k) Enddo end subroutine End program Σε Mathematica οι εντολές που επιλύουν το συγκεκριμένο πρόβλημα με την απαλοιφή Gauss είναι οι ακόλουθες: a={{,0,-,},{-,-,0,},{,0,-9,},{,4,0,8}}; b={,,-,}; n=length[b];
(cc=transpose[append[transpose[a],b]])//matrixform c=cc; result=reap[do[do[v=c[[i,k]]/c[[k,k]];c[[i,all]]=c[[i,all]]- c[[k,all]]*v;sow[{v,c}],{i,k+,n}], {k,,n-}]]; cc//matrixform Do[Print[result[[,,k,]]," -- ",result[[,,k,]]//matrixform],{k,,6}] ) Παραγοντοποίηση LU a a a a l 0 0 0 u u u 4 4 a a a a 4 l l 0 0 0 u u 4 a a a a 4 l l l 0 0 0 u 4 a4 a4 a4 a44 l4 l4 l4 l44 0 0 0 A LU l lu lu lu4 l lu l lu lu lu4 lu 4 l lu l lu lu l lu4 lu4 lu 4 l4 l4u l4 lu l4u l4 l4u4 l4u4 l4u4 l44 Σαρώνοντας τον πίνακα εναλλάξ σε κάθε γραμμή και στήλη, οι ποσότητες l ij και u ij υπολογίζονται από τις ακόλουθες σχέσεις: l a, u a / l 0, u a / l, u4 a4 / l l a, l a, l4 a4, l a lu, 4 u a lu / l, u4 a4 lu4 / l 9 l a lu 0, l4 a4 l4u 4, l a lu lu u4 a4 lu4 lu4 / l 9 0 l4 a4 l4u l4u, l44 a44 l4u4 l4u4 l4u4 Επομένως 0 0 0 0 0 0 4 L 9 0 0 0 και U 0 4 0 0 9 0 0 0 Όπως και στην προηγούμενη μέθοδο παραγοντοποίησης LU, έτσι κι εδώ επιλύουμε αρχικά το σύστημα Ly b, το οποίο με προς τα εμπρός αντικατάσταση δίνει τη λύση: y 0., y 0.48, y 0.46, y4 0.406 Τέλος, επιλύοντας το σύστημα Ux y με προς τα πίσω αντικατάσταση, παίρνουμε τη λύση του αρχικού συστήματος:
x.89, x.894, x 4.684, x 0.46 4 Κώδικας Fortran που εφαρμόζει την παραγοντοποίηση LU: program Crout_LU_Decomposition implicit none real,allocatable::a(:,:),x(:),z(:),l(:,:),u(:,:),b(:) real::s integer::i,k,n n=4 allocate(a(n,n),x(n),z(n),l(n,n),u(n,n),b(n)) A(,:)=(/,0,-,/) A(,:)=(/-,-,0,/) A(,:)=(/,0,-,/) A(4,:)=(/,4,0,/) b=(/-,,,-/) call Crout_LU_Decompose(A,N,L,U) print* print*, '-----A-----' do i=,n print*,a(i,:) print* print*, '-----L-----' do i=,n print '(00(f0.,:,","))',l(i,:) print* print*, '-----U-----' do i=,n print '(00(f0.,:,","))',u(i,:)!Solve L*Z=B!Forward Substitution Do k=,n s=sum(l(k,:k-)*z(:k-)) Z(k)=(B(k)-s)/L(k,k) Enddo Do i=,n print*,i, z(i) Enddo!Solve U*X=Z!Backward Substitution Do k=n,,- s=sum(u(k,k+:n)*x(k+:n)) X(k)=Z(k)-s Enddo print*,'----------------'!display Result
Do i=,n print*,i, X(i) Enddo contains subroutine Crout_LU_decompose(A,N,L,U) integer,intent(in)::n real,intent(in)::a(n,n) real,intent(out)::l(n,n),u(n,n) integer::i,j,k u=0 l=0 L(:N, ) = A(:N, ) do i =,N U(i, i) = U(,:N) = A(, :N) / L(, ) do j =,N- do i = j,n L(i, j) = A(i, j) -sum( L(i, :j - ) * U(:j -, j)) do k = j +,N U(j,k) = (A(j,k) - sum(l(j, :j - ) * U(:j -, k))) / L(j, j); L(N,N) = A(N,N) - sum(l(n, :N - ) * U(:N -, N)) end subroutine End program Με την χρήση του Mathematica η λύση του συγκεκριμένου προβλήματος δίνεται με τις ακόλουθες εντολές: a={{,0,-,},{-,-,0,},{,0,-,},{,4,0,}}; b={-,,,-.}; n=length[b]; ll=table[0,{n},{n}]; Do[ll[[i,j]]=Subscript[l, i,j],{i,,n},{j,,i}] ll//matrixform uu=identitymatrix[n]; Do[uu[[i,j]]=Subscript[u, i,j],{i,,n},{j,i+,n}] uu//matrixform s=solve[ll.uu==a] (ll=ll/.s[[]])//matrixform (uu=uu/.s[[]])//matrixform y=linearsolve[ll,b] x=linearsolve[uu,y]
) Jacobi Αρχικά γράφουμε το σύστημα στην ακόλουθη μορφή: ( k) ( ) ( ) k k x x x4 ( k) ( ) ( ) k k x x x4 ( k) ( k) ( k) x x x4 9 ( k) ( ) ( ) 4 k 4 k x x x 8 όπου ( k), k 0,,... δηλώνει το επαναληπτικό βήμα. (0) (0) (0) (0) (0) Με αρχική εκτίμηση της λύσης x = (x, x, x, x 4 ) = (0,0,0,0) για k 0 το σύστημα γίνεται: () x (0) 0 0. () x (0) 0 0.86 () x (0) (0) 0. 9 () x4 (0) 4(0) 0. 8 To απόλυτο σφάλμα για το πρώτο βήμα προκύπτει ως () (0) x x 0. () (0) x () (0) x 0.86 x x max max και ισούται με 0.. () (0) x x 0. () (0) 0. x4 x 4 Για k το σύστημα γίνεται: () x (0.) 0. 0.8 () x (0.) 0. 0.89 () x (0.) (0.) 0.48 9 () x4 (0.) 4( 0.86) 0.468 8
To απόλυτο σφάλμα για το δεύτερο βήμα προκύπτει ως () () x x 0.08 () () x () () x 0.00 x x max max και ισούται με 0.. () () x x 0. () () 0.09 x4 x 4 Η διαδικασία επαναλαμβάνεται μέχρι να επιτευχθεί η σύγκλιση, δηλαδή μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 6. Κώδικας Fortran που επιλύει το συγκεκριμένο σύστημα με την μέθοδο Jacobi: program Jacobi_method implicit none integer,parameter::n=4 real::a(n,n),b(n),x(n) integer::i A(,:)=(/,0,-,/) A(,:)=(/-,-,0,/) A(,:)=(/,0,-9,/) A(4,:)=(/,4,0,8/) b=(/,,-,/) x=(/0,0,0,0/)!initial guess call Jacobi(A,b,N,x) do i=,n print*,x(i) contains subroutine Jacobi(A,B,N,X) integer,intent(in)::n real,intent(in)::a(n,n) real,intent(in)::b(n) real,intent(inout)::x(n) real::x_old(n) integer::i,k real::err open(0,file='results_jacobi.txt') do k=,0000 print*,k x_old=x do i=,n x(i)=(b(i)-(sum(a(i,:i-)*x_old(:i- ))+sum(a(i,i+:n)*x_old(i+:n))))/a(i,i) err=maxval(abs(x_old(:)-x(:)))
k,err,x write(0,'(i,",",e0.,",",00(f0.,:,","))') print*,k,err,x if (err<e-6) exit close(0) end subroutine end program Η εκτέλεση του προγράμματος δίνει: Αριθμός Απόλυτο x x x x 4 επανάληψης σφάλμα 0.00 0.86 0. 0. 0.0E+00 0.8 0.89 0.48 0.468 0.44E 0 0.00 0.9 0. 0.4 4 0.86E 0 0.8 0.06 0.4 0.446 0.6E 0 0.4 0. 0.9 0.449 6 0.E 0 0.6 0.4 0.4 0.40 0.8E 0 0.6 0.4 0.4 0.4 8 0.09E 0 0. 0. 0.4 0.4 9 0.4E 0 0. 0. 0.4 0.4 0 0.49E 04 0. 0. 0.4 0.4 0.8E 04 0. 0. 0.4 0.4 0.948E 0 0. 0. 0.4 0.4 0.40E 0 0. 0. 0.4 0.4 4 0.E 0 0. 0. 0.4 0.4 0.84E 06 0. 0. 0.4 0.4 4) Gauss Seidel Αρχικά γράφουμε το σύστημα στην ακόλουθη μορφή: ( k) ( ) ( ) k k x x x4 ( k) ( ) ( ) k k x x x4 ( k) ( k) ( k) x x x4 9 ( k) ( ) ( ) 4 k 4 k x x x 8 όπου ( k), k 0,,... δηλώνει το επαναληπτικό βήμα. Με αρχική εκτίμηση της λύσης (0) (0) (0) (0) (0) x = (x, x, x, x ) = (0,0,0,0) για k 0 το σύστημα γίνεται: 4
() x (0) 0 0. () x (0.) 0 0.4 () x (0.) (0) 0.4 9 () x4 (0.) 4(0) 0.4964 8 To απόλυτο σφάλμα για το πρώτο βήμα προκύπτει ως () (0) x x 0. () (0) x () (0) x 0.4 x x max max και ισούται με 0.4964. () (0) x 0.4 x () (0) 0.4964 x4 x 4 Για k το σύστημα γίνεται: () x (0.4) 0.496 0.60 () x (0.60) 0.496 0.89 () x (0.60) (0.496) 0. 9 () x4 (0.60) 4( 0.89) 0.44 8 To απόλυτο σφάλμα για το δεύτερο βήμα προκύπτει ως () () x x 0.06 () () x () () x 0.0 x x max max και ισούται με 0.. () () x x 0. () () 0.04 x4 x 4 Η διαδικασία επαναλαμβάνεται μέχρι να επιτευχθεί η σύγκλιση, δηλαδή μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 6. Ο κώδικας σε Fortran που επιλύει ένα σύστημα με τη μέθοδο Gauss Seidel δόθηκε στην άσκηση (iii). Αν τον τρέξουμε για το συγκεκριμένο πρόβλημα δίνει τα ακόλουθα αποτελέσματα: Iter Abs Err x x x x 4 0 0.00000 0.00000 0.00000 0.00000 0.496E+00 0.0000 0.486 0.40000 0.4964 0.E+00 0.60 0.899 0.06 0.4446 0.606E 0 0. 0.60 0.444 0.409 4 0.0E 0 0.68 0.44 0.44 0.4068 0.4E 0 0.680 0.40 0.44 0.406 6 0.E 04 0.684 0.4 0.44 0.406 0.9E 0 0.684 0.4 0.44 0.406 8 0.8E 06 0.684 0.4 0.44 0.406
) SOR Αρχικά γράφουμε το σύστημα στην ακόλουθη μορφή: ( k) ( k) ( k) ( k) x x x4 ( ) x ( k) ( k) ( k) ( k) x x x4 ( ) x ( k) ( k) ( k) ( k) x x x4 ( ) x 9 ( k) ( k) ( k) ( k) x4 x 4 x ( ) x4 8 όπου ( k), k 0,,... δηλώνει το επαναληπτικό βήμα και. Έστω.0. Με αρχική εκτίμηση της λύσης x = (x, x, x, x ) = (0,0,0,0) για k 0 το (0) (0) (0) (0) (0) 4 σύστημα γίνεται: ().0 x (0) (0) 0.0(0) 0.0 ().0 x 0.0 0 0.0(0) 0.4 ().0 x 0.0(0) 0.0(0) 0.40 9 ().0 x4 0.0 4 0.4 0.0(0) 0.0 8 To απόλυτο σφάλμα για το πρώτο βήμα προκύπτει ως () (0) x x 0.0 () (0) x () (0) x 0.4 x x max max και ισούται με 0.0. () (0) x x 0.40 () (0) 0.0 x4 x 4 Για k το σύστημα γίνεται: ().0 x (0.40) 0.0 0.0(0.0) 0.6 ().0 x 0.6 0.0 0.0( 0.4) 0.88 ().0 x 0.6(0.0) 0.0(0.40) 0.4 9 ().0 x4 0.6 4 0.88 0.0(0.0) 0.4 8
To απόλυτο σφάλμα για το δεύτερο βήμα προκύπτει ως () () x x 0.06 () () x () () x 0.08 x x max max και ισούται με 0.9. () () x x 0.9 () () 0.0 x4 x 4 Η διαδικασία επαναλαμβάνεται μέχρι να επιτευχθεί η σύγκλιση, δηλαδή μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 6. Κώδικας Fortran που επιλύει το συγκεκριμένο σύστημα με την μέθοδο SOR: program SOR_Method implicit none real,allocatable::a(:,:),x(:),b(:) integer::i,n real::w n=4 allocate(a(n,n),x(n),b(n)) A(,:)=(/,0,-,/) A(,:)=(/-,-,0,/) A(,:)=(/,0,-9,/) A(4,:)=(/,4,0,8/) b=(/,,-,/)!initial guess x=0 w=.0 call SOR(A,B,N,X,w) do i=,n print*,x(i) contains subroutine SOR(A,B,N,X,w) integer,intent(in)::n real,intent(in)::a(n,n) real,intent(in)::b(n) real,intent(inout)::x(n) real,intent(in)::w real::x_old(n) integer::i,k real::err open(0,file='results_sor.txt') do k=,0000 x_old=x do i=,n
x(i)=w*(b(i)-(sum(a(i,:i-)*x(:i- ))+sum(a(i,i+:n)*x_old(i+:n))))/a(i,i)+ (-w)*x_old(i) err=maxval(abs(x_old(:)-x(:))) write(0,'(i,",",e0.,",",00(f0.,:,","))') k,err,x print*,k,err,x if (err<e-6) exit close(0) end subroutine end program H εκτέλεση του προγράμματος δίνει τα ακόλουθα αποτελέσματα (ω=.0): Iter Abs Err x x x x 4 0.0 0.4 0.40 0.0 0.9E+00 0.6 0.88 0.4 0.4 0.66E 0 0. 0.4 0.4 0.4 4 0.6E 0 0. 0. 0.4 0.4 0.E 0 0. 0. 0.4 0.4 6 0.64E 0 0. 0. 0.4 0.4 0.68E 06 0. 0. 0.4 0.4 Σημειώνεται ότι στο συγκεκριμένο σύστημα η τιμή ω=.0 οδηγεί στον ελάχιστο αριθμό επαναλήψεων. Παρακάτω δίδεται ο προκύπτων αριθμός επαναλήψεων για διάφορες τιμές της παραμέτρου χαλάρωσης ω: ω=0.6 Επαν=4 ω=0. Επαν=9 ω=0.8 Επαν= ω=0.9 Επαν= ω=0.99 Επαν=9 ω=.0 Επαν=9 ω=.0 Επαν= ω=. Επαν= ω=. Επαν=8 ω=. Επαν=9 ω=.4 Επαν=6 ΑΣΚΗΣΗ Επιλέξτε ένα μη γραμμικό σύστημα εξισώσεων και επιλύστε το αριθμητικά με τη μέθοδο Newton. Έστω το μη γραμμικό σύστημα: x x y0 z 0 yz 0
Επομένως f x, y, z x y,, f x y z x z,, f x y z yz O πίνακας της Ιακωβιανής γράφεται ως x 0 x J( x ) x 0 0z, όπου x y 0 z yz z Ξεκινώντας με μία αρχική εκτίμηση της λύσης x υπολογισθεί αρχικά το z, y, z J( xk) x k = f( x k) x0 y, θα πρέπει σε κάθε βήμα να z 0 0 0 x= επιλύοντας το γραμμικό σύστημα: και στη συνέχεια το νέο x από τη σχέση: x x x. H διαδικασία επαναλαμβάνεται k k k Έστω x 0 (,,) Στο πρώτο βήμα θα πρέπει να επιλυθεί το σύστημα: 0 x 4 0 0 y 0 4 4 z το οποίο δίνει x 0.9, y 0., z 0.4 x 0.9.6 Το νέο x θα είναι το x x0 x y 0. 0. z 0.4. Μέγιστο απόλυτο σφάλμα για το πρώτο βήμα xx0 x xx 0 max y y0 max y και ισούται με 0.4. z z z 0 Στο δεύτερο βήμα θα πρέπει να επιλυθεί το σύστημα:.88 0 x 0.80.88 0. y 0. 0.9. z 0.686 το οποίο δίνει x 0., y 0., z 0.0 x.6 0..468 Το νέο x θα είναι το x xx y 0. 0.99 0. z. 0.0.4
x Μέγιστο απόλυτο σφάλμα για το δεύτερο βήμα προκύπτει ως x x max y και ισούται με 0.99. z Συνεχίζουμε επαναληπτικά την ίδια διαδικασία μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 4. Κώδικας Mathematica που επιλύει το μη γραμμικό σύστημα: ClearAll["Global`*"] (*Καθαρισμός μνήμης*) (*ΔΕΔΟΜΕΝΑ ΠΡΟΒΛΗΜΑΤΟΣ*) f={x^-y-,x^-z^+,y z^-}; (*Συναρτήσεις Συστήματος*) vars={x,y,z}; (*Μεταβλητές*) v0={,,}; (*Αρχική Εκτίμηση*) critirio=0^-4; (*Κριτήριο Σύγκλισης*) (*Αναλυτική Λύση*) Solve[f==0,vars,Reals]//N J=Outer[D,f,vars]; (*Ιακωβιανή*) J//MatrixForm lins=linearsolve[j,-f]; (*Συμβολική Επίλυση Γραμμικού Συστήματος*) rules:=thread[vars->v] (*Κανόνες αντικατάστασης που θα χρησιμοποιηθούν αργότερα*) result={};err=;v=v0;i=0;(*αρχικοποίηση μεταβλητών*) While[err>=critirio, (*Συνθήκη Συνέχισης Επαναλήψεων*) Jac=Flatten[J]/.rules;(*Υπολογισμός Ιακωβιανής για εκτύπωση*) Func=f/.rules; (*Υπολογισμός τιμών συναρτήσεων για εκτύπωση*) dv=n[(lins/.rules)]; (*Τιμή επίλυσης του γραμμικού συστήματος*) result=append[result,flatten[{i,n[v],func,jac,dv,err}]]; (*result=o τελικός πίνακας εκτύπωσης αποτελεσμάτων*) v=v+dv; (*Νέα προσέγγιση της λύσης*) err=max[abs[dv]]; (*Υπολογισμός απόλυτου σφάλματος*) i=i+; (*Μετρητής Επαναλήψεων*)] (*Αυτοματοποιημένη δημιουργία γραμμής Τίτλων για τον πίνακα των αποτελεσμάτων*) title={"iter",vars}; (*Iter,x,y,z,...*) Do[s="f"<>ToString[i];title=Append[title,s],{i,,Length[vars]} ]; (*f,f,f,...*) Do[s="Df"<>ToString[i]<>ToString[vars[[j]]];title=Append[title,s],{i,,Length[vars]},{j,,Length[vars]}]; (*Dfx,Dfy,...*) s=inner[stringjoin,table["d",{length[vars]}],map[tostring,vars ],List]; title=append[title,s]; (*dx,dy,dz,...*) title=flatten[append[title,"abs Err"] (*Abs Err*)];
result=prepend[result,title]; (*Προσθήκη της γραμμής τίτλου στα αποτελέσματα*) (*Εμφάνιση αποτελεσμάτων σε μορφή πίνακα με σημαντικά ψηφία*) Style[Grid[result,Alignment->Left,Frame->All,ItemStyle-> {Automatic,{->{Bold,4}}},Background-> {{},{LightGray,None}}],PrintPrecision->] Η εκτέλεση του κώδικα δίνει τον ακόλουθο πίνακα αποτελεσμάτων: Iter x y z f f f Dfx Dfy Dfz Dfx Dfy Dfz Dfx Dfy Dfz dx dy dz Abs Err 0... 4 0 0 0 0 4 4 0.9 0. 0.4.6 0.. 0.80 0. 0.686.88 0.88 0. 0.. 0. 0. 0.0 0.4.4 0.8.4 0. 0.09 0.0668 6.4 0 6.4 0 4. 0.0. 0.0 0.0 0.004 0..44 0..4 0.008 0.008 0.0006 6.4 0 6.4 0 4. 0..4 0.0004 0.0006 0.0000 0.0 4.44 0..4. 0 6. 0 6 4.44 0 8 6.4 0 6.4 0 4. 0..4. 0.94 0 8.9 0 9 0.0004 ΑΣΚΗΣΗ 4 Να βρεθεί αριθμητικά με ακρίβεια δύο σημαντικών ψηφίων η θετική ρίζα της εξίσωσης 6 x 0 εφαρμόζοντας τις μεθόδους των διαδοχικών αντικαταστάσεων και του Νεύτωνα. ) Μέθοδος διαδοχικών αντικαταστάσεων Ξαναγράφουμε την αρχική εξίσωση ως: 6 x 6 6 x 0 6 x x x 0 x 6 x x x x x x Επομένως δημιουργείται ο ακόλουθος αναδρομικός τύπος: 6 xk xk, k 0,,,... xk Θέτοντας x0 παίρνουμε για k 0 6 6 x x0 4.66 x0 Το απόλυτο σφάλμα στο πρώτο βήμα είναι xx0.66 6 6 Για k= η μέθοδος δίνει: x x 4.664.00 x 4.66 Το απόλυτο σφάλμα στο δεύτερο βήμα είναι x x 0.6 Η διαδικασία επαναλαμβάνεται μέχρι να επιτευχθεί η σύγκλιση, δηλαδή μέχρι το απόλυτο σφάλμα να πέσει κάτω από κάποιο κριτήριο που έχουμε θέσει, έστω το 0 6.
Το πρόγραμμα σε Fortran που επιλύει το συγκεκριμένη εξίσωση με την μέθοδο των διαδοχικών αντικαταστάσεων παρουσιάζεται στη συνέχεια: program Fixed_Point_Method implicit none real::x0,xnew,err_critirio,err,xold integer i,maxi print*, 'Initial guess'!read*, x0 x0= err_critirio=e-6 maxi=0000 open(0,file='results_fixed_point.txt') err =. i = xold=x0 write(0,00) 0,xold,f(xold),err print*, 0,xold,f(xold),err do while ((i/=maxi).and.(err>=err_critirio).and.(abs(xold)>e-6)) xnew =f(xold) err = abs(xnew - xold) write(0,00) i,xnew,f(xnew),err print*, i,xnew,f(xnew),err xold = xnew i = i + 00 Format(i,",",(F.,","),E.) if ((err<err_critirio).and.(abs(xold)>e-6)) then print*, 'The root within the prescribed error limit is:',xold print*, 'The absolute error =',err print*,'the number of iteration performed before achieving' print*,'acceptable error limit is:',i - elseif((err>err_critirio).and.(abs(xold)>e-6)) then print*, 'The root is not reached within the error limit after prescribed number of iteration.' print*, 'The approximate root =',xold print*, 'The absolute error =',err elseif(abs(xold)<e-6) then print*, 'Error: x is equal to zero.' endif contains real function f(x) real,intent(in)::x f= 0.*(6./x +x) end function end program
Η εκτέλεση του προγράμματος δίνει: Iter x f(x) Abs Err 0.0000000 4.66666 4.66666 4.00 0.E+0 4.00 4.000004 0.6E+00 4.000004 4.0000000 0.E 0 4 4.0000000 4.0000000 0.4E 0 4.0000000 4.0000000 0.000E+00 ) Μέθοδος Newton Raphson Είναι f( x) x 6 και επομένως f '( x) x ( k ) ( k) ( k) f( x ) Ο αναδρομικός τύπος x x ( k ), k 0,,,... της μεθόδου, γράφεται ως f '( x ) xk 6 xk xk, k 0,,,... xk Θέτοντας x0 παίρνουμε για k 0 x0 6 6 x x0 4.66 x0 () Το απόλυτο σφάλμα στο πρώτο βήμα είναι xx0.66 Για k= η μέθοδος δίνει: x 6 4.66 6 x x 4.66 4.00 x (4.66) Το απόλυτο σφάλμα στο δεύτερο βήμα είναι x x 0.6 Χρησιμοποιώντας το πρόγραμμα που δόθηκε στην άσκηση (iv), τροποποιώντας κατάλληλα τις συναρτήσεις f και df παίρνουμε: Iter x f(x) f'(x) Abs Err 0.0000000.0000000 6.0000000 4.66666.609 8.0 0.E+0 4.006 0.0669 8.00666 0.6E+00 4.000004 0.00004 8.000009 0.E 0 4 4.0000000 0.0000000 8.0000000 0.4E 0 4.0000000 0.0000000 8.0000000 0.000E+00