Page 210 - Chapra y Canale. Metodos Numericos para Ingenieros 5edición_Neat
P. 210

186                     RAÍCES DE POLINOMIOS

              a) Algoritmo de Bairstow                        IF iter < maxit THEN
                                                               IF n = 2 THEN
              SUB Bairstow (a,nn,es,rr,ss,maxit,re,im,ier)        r = –a(1)/a(2)
              DIMENSION b(nn), c(nn)                              s = –a(0)/a(2)
              r = rr; s = ss; n = nn                              CALL Quadroot(r,s,r1,i1,r2,i2)
              ier = 0; ea1 = 1; ea2 = 1                           re(n) = r1
              DO                                                  im(n) = i1
               IF n < 3 OR iter ≥ maxit EXIT                      re(n – 1) = r2
               iter = 0                                           im(n – 1) = i2
               DO                                              ELSE
                 iter = iter + 1                                  re(n) = –a(0)/a(1)
                 b(n) = a(n)                                      im(n) = 0
                 b(n – 1) = a(n – 1) + r * b(n)                END IF
                 c(n) = b(n)                                  ELSE
                 c(n – 1) = b(n – 1) + r * c(n)                ier = 1
                 DO i = n – 2, 0, –1                          END IF
                   b(i) = a(i) + r * b(i + 1) + s * b(i + 2)  END Bairstow
                   c(i) = b(i) + r * c(i + 1) + s * c(i + 2)
                 END DO
                 det = c(2) * c(2) – c(3) *c(1)
                 IF det ≠ 0 THEN
                   dr = (–b(1) * c(2) + b(0) * c(3))/det
                                                              b) Algoritmo para raíces de una cuadrática
                   ds = (–b(0) * c(2) + b(1) * c(1))/det
                   r = r + dr
                                                              SUB Quadroot(r,s,r1,i1,r2,i2)
                   s = s + ds
                                                              disc = r ^ 2 + 4 * s
                   IF r ≠ 0 THEN ea1 = ABS(dr/r) * 100
                                                              IF disc > 0 THEN
                   IF s ≠ O THEN ea2 = ABS(ds/s) * 100
                                                               r1 = (r + SQRT(disc))/2
                 ELSE
                                                               r2 = (r – SQRT(disc))/2
                   r = r + 1
                                                               i1 = 0
                   s = s + 1
                                                               i2 = 0
                   iter = 0
                                                              ELSE
                 END IF
                                                               r1 = r/2
                 IF ea1 ≤ es AND ea2 ≤ es OR iter ≥ maxit EXIT
                                                               r2 = r1
               END DO
                                                               i1 = SQRT(ABS(disc))/2
               CALL Quadroot(r,s,r1,i1,r2,i2)
                                                               i2 = –i1
               re(n) = r1
                                                              END IF
               im(n) = i1
                                                              END QuadRoot
               re(n – 1) = r2
               im(n – 1) = i2
               n = n – 2
               DO i = 0, n
                 a(i) = b(i + 2)
               END DO
              END DO
              FIGURA 7.5
              a) Algoritmo para el método de Bairstow junto con b) un algoritmo para determinar las raíces de una ecuación cuadrática.



                                                                                                         6/12/06   13:51:26
          Chapra-07.indd   186                                                                           6/12/06   13:51:26
          Chapra-07.indd   186
   205   206   207   208   209   210   211   212   213   214   215