Práctica 3: Resolución de problemas en Java (I)

Objetivos de la práctica

Los objetivos de esta práctica son los siguientes:

• Desarrollar algoritmos en Java.
• Ejecutar algoritmos en el entorno Eclipse.
• Utilizar expresiones condicionales para distinguir distintos casos de un problema.

Raíces de una ecuación de segundo grado

Una ecuación de segundo grado tiene la forma:

\[ ax^2 + bx + c = 0 \]

donde \(a\), \(b\) y \(c\) son coeficientes reales, y \(x\) es la variable que queremos resolver.

A diferencia de las ecuaciones de primer grado, las ecuaciones de segundo grado pueden tener 0, 1 o 2 soluciones reales dependiendo de los valores de los coeficientes.

Por ejemplo, los siguientes coeficientes generan diferentes números de soluciones:

• \(a=1\), \(b=-3\), \(c=2\) → dos soluciones reales (\(x=1\) y \(x=2\)).
• \(a=1\), \(b=-2\), \(c=1\) → una solución real (\(x=1\)).
• \(a=1\), \(b=0\), \(c=1\) → no hay soluciones reales.

viewof coeficientes = {
  const makeRange = (name, min, max, value, step = 0.1) => {
    const control = Inputs.range([min, max], { value, step });
    control.classList.add("p3-range-widget-uza");
    control.style.width = "100%";
    control.style.maxWidth = "100%";
    control.style.minWidth = "0";
    control.style.boxSizing = "border-box";

    const numberBox = control.querySelector("input[type=number]");
    const slider = control.querySelector("input[type=range]");
    if (numberBox) numberBox.style.display = "none";
    if (slider) {
      slider.classList.add("p3-slider-uza");
      slider.style.width = "100%";
      slider.style.maxWidth = "100%";
      slider.style.minWidth = "0";
    }

    const valueNode = htl.html`<output class="p3-control-value-uza">${value.toFixed(1)}</output>`;
    const field = htl.html`<label class="p3-control-uza">
      <span>${name}</span>
      ${control}
      ${valueNode}
    </label>`;

    return { field, control, valueNode };
  };

  const aControl = makeRange("a", -5, 5, 1);
  const bControl = makeRange("b", -10, 10, -3);
  const cControl = makeRange("c", -10, 10, 2);

  const form = htl.html`<div class="p3-quadratic-panel-uza">
    <div class="p3-controls-uza">
      ${aControl.field}
      ${bControl.field}
      ${cControl.field}
    </div>
  </div>`;

  const update = () => {
    const value = {
      a: Number(aControl.control.value),
      b: Number(bControl.control.value),
      c: Number(cControl.control.value)
    };

    aControl.valueNode.value = value.a.toFixed(1);
    bControl.valueNode.value = value.b.toFixed(1);
    cControl.valueNode.value = value.c.toFixed(1);
    form.value = value;
    form.dispatchEvent(new CustomEvent("input"));
  };

  [aControl, bControl, cControl].forEach(({ control }) => {
    control.addEventListener("input", update);
  });

  update();
  return form;
}

