Resolver la ecuación cuadrática en C ++

Question

Estoy tratando de escribir una función en C ++ que resuelve para x usando la ecuación de segundo grado. Esto es lo que he escrito en un principio, que parece funcionar, siempre y cuando no hay números complejos por respuesta:

float solution1 = (float)(-1.0 * b) + (sqrt((b * b) - (4 * a * c)));
solution1 = solution1 / (2*a);

cout << "Solution 1: " << solution1 << endl;

float solution2 = (float)(-b) - (sqrt((b*b) - (4 * a * c)));
solution2 = solution2 / (2*a);
cout << "Solution 2: " << solution2;

Si, por ejemplo, uso de la ecuación:. X ^ 2 - x - 6, consigo la solución 3, -2 correctamente

Mi pregunta es ¿cómo tener en cuenta que para los números complejos .... por ejemplo, dada la ecuación:

x ^ 2 + 2x + 5

Solución de la mano, me gustaría tener -1 + 2i, -1 -. 2i

Bueno, supongo que dos preguntas, puedo escribir lo anterior mejor y también hacer que cuenta para el número complejo?

Gracias por cualquier ayuda!

Answer 1

Algo como esto funcionaría:

struct complex { double r,i; }
struct pair<T> { T p1, p2; }

pair<complex> GetResults(double a, double b, double c)
{
  pair<complex> result={0};

  if(a<0.000001)    // ==0
  {
    if(b>0.000001)  // !=0
      result.p1.r=result.p2.r=-c/b;
    else
      if(c>0.00001) throw exception("no solutions");
    return result;
  }

  double delta=b*b-4*a*c;
  if(delta>=0)
  {
    result.p1.r=(-b-sqrt(delta))/2/a;
    result.p2.r=(-b+sqrt(delta))/2/a;
  }
  else
  {
    result.p1.r=result.p2.r=-b/2/a;
    result.p1.i=sqrt(-delta)/2/a;
    result.p2.i=-sqrt(-delta)/2/a;
  }

  return result;
}

De esta manera se obtiene los resultados de una manera similar para los resultados reales y complejos (los resultados reales sólo tienen la parte imaginaria puesto a 0). Se vería aún más bonita con el impulso!

edit: fijado para la cosa delta y ha añadido un cheque de casos degenerados como a = 0. Sin dormir la noche dt!

Answer 2

Una nota importante a todo esto. Las soluciones que se muestran en estas respuestas y en la pregunta original no son robustos.

La solución bien conocida (- b + - sqrt (b ^ 2 - 4ac)) / 2a es conocido por ser no robusto en el cálculo cuando AC es muy pequeña competían a b ^ 2 , porque uno está restando dos valores muy similares. Es mejor utilizar la solución menos conocido 2c /. (-B - + sqrt (b ^ 2 -4ac)) para la otra raíz

una solución sólida se puede calcular como:

temp = -0.5 * (b + sign(b) * sqrt(b*b - 4*a*c);
x1 = temp / a;
x2 = c / temp;

El uso de señal (b) se asegura de que no estamos restar dos valores similares.

Para el OP, modificar este para los números complejos como se muestra por otros carteles.

Answer 3

más o menos lo tiene, simplemente comprobar para ver si la parte que está dentro de la raíz cuadrada es negativo y luego hacer un seguimiento de esa forma separada en sus reducciones.

Answer 4

Se podría básicamente sólo tiene que utilizar en lugar de std::complex<float> float obtener apoyo para los números complejos.

Answer 5

mellar la idea de Blindy:

typedef std::complex<double> complex;
using std::pair;
pair<complex> GetResults(double a, double b, double c)
{
  double delta=(b*b-4*a*c);
  double inv_2a = 1/2/a;
  if(delta >= 0) {
    double root = sqrt(delta);
    return std::make_pair(
        complex((-b-root)*inv_2a),
        complex((-b+root)*inv_2a);
  } else {
    double root = sqrt(-delta);
    return std::make_pair(
        complex(-b*inv_2a, -root*inv_2a)),
        complex(-b*inv_2a, +root*inv_2a)));
  }
}

Answer 6

He probado el programa sin el uso de cabecera '' math.h y también trató lógica diferente ... pero mi programa puede contestar sólo aquellas ecuaciones de segundo grado que tienen coeficiente de 'x cuadrado' como uno ..... y donde el coeficiente de 'x' se puede expresar como una suma de dos números que son factores de término constante. p.ej. x cuadrado + 8x + 16;     x cuadrado + 7x + 12; etc. aquí 8 = 4 + 4 y 16 = 4 * 4; aquí el coeficiente de x puede ser expresada como una suma de dos números que son factores de término constante 16 ... Yo mismo no está completamente satisfecho con ella, pero intentado algo diferente, sin necesidad de utilizar la fórmula para resolver la ecuación cuadrática. código es;

        #include<iostream.h>
        #include<conio.h>
         class quadratic
              {
                int b,c ;
                float l,k;
                public:
               void solution();
              };
        void quadratic::solution()
             {
                 cout<<"Enter coefficient of x and the constant term of the quadratic eqn where coefficient of x square is one";
                 cin>>b>>c;

                 for(l=1;l<b;l++)
                  {
                   for(k=1;k<b;k++)
                    {
                     if(l+k==b&&l*k==c)
                        {
                          cout<<"x="<<-l<<"\t"<<"or"<<"\t"<<"x="<<-k;
                          cout<<"\n";
                         }
                    }
                }
            }
              void main()
                 {
                  quadratic a;
                   clrscr();
                  a.solution();
                  getch();
                 }