C/Visual C - calculo de raices

como le hago que dado un polinomio de grado n sea completo o incompleto saber el numero de raices y sus intervalos correspondientes

intento hacer el metodo de biseccion, pero me piden que de entrada los intervalos no los deduzca sino que el programa los calcule, y no se como, alguien que sepa como calcular raices????

esto es lo que llevo:

#include<conio.h>
#include<alloc.h>
#include<stdio.h>
#include<math.h>

#define false 0

struct ecua
{
int expon;
int coefi;
}
*D;

//PROTOTIPO DE FUNCIONES
void captura(struct ecua D[],int tam,int pos);
void mostrar_polinomio(struct ecua D[],int tam,int pos);
int simplifica_polinomio(struct ecua D[],int tam);
void ordenar_polinomio(struct ecua D[],int tam);
void evaluar(struct ecua D[],int vx,int indice);
float evalua_intervalo( float vx, int tam );

//FUNCION PRINCIPAL
void main()
{
int max,fil=6;
clrscr();
gotoxy(29,3);printf("ALGORITMO DE BISECCION");
gotoxy(3,6);printf("CUANTOS TERMINOS ? ");
scanf("%d",&max);
//DEFINIMOS TAMA¥O DE LA ESTRUCTURA
D = (struct ecua*) malloc(max);
//LLENAMOS EL POLINOMIO
captura(D,max,8);
//CALCULAMOS....
float pn=0, a , b , fpn ,TOL ;
gotoxy(3,fil+1);printf("Intervalo a: ");scanf("%f",&a);
gotoxy(3,fil+2);printf("Intervalo b: ");scanf("%f",&b);
gotoxy(3,fil+4);printf("Tolerancia: "); scanf("%f",&TOL);
gotoxy(3,fil+6);printf("Intervalos [%.1f ,%.1f]",a,b);
gotoxy(8,fil+9);printf("N"); gotoxy(18,fil+9);printf("An");
gotoxy(30,fil+9);printf("Bn"); gotoxy(45,fil+9);printf("Pn");
gotoxy(60,fil+9);printf("F(Pn)");
int i=0,f=fil+11,flag=0;

do
{
gotoxy(8,f);printf("%d",i+1);
gotoxy(15,f);printf("%.6f",a);
gotoxy(27,f);printf("%.6f",b);
gotoxy(42,f);printf("%.6f", pn= (a + b)/2.0);
//Se evalua el intervalo fpn en el polinomio
fpn=evalua_intervalo(pn,max);
gotoxy(57,f);printf("%.6f",fpn);
if( fpn==0 )
{
gotoxy(25,f+3);printf("Se Complet¢ Satisfactoriamente");
gotoxy(27,f+4);printf("el algoritmo de Biseccion");
break;
}
//Se definen nuevamente los intervalos
else
{
if( fpn>0 )
{
b=pn;
}
else
{
a=pn;
}
}
i++;
f++;
}
while( ((fpn >= (TOL * -1)) && (fpn <= TOL ))==false );
getch();
}

//EVALUA EL INTERVALO (a+b)/2
float evalua_intervalo( float vx, int tam )
{
float res=0.0;
for (int x=0;x<tam;x++)
{
res = res + (D[x].coefi * pow(vx,D[x].expon));
}
return res;
}

void captura(struct ecua D[],int tam, int pos)
{
int x,f=pos;
for (int i =0 ;i< tam ;i++)
{
gotoxy(3,f); printf("Termino %d ",i+1);
gotoxy(5,f+2);printf("Coeficiente: "); scanf("%d",&D[i].coefi);
gotoxy(5,f+3);printf("Exponente: "); scanf("%d",&D[i].expon);
f+=5;
}
gotoxy(3,f+3);printf("El polinomio desordenado es: ");
mostrar_polinomio(D,tam,f+3);
tam=simplifica_polinomio(D,tam);
tam=simplifica_polinomio(D,tam);
ordenar_polinomio(D,tam);
gotoxy(23,f+5);printf("Pulsa una tecla para continuar...");
getch();
clrscr();
gotoxy(29,3);printf("ALGORITMO DE BISECCION");
gotoxy(3,5);printf("El polinomio es ordenado es: ");
mostrar_polinomio(D,tam,5);
// gotoxy(3,7);printf("Valor de X: ");scanf("%d",&x);
// evaluar(D,x,tam);
}