{
  const { a, b, c } = coeficientes;
  const curve = Array.from({ length: 401 }, (_, i) => {
    const x = -10 + i * 0.05;
    return { x, y: a * x * x + b * x + c };
  });

  const discriminante = b * b - 4 * a * c;
  const points = [];

  if (a !== 0 && discriminante >= 0) {
    const raiz1 = (-b + Math.sqrt(discriminante)) / (2 * a);
    const raiz2 = (-b - Math.sqrt(discriminante)) / (2 * a);
    points.push({ x: raiz1, y: 0, label: `x=${raiz1.toFixed(2)}` });
    if (discriminante > 0) points.push({ x: raiz2, y: 0, label: `x=${raiz2.toFixed(2)}` });
  } else if (a === 0 && b !== 0) {
    const raiz = -c / b;
    points.push({ x: raiz, y: 0, label: `x=${raiz.toFixed(2)}` });
  }

  const plot = Plot.plot({
    height: 360,
    grid: true,
    marginLeft: 42,
    marginRight: 18,
    x: { domain: [-10, 10], label: "x" },
    y: { domain: [-10, 10], label: null },
    marks: [
      Plot.ruleY([0], { stroke: "#94a3b8", strokeWidth: 1.4 }),
      Plot.ruleX([0], { stroke: "#94a3b8", strokeWidth: 1.4 }),
      Plot.line(curve, { x: "x", y: "y", stroke: "#1f5f8b", strokeWidth: 3 }),
      Plot.dot(points, { x: "x", y: "y", fill: "#d94841", r: 6, stroke: "white", strokeWidth: 2 }),
      Plot.text(points, { x: "x", y: "y", text: "label", dy: -15, fill: "#172033", stroke: "white", strokeWidth: 4, fontWeight: "bold", fontSize: 12 })
    ]
  });

  plot.classList.add("p3-plot-uza");

  const state =
    discriminante > 0 ? "Dos soluciones reales" :
    discriminante === 0 ? "Una solución real" :
    "Sin soluciones reales";

  return htl.html`<div class="p3-plot-card-uza">
    ${plot}
    <div class="p3-discriminant-uza">
      <span>Δ = ${discriminante.toFixed(2)}</span>
      <strong>${state}</strong>
    </div>
  </div>`;
}

Figura 1: Explorador interactivo de una ecuación de segundo grado y de sus raíces reales.

Resolución de la práctica

Para resolver esta práctica se propone implementar tres clases en Java, cada una correspondiente a un nivel de resolución de la ecuación cuadrática.

La solución única o doble de la ecuación se calcula mediante la siguiente fórmula, conocida como la fórmula general:

\[ x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} = \frac{-b \pm \sqrt{\Delta}}{2a} \]

El valor dentro de la raíz cuadrada, \(b^2 - 4ac\), se llama discriminante (\(\Delta\)) y determina el número de soluciones reales que tiene la ecuación.

Clases en Java

Recuerda que una clase en Java toma el siguiente formato general:

public class NombreDeLaClase {
    /*
     * @author: Vuestros nombres
     * @date: Fecha de entrega
     */
    public static void main(String[] args) {
        // solucion del problema
    }
}

Clase 1: dos soluciones reales

Si \(\Delta > 0\), la ecuación tiene dos soluciones reales distintas. Estas soluciones se calculan con la fórmula general utilizando el signo \(+\) para una raíz y el signo \(-\) para la otra.

Notas para resolver el problema

• Supondremos que solo hay raíces reales.
• Lee los coeficientes del polinomio.
• Aplica las fórmulas para calcular las dos soluciones.
• Escribe las soluciones por pantalla.

Leer datos en Java

Utiliza la clase Scanner para leer los coeficientes del polinomio desde la entrada estándar:

Scanner scanner = new Scanner(System.in);
System.out.print("Introduce el coeficiente a: ");
double a = scanner.nextDouble();

Imprimir resultados en Java

Utiliza la consola para mostrar los resultados:

System.out.println("La solucion es: " + x);

A continuación se muestra una posible solución en pseudocódigo:

Programa Raices1   { Funciona si solo hay raices reales }

Definicion de variables
    reales: coefA, coefB, coefC;
    reales: discriminante, denominador;
    reales: raiz1, raiz2;

Principio del algoritmo

    lee(coefA, coefB, coefC);

    discriminante := pow(coefB, 2) - (4.0 * coefA * coefC);
    denominador := 2.0 * coefA;

    raiz1 := (-coefB + sqrt(discriminante)) / denominador;
    raiz2 := (-coefB - sqrt(discriminante)) / denominador;

    escribe(raiz1, raiz2);

fin

Comprobación

Verifica la solución con los siguientes coeficientes:

\(a=1, \quad b=-3, \quad c=2\)

El resultado esperado son dos soluciones reales: \(x=1\) y \(x=2\).

Clase 2: una solución real o dos soluciones reales

Si \(\Delta = 0\), la ecuación tiene una única solución real. En este caso, los signos \(+\) y \(-\) de la fórmula general producen el mismo resultado.

Notas para resolver el problema

• Calcula las raíces cuando \(\Delta \geq 0\).
• Si \(\Delta > 0\), escribe las dos soluciones reales.
• Si \(\Delta = 0\), escribe la solución única.
• Si \(\Delta < 0\), escribe un mensaje indicando que no hay raíces reales.

