Algoritmo de Briot-Ruffini

Paolo Ruffini

Algoritmo de Briot-Ruffini, por vezes denominado apenas como regra de Ruffini, é um método de resolução de frações polinomiais, criado por Paolo Ruffini. Esse algoritmo consiste em efetuar a divisão fazendo cálculos apenas com coeficientes e só serve para divisões de um polinômio por um binômio da forma ${\displaystyle (x-a)}$.

As divisões de polinômios por binômios, como por exemplo: ${\displaystyle (x-2)}$, ${\displaystyle \left(x+{\dfrac {3}{2}}\right)}$ e ${\displaystyle (x+5)}$, surgem em problemas de matemática mais frequentemente do que quaisquer outras divisões de polinômios e desempenham papel importante na pesquisa de zeros de funções e na resolução de equações.

Exemplo

Divisão de um Polinômio por x − a

Seja:

${\displaystyle P(x)=2x^{3}+3x^{2}-4\,\!}$

${\displaystyle D(x)=x+1.\,\!}$

Queremos dividir P(x) por D(x) usando a regra de Ruffini. Primeiro observamos que D(x) não é um binômio da forma x − a, mas da forma x + a. Então reescrevemos D(x) deste modo:

${\displaystyle D(x)=x+1=x-(-1).\,\!}$

Agora aplicamos o algoritmo:

1. Transcrevemos os coeficientes e a. Note que, como P(x) não contém um coeficiente para x, então escrevemos 0:

    |     2     3     0     -4
    |                                    
 -1 |                                    
----|---------------------------
    |                                    
    |

2. Passe o primeiro coeficiente

    |     2     3     0     -4
    |                                    
 -1 |                                    
----|----------------------------
    |     2                              
    |

3. Multiplique-o por a:

    |     2     3     0     -4
    |                                    
 -1 |          -2                         
----|----------------------------
    |     2                              
    |

4. Some os valores da coluna:

    |     2     3     0     -4
    |
 -1 |          -2
----|----------------------------
    |     2     1
    |

5. Repita os passos 3 e 4 até a última coluna:

    |     2     3     0     -4
    |
 -1 |          -2    -1      1
----|----------------------------
    |     2     1    -1     -3
    |    {coeficientes}   {resto}

${\displaystyle P(x)=D(x)Q(x)+r\,\!}$, onde

${\displaystyle Q(x)=2x^{2}+x-1\,\!}$ e ${\displaystyle r=-3.\,\!}$

isto é,

${\displaystyle (2x^{3}+3x^{2}-4)=(x+1)(2x^{2}+x-1)-3\,\!}$

Exemplo de código fonte

import java.util.Scanner;

public class BriotRuffiniAlgorithm {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        
        System.out.print("Digite o grau do polinômio: ");
        int degree = input.nextInt();
        
        double[] coefficients = new double[degree + 1];
        System.out.println("Digite os coeficientes do polinômio, do termo de maior grau ao termo de menor grau:");
        for (int i = degree; i >= 0; i--) {
            System.out.print("x^" + i + ": ");
            coefficients[i] = input.nextDouble();
        }
        
        System.out.print("Digite o valor de x para avaliar o polinômio: ");
        double x = input.nextDouble();
        
        double[] result = briotRuffini(coefficients, x);
        
        System.out.print("Resultado: ");
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i]);
            if (i < result.length - 1) {
                System.out.print(", ");
            }
        }
        
        input.close();
    }
    
    public static double[] briotRuffini(double[] coefficients, double x) {
        int degree = coefficients.length - 1;
        double[] result = new double[degree];
        
        result[0] = coefficients[degree];
        for (int i = degree - 1; i > 0; i--) {
            result[i] = coefficients[i] + x * result[i - 1];
        }
        
        return result;
    }

}

Ver também

• Divisão polinomial
• Teorema do resto
• Teorema fundamental da álgebra