//MUESTRA EL POLINOMIO EN TERMINOS DE X
void mostrar_polinomio(struct ecua D[],int tam,int pos)
{
char s=' ';
gotoxy(33,pos);
for(int i=0; i<tam;i++ )
{
if(D[i].coefi>=0)
{
s='+';
}
if(D[i].coefi>=0)
{
if( D[i].coefi>=1 && D[i].expon==0 )
printf(" %d %c",D[i].coefi,s);
if( D[i].coefi>1 && D[i].expon>1 )
printf(" %dx^%d %c",D[i].coefi,D[i].expon,s);
if( D[i].coefi==1 && D[i].expon>1 )
printf(" x^%d %c",D[i].expon,s);
if( D[i].coefi>1 && D[i].expon==1 )
printf(" %dx %c",D[i].coefi,s);
if( D[i].coefi==1 && D[i].expon==1 )
printf(" x %c",s);
}

else
{
if( D[i].coefi<0 && D[i].expon==0 )
printf(" %d +",D[i].coefi);
if( D[i].coefi<0 && D[i].expon>1 )
printf(" %dx^%d +",D[i].coefi,D[i].expon);
if( D[i].coefi==-1 && D[i].expon>1 )
printf(" x^%d +",D[i].expon);
if( D[i].coefi<-1 && D[i].expon==1 )
printf(" %dx +",D[i].coefi);
if( D[i].coefi==-1 && D[i].expon==1 )
printf(" - x +");
}

}
}
//SIMPLIFICA O REDUCE EL POLINOMIO EJ: x + x = 2x
int simplifica_polinomio(struct ecua D[],int tam)
{
int aux=tam;
for(int i=0; i<aux;i++ )
{
for(int j=i+1; j<aux;j++ )
{
if(D[i].expon==D[j].expon)
{
D[i].coefi=(D[i].coefi+D[j].coefi);
D[i].expon=D[j].expon;
for(int x=i+1;x<aux;x++)
{
D[x].coefi=D[x+1].coefi;
D[x].expon=D[x+1].expon;
}
aux--;
}
}
}
return aux;
}
//ORDENA EL POLINOMIO POR GRADOS
void ordenar_polinomio(struct ecua D[],int tam)
{
int t_e,t_c;
for(int i=0; i<tam;i++ )
{
for(int j=i+1; j<tam;j++ )
{
if( D[i].expon < D[j].expon )
{
t_e = D[i].expon;
D[i].expon=D[j].expon;
D[j].expon=t_e;
t_c = D[i].coefi;
D[i].coefi=D[j].coefi;
D[j].coefi=t_c;
}
}
}
}
//EVALUA EL POLINOMIO DANDOLE UN VALOR
void evaluar(struct ecua D[],int vx,int indice)
{
int res=0;
for (int x=0;x<indice;x++)
{
res = res + (D[x].coefi * pow(vx,D[x].expon));
}
gotoxy(3,9);printf("%i Evaluado en polinomio es: %d",vx, res);
}

Una posibilidad para hallar el rango es tomar el intevalo -B, B
siendo B = ( A / |a0| ) + 1

Coeficientes del polinomio a3, a2, ... + a(n-1), an

A = | coef. mayor | (mayor coef. en valor absoluto)
a0 es el término independiente

ej: p(x) = x^3 - 5 x^2 + 2x + 1

|a0| = 1, A = 5 y B = 6, luego el rango es [-6, 6]

Generalmente el rango es muy amplio, pero bueno, es lo que hay...

Hay varios teoremas acerca del cálculo de raíces, busca información que seguro
vas a encontrar mucho...

Saludos desde Baires, JuanC

grax pero necesito saber cuantas raices tiene un polinomio y sus intervalos de cada una de las raices...

me urge =(...

no importa si la raiz o real o compleja , quiero saber si existe y su intervalo...

para cualquier polinomio, sea completo o incompleto.. graxias por responder Sr. JuanC

un polinomio de grado n tiene n raices, reales y/o complejas
para hallar los rangos se puede hacer mediante derivadas...

Saludos desde Baires, JuanC

Lo que estas preguntando es mas de matematicas que de programacion ;) :P

Yo para halar las raices siempre me ponia a sacar factor comun y descomponer al maximo el polinomio en productos pequenyos. Luego aplicabamos un metodo que consistia en poner el coeficiente de cada grado de "X" y buscar aquel que te daba un cero al final haciendo simples sumas y restas, creo recordar el "metodo ruffini"??. Pongo un ejemplo.

x^3 + 2x^2 - 1

1 2 0 -1
-1 -1 -1 +1
1 1 -1 0

La primera linea es el polinomio, el primer numero de la segunda linea es el que yo pruebo, lo que hago es tomar el primero, lo multiplico por el que yo elegi, se lo sumo al segundo de la primera linea y me da el de la tercera, lo vuelvo a multiplicar y se lo pongo en el siguiente puesto de la segunda fila, asi hasta conseguir un cero al final de la tercera linea.

con eso, el polinomio queda como:

(x - (-1)) (x^2 + x - 1). Es decir que -1 es raiz de ese polinomio. Creo que ya hay algortimos para realizar este metodo en internet, echa un vistazo. Con ello sacarias todas las raices reales. Para las imaginarias debe de haber algun otro metodo, o reducirlo a un grado multiplo de 2 e ir haciendo cambios de variables con x^2 = t y aplicar la tipica de "menos B mas menos raiz cuadrada de (B al cuadrado menos 4AC) partido por 2A"

HECHALE GANAS DUQUE!!!
ANIMO!!!

JEJEJEJE