Programa Raices2   { Funciona si hay raices reales; si no, mensaje de error }

Definicion de variables
    reales: coefA, coefB, coefC;
    reales: discriminante, denominador;
    reales: raiz1, raiz2;

Principio del algoritmo

    lee(coefA, coefB, coefC);

    discriminante := pow(coefB, 2) - (4.0 * coefA * coefC);

    si discriminante > 0.0 entonces
        principio
            denominador := 2.0 * coefA;
            raiz1 := (-coefB + sqrt(discriminante)) / denominador;
            raiz2 := (-coefB - sqrt(discriminante)) / denominador;
            escribe(raiz1, raiz2);
        fin
    sino si discriminante == 0.0 entonces
        principio
            denominador := 2.0 * coefA;
            raiz1 := -coefB / denominador;
            escribe(raiz1);
        fin
    sino
        escribe("Este polinomio no tiene raices reales");
    fin
fin

Comprobación

Verifica la solución con los siguientes coeficientes:

\(a=1, \quad b=-2, \quad c=1\)

El resultado esperado es una única solución real: \(x=1\).

Clase 3: solución completa

Si \(\Delta < 0\), la ecuación no tiene soluciones reales, ya que la raíz cuadrada de un número negativo no es un número real.

En este caso, se pueden calcular las soluciones complejas utilizando números imaginarios:

\[ x = \frac{-b \pm i\sqrt{-(b^2 - 4ac)}}{2a} = \frac{-b \pm i\sqrt{4ac - b^2}}{2a} \]

Las dos soluciones complejas conjugadas se pueden expresar como:

\[ \begin{aligned} x_1 &= \frac{-b + i\sqrt{4ac - b^2}}{2a} = \frac{-b}{2a} + i\frac{\sqrt{4ac - b^2}}{2a} \\ x_2 &= \frac{-b - i\sqrt{4ac - b^2}}{2a} = \frac{-b}{2a} - i\frac{\sqrt{4ac - b^2}}{2a} \end{aligned} \]

Notas para resolver el problema

• Calcula las raíces en todos los casos.
• Si \(\Delta > 0\), escribe las dos soluciones reales.
• Si \(\Delta = 0\), escribe la solución única.
• Si \(\Delta < 0\), escribe las dos soluciones complejas conjugadas.

Programa Raices3   { Funciona si hay raices reales o complejas }

Definicion de variables
    reales: coefA, coefB, coefC;
    reales: discriminante, denominador;
    reales: raiz1, raiz2, parteReal, parteImaginaria;

Principio del algoritmo

    lee(coefA, coefB, coefC);

    discriminante := pow(coefB, 2) - (4.0 * coefA * coefC);
    denominador := 2.0 * coefA;

    si discriminante > 0.0 entonces   { Raices reales }
        principio
            raiz1 := (-coefB + sqrt(discriminante)) / denominador;
            raiz2 := (-coefB - sqrt(discriminante)) / denominador;
            escribe(raiz1, raiz2);
        fin
    sino si discriminante == 0.0 entonces   { Raiz unica real }
        principio
            raiz1 := -coefB / denominador;
            escribe(raiz1);
        fin
    sino   { Raices complejas }
        principio
            parteReal := -coefB / denominador;
            parteImaginaria := sqrt(-discriminante) / denominador;

            escribe("(", parteReal, " + ", parteImaginaria, "i)");
            escribe("(", parteReal, " - ", parteImaginaria, "i)");
        fin
    fin
fin

Comprobación

Verifica la solución con los siguientes coeficientes:

\(a=1, \quad b=0, \quad c=1\)

Las soluciones esperadas son:

\[ x_1 = i,\qquad x_2 = -i \]

Entrega de la práctica

La práctica se entregará a través de la plataforma de la asignatura, con un fichero .zip que contenga las tres clases Java implementadas.

• Solucion1.java para el caso de dos soluciones reales.
• Solucion2.java para el caso de discriminante no negativo, es decir, una o dos soluciones reales.
• Solucion3.java para el caso completo, con soluciones reales o complejas.

Solo realizará la entrega de la práctica un miembro del grupo.