Java - Algoritmo factorización polinomios

   
Vista:

Algoritmo factorización polinomios

Publicado por Juan Sánchez (4 intervenciones) el 19/12/2015 00:42:25
Buenas noches a todos

Soy nuevo en el foro. Quería pedirles ayuda.
Necesito programar una calculadora de polinomios en JAVA como trabajo de una asignatura de primer año de Ing. Telecomunicaciones.

Es necesario que la calculadora suma,reste,multiplique,derive y factorice diferentes polinomios de grado menor o igual que 20. Tengo todo terminado excepto la factorización, que no consigo sacarla, el algoritmo.

Se nos proporcionaba como base dos métodos:
- ParsePolinomio: Convierte String introducido por el usuario en un vector donde los indices son los grados de las "x" y los coeficientes de las mismas son los valores de las componentes.
-ToString: Lleva a cabo el camino inverso, es decir, pasa el vector a cadena de texto.

El metodo de la factorización debe, no sólo factorizar el polinomio, sino también mostrar el proceso de la factorización(factor común y Ruffini). Es necesario usar una matriz o arreglo de arreglo.
Les dejo lo que me piden en el guión del trabajo.

/**
* Factorización de un polinomio
* @see Utiliza el método Ruffini
* @see Muestra por pantalla el proceso seguido para la factorización por ruffini
* Factorización:
* Polinomio a factorizar = 2,0X^5+X^4-8,0X^3-X^2+6,0X
* 1. Factor Común
* X(2,0X^4+X^3-8,0X^2-X+6,0)
* 2. Ruffini
* X(2,0X^4+X^3-8,0X^2-X+6,0)
* | 2.0 1.0 -8.0 -1.0 6.0
* 1 | 2.0 3.0 -5.0 -6.0
* ___________________________________________________________
* | 2.0 3.0 -5.0 -6.0 0.0
*
* | 2.0 3.0 -5.0 -6.0
* -1 | -2.0 -1.0 6.0
* ___________________________________________________________
* | 2.0 1.0 -6.0 0.0
*
* | 2.0 1.0 -6.0
* -2 | -4.0 6.0
* ___________________________________________________________
* | 2.0 -3.0 0.0
*
* X (X-1,0)(X+1,0)(X+2,0)(2,0X-3,0)
* @param p polinomio a factorizar
* @return float [][] array de polinomios que representan la factorizacion de p
*/
public static float[][] factorizacion(float[] p)
{

}

Espero que puedan ayudarme. No obstante, sigo trabajando en ello para intentar conseguirlo por mi mismo. El problema es que lo tengo que tener terminado para el día 22.

Muchas gracias por su atención
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alberto

Algoritmo factorización polinomios

Publicado por Alberto albertdtorres1@gmail.com (7 intervenciones) el 19/12/2015 18:41:17
Hola, para que el algoritmo sea mas simplificado debes tener en cuanta
que las posibles raíces a evaluar por el método de ruffini deben ser divisores
del termino independiente.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Algoritmo factorización polinomios

Publicado por Juan Sanchez (4 intervenciones) el 19/12/2015 20:15:29
Gracias por contestar.
Ya lo he tenido en cuenta.
Primero calculo los divisores y después con el Teorema del Resto veo cuales son raíces y cuales no.
El problema lo encuentro cuando tengo que mostrar explícitamente el proceso de Ruffini que haríamos a mano en papel.
Sé que hay que hacerlo con arreglos de arreglos pero no consigo encontrar un código general para cada división por Ruffini

Muchas gracias Alberto
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Jordi

Algoritmo factorización polinomios

Publicado por Jordi (38 intervenciones) el 19/12/2015 21:33:18
Una vez sabes las raíces de cada polinomio, puedes empezar a hacer Ruffini. Sabes cuándo tienes que multiplicar y cuándo tienes que sumar.

Puedes tener 3 arrays de integers: uno con el polinomio a factorizar (línea superior), otro con la línea inferior y otro con la línea de "resultados". Cuando tengas todo el proceso hecho, puedes mostrar por pantalla los vectores y tendrás la primera iteración de Ruffini. Cuando vayas a hacer la segunda, haces lo mismo, solo que la última línea ahora será la primera, con una posición menos (la última, que es el resto). Y lo vas printando todo sobre la marcha. Al final sólo es hacer unos bucles hasta terminar con todas las raíces.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Algoritmo factorización polinomios

Publicado por Juan Sanchez (4 intervenciones) el 19/12/2015 21:47:48
Muchisimas gracias Jordi.

