PHƯƠNG PHÁP LẶP BIRGE - VIETTE



PHƯƠNG PHÁP LẶP BIRGE - VIETTE
                Các nghiệm thực, đơn giản của một đa thức Pn(x) được tính toán khi sử dụng phương pháp Newton   
                                                          
                                                                                                    (1)
Để bắt đầu tính toán cần chọn một giá trị ban đầu xo. Chúng ta có thể chọn một giá trị xo nào đó, ví dụ :
                                                                                  
và tính tiếp các giá trị sau :                           
                                                    
Tiếp theo có thể đánh giá Pn(xi) theo thuật toán Horner :
P0 = a0
                P1 = P0xi + a1                                                                                                                                         (2)
                P2 = P1xi + a2
                P3 = P2xi + a3
                ..................
                P(xi) = Pn = Pn-1xi + an
Mặt khác khi chia đa thức Pn(x) cho một nhị thức (x - xi) ta được :
Pn(x) = (x - xi)Pn-1(x) + bn                                                                                                   (3)
với bn = Pn(xi). Đa thức Pn-1(x) có dạng:
                Pn-1(x) = boxn-1 + b1xn-2 + p3xn-3 +..+ bn-2x + bn-1                                                             (4)
Để xác định các hệ số của đa thức (4) ta thay (4) vào (3) và cân bằng các hệ số với đa thức cần tìm nghiệm Pn(x) mà các hệ số ai đã cho:
                (x - xi)( boxn-1 + b1xn-2+b3xn-3 +..+ bn-2x + bn-1 ) + bn
                = aoxn + a1xn-1 + a2xn-2 +...+ an-1x + a=                                                                                             (5)
Từ (5) rút ra :
bo = ao
b1 = a1 + boxi                                                                                                                                         (6)
                b2 = a2 + b1xi
                        ......
                bk = ak + bk-1xi
                .......
                bn = an + bn-1xi = Pn(xi)
                Đạo hàm (3) ta được :
               
và:                                               


                                                                                               (7)
                Như vậy với một giá trị xi nào đó theo (2) ta tính được Pn(xi) và kết hợp (6) với (7) tính được P¢n(xi). Thay các kết quả này vào (1) ta tính được giá trị xi+1. Quá trình được tiếp tục cho đến khi | xi+1 - xi | < e hay Pn(xi+1) » 0 nên a1 » xi+1 là một nghiệm của đa thức.
                Phép chia Pn(x­) cho (x -  a1) cho ta Pn-1(x­) và một nghiệm mới khác được tìm theo cách trên khi chọn một giá trị xo mới hay chọn chính xo=a1. Khi bậc của đa thức giảm xuống còn bằng 2 ta dùng các công thức tìm nghiệm của tam thức để tìm các nghiệm còn lại.
Ví dụ: Tìm nghiệm của đa thức P3(x) = x3 - x2 -16x + 24
ao­ = 1                     a1 = -1                    a2= -16                   a3 = 24
Chọn xo = 3.5 ta có :
Po = ao = 1
P1 = a1 + pox0 = -1 + 3.5*1 = 2.5       
P2 = a2 + p1x0 = -16 + 3.5*2.5 = -7.25
P3 = a3 + p2x0 = 24 + 3.5*(-7.25) = - 1.375
b0 = a0 = 1;
b1 = a1 + box0 = -1 + 3.5*1 = 2.5        
b2 = a2 + b1x0 = -16 + 3.5*2.5 = -7.25
P2(3.5) = b0x2 + b1x + b2 = 13.75
Lặp lại bước tính trên cho x1 ta có:
Po = ao = 1
P1 = a1 + pox1 = -1 + 3.6*1 = 2.6       
P2 = a2 + p1x1 = -16 + 3.6*2.6 = -6.64
P3 = a3 + p2x1 = 24 + 3.6*(-6.64) = - 0.096
bo = ao = 1
b1 = a1 + box1 = -1 + 3.6*1 = 2.6                        
b2 = a2 + p1x1 = -16 + 3.6*2.6 = -6.64
P2(3.6) = b0x2 + b1x + b2 = 15.68
Quá trình cứ thế tiếp tục cho đến khi sai số chấp nhận được. Chương trình dưới đây mô tả thuật tính trên.

 

Chương trình 2-8


//phuong phap Birge-Viette
#include <conio.h>
#include <stdio.h>
#include <math.h>
#define  max  20

void main()
  {
                float a[max],p[max],d[max],x[max];
                int k,j,i,n;
                float e1,e2,x0,x1;

                clrscr();
                printf("Cho bac cua da thuc n = ");
                scanf("%d",&n);
                e1=0.0001;
                printf("Cho cac he so cua da thuc can tim nghiem\n");
                for (i=0;i<=n;i++)
                  {
                                printf("a[%d] = ",i);
                                scanf("%f",&a[i]);
                  }
                x0=a[0];
                for (i=0;i<=n;i++)
                  a[i]=a[i]/x0;
                printf("Nghiem cua phuong trinh  : \n");
                tt:x0=-a[n]/a[n-1];
                j=0;
                do
                  {
                                j=j+1;
                                p[1]=x0+a[1];
                                d[1]=1.0;
                                for (k=2;k<=n;k++)
                                  {
                                                p[k]=p[k-1]*x0+a[k];
                                                d[k]=d[k-1]*x0+p[k-1];
                                  }
                                x1=x0-p[n]/d[n];
                                e2=fabs(x1-x0);
                                if (e2>e1)
                                x0=x1;
                  }
                while((j<=50)||(e2>=e1));
if (e2>=e1)
                  printf("Khong hoi tu");
                else
                  printf(" x = %.4f\n",x1);
                n=n-1;
                if (n!=0)
                  {
                                for (k=1;k<=n;k++)
                                  a[k]=p[k];
                                goto tt;
                  }
                getch();
  }
                Dùng chương trình trên để tìm nghiệm của đa thức x4 + 2x3 - 13x2 - 14x + 24 ta được các nghiệm là:-4 ; 3 ; -2 và 1.
Ntech Developers

Programs must be written for people to read, and only incidentally for machines to execute.

Post a Comment

Previous Post Next Post