Esa era la idea que tenía ayer(solo que trabajando con arrays de reales, por lo que no creo que haya problemas).
Estructurando el codigo con un while que se repitiese para cada una de las raices(por lo que para cada raíz se construyen 3 vectores, el original(o el resultado de la iteracion anterior), el de lo que se suma, el del resultado. Al final de la iteracion asignaba al polinomio original el array del resultado de la iteracion.
El caso es que me piden imprimirlo una vez terminada la factorización, es decir, de golpe, teniendo un arreglo de arreglos en el que estén todas las operaciones y resultados.
Agradecería muchisimo que pudieses escribirme un esquema del codigo o parte de el(el de una iteración).

Muchas gracias a todos
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Algoritmo factorización polinomios

Publicado por Juan Sanchez (4 intervenciones) el 20/12/2015 03:16:31
He programado estos métodos
Pero el de la factorización debe estar incorrecto, ya que no funciona como debería.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/**
* Factor Común
* 
* @param p
*            Polinomio a sacar factor común
*
* @return int Número de factores x comunes a los monomios de p (grado de x)
*/
public static int factorcomun(float[]p){
	int factoresx=0;
	while(p[0]==0){
		for(int i=1;i<p.length;i++){
			p[i-1]=p[i];
 
		}
		factoresx++;
	}
 
	return factoresx;
}
 
/**
* Raíces de un polinomio
* 
* @param p
*            Polinomio a obtener raíces
*
* @return float[] Vector de reales cuyas componentes son las raíces del polinomio p
*/
public static float[] raices(float[]p){
 
	//GRADO POLINOMIO P
	int grado=0;
	for(int i=0;i<p.length;i++){
		if (p[i]!=0){grado=i;}
	}
	//CALCULO DIVISORES
	float divisores[]=new float[2*Math.abs((int)p[0])];
	float divisor=1;
	int i=0;
	while(divisor<Math.abs(p[0])){
		if(p[0]%divisor==0){
			divisores[i]=divisor;
			divisores[i+1]=-divisor;
		}
		divisor++;
		i=i+2;
	}
 
	//CALCULO RAICES
	float raices[]=new float[grado];
	int nraices=0;
	int k=0;
	for(int j=0;j<divisores.length;j++){
	if(divisores[j]!=0){
		if(Polinomio.valor(p,divisores[j])==0){
			raices[k]=divisores[j];
			nraices++;
			k++;
			}
		}
	}
	return raices;
}
 
 
 
/**
* Factorización de un polinomio
* @see Utiliza el método Ruffini
* @see Muestra por pantalla el proceso seguido para la factorización por ruffini
* Factorización: 
* Polinomio a factorizar = 2,0X^5+X^4-8,0X^3-X^2+6,0X
* 1. Factor Común
* X(2,0X^4+X^3-8,0X^2-X+6,0)
* 2. Ruffini
* X(2,0X^4+X^3-8,0X^2-X+6,0)
* 		|	2.0		1.0		-8.0	-1.0	6.0	
* 1	|			2.0		3.0		-5.0	-6.0	
* ___________________________________________________________
* 		|	2.0		3.0		-5.0	-6.0	0.0	
* 
* 		|	2.0		3.0		-5.0	-6.0	
* -1	|			-2.0	-1.0	6.0	
* ___________________________________________________________
* 		|	2.0		1.0		-6.0	0.0	
* 
* 		|	2.0		1.0		-6.0	
* -2	|			-4.0	6.0	
* ___________________________________________________________
* 		|	2.0		-3.0	0.0	
* 	
* 	X (X-1,0)(X+1,0)(X+2,0)(2,0X-3,0)
* @param p polinomio a factorizar
* @return float [][] array de polinomios que representan la factorizacion de p
*/
public static float[][] factorizacion(float[] p)
{	int gradomaximo=0;
	float raices[]=raices(p);
	int numeroraices=0;
	for(int i=0;i<raices.length;i++){
		if(raices[i]!=0){
			numeroraices++;
		}
	}
	float factorizacion[][]=new float[3*numeroraices][];
	int Ruffini=0;
	int fila=0;
	while(fila<numeroraices){
		//1ªFila
		factorizacion[fila]=new float[gradomaximo+1-Ruffini];
		for(int i=0;i<factorizacion[fila].length;i++){
			factorizacion[fila][i]=p[i];
		}
		fila=fila+2;
		//3ªFila
 
		factorizacion[fila]=new float[gradomaximo-Ruffini];
		for(int i=factorizacion[fila].length;i>0;i--){
			if(i==factorizacion[fila].length){
				factorizacion[fila][i]=factorizacion[fila-2][i+1];
 
			}
			else{factorizacion[fila][i]=factorizacion[fila-2][i+1]+raices[Ruffini]*factorizacion[fila][i+1];
			}
 
		}
		fila--;
		//2ªFila
		factorizacion[fila]=new float[gradomaximo-Ruffini];
		for(int i=factorizacion[fila].length;i>0;i--){
			if(i==0){
				factorizacion[fila][i]=0-factorizacion[fila-1][i];
			}
 
			else factorizacion[fila][i]=factorizacion[fila+1][i-1]-factorizacion[fila-1][i];
 
 
		}
		p=factorizacion[fila];
		fila=fila+2;
 
	}
 
 
 
	return factorizacion;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Algoritmo factorización polinomios

Publicado por Dani (1 intervención) el 29/12/2015 12:08:37
Has encontrado ya solución a la factorización?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar