Los algoritmos para simplificar un producto son similares a los de la suma, para iniciar se deben seguir varias reglas b´asicas del producto:
Asociatividad: a· (b · c) = (a · b) · c = a · b · c
Es decir, un producto se puede representar con una sola cabecera con todos sus sumandos a un mismo nivel, tal como se muestra en la figura 1.2 en donde en ambos casos se representa el mismo producto.
Algoritmo 1.14: UnirSumas input : a, b: Dos sumas output: La sumas unidas if Tipo(a)6=“Suma” then 1
a=Suma(a);
2
else if Tipo(b)6=“Suma” then 3 b=Suma(b); 4 respuesta=Suma(vac´ıo); 5 i=1; 6 j=1; 7
while i <=numeroOperandos(a) Y j <=numeroOperandos(a) do 8 comodin=Suma(a.Operando(i), b.Operando(j)); 9 comodin=simplificaSumaRecursiva(comodin); 10 if numeroOperandos(comodin)=0 then 11 i++; 12 j++; 13
else if numeroOperandos(comodin)=1 then 14 respuesta.agrega(comodin.Operando(1)); 15 i++; 16 j++; 17
else if comodin.Operando1=a.Operando(i) then 18
respuesta.agrega(comodin.Operando(1));
19
i++;
20
else if comodin.Operando1=b.Operando(i) then 21 respuesta.agrega(comodin.Operando(1)); 22 j++; 23 if i <=numeroOperando(a) then 24
for (; i <=numeroOperando(a); i++) do 25
respuesta.agrega(a.Operando(i));
26
else if j <=numeroOperando(b) then 27 for (; j <=numeroOperando(b); j++) do 28 respuesta.agrega(b.Operando(j)); 29 return respuesta; 30
1.1. SIMPLIFICACI ´ON AUTOM ´ATICA 21
Algoritmo 1.15: termino input : u: Una expresi´on
output: El t´ermino algebraico de la multiplicaci´on
if Tipo(u)∈{N´umero} then 1
return “Indefinido”; 2
else if Tipo(u)=“Producto” then 3
if Tipo(u.Operando(1))∈ { N´umero } then 4 return u.eliminaOperando(1); 5 else 6 return u; 7 else 8 return Producto(u); 9 Algoritmo 1.16: constantes input : u: Una multiplicaci´on
output: La constante de la multiplicaci´on
if Tipo(u)∈{N´umero} then 1
return “Indefinido”; 2
else if Tipo(u)=“Producto” then 3
if Tipo(u.Operando(1))∈ { N´umero } then 4
return u; 5
return 1; 6
Algoritmo 1.17: simplificarNumerosSuma input : u: Una suma de n´umeros
output: La suma simplificada a=u.Operando(1);
1
b=u.Operando(2);
2
if Tipo(a)∈{“Indefinido”, “Booleano”} O Tipo(b)∈{“Indefinido”, 3
“Booleano”} then return “Indefinido; 4
else if Tipo(a)=Entero Y Tipo(b)=Entero then 5
return Entero(a+b); 6
else if Tipo(a)=Decimal O Tipo(b)=Decimal then 7
if Tipo(a)=Racional then 8
solucion= a.Operando(1)/a.Operando(2)+b;
9
else if Tipo(b)=Racional then 10 solucion= a+b.Operando(1)/b.Operando(2); 11 else 12 solucion= a+b; 13 return EnteroODecimal(solucion); 14 else 15 if Tipo(a)=Entero then 16 solucion= Racional(a)+b ; 17
else if Tipo(b)=Entero then 18 solucion= a+Racional(b) ; 19 else 20 solucion= a+b; 21 if Denominador(solucion)=1 then 22 return Entero(Numerador(solucion)); 23 else 24 return solucion; 25 Algoritmo 1.18: simplificarResta
input : a, b: Las expresiones para restar output: La resta simplificada
if Tipo(a)∈{“Indefinido”, “Booleano”} O Tipo(b)∈{“Indefinido”, 1 “Booleano”} then return “Indefinido”; 2 else 3 return simplifica(Suma(a,Producto(-1,b))); 4
1.1. SIMPLIFICACI ´ON AUTOM ´ATICA 23
Algoritmo 1.19: simplificarNumerosResta input : a, b: Las expresiones para restar output: La resta simplificada
if Tipo(a)∈{“Indefinido”, “Booleano”} O Tipo(b)∈{“Indefinido”, 1 “Booleano”} then return “Indefinido”; 2 else 3 return simplifica(Suma(a,Producto(-1,b))); 4
Figura 1.2: Asociatividad de la suma
Esta propiedad se utiliza para acomodar los t´erminos de acuerdo a la prioridad, tomando el caso de la figura 1.2, el programa acomodar´ıa el producto 1· x · a como 1 · a · x
Neutro: 1· a = a · 1 = a
Si uno de los t´erminos es uno simplemente se elimina. Inverso: a +(a−1)=(a−1)+ a = 1
Si se tiene un t´ermino y su inverso multiplicativo entonces da uno y, por la propiedad anterior, se elimina de un producto.
Producto por el neutro de la suma: 0· a = a · 0 = 0
Si alguno de los t´erminos de una multiplicaci´on es cero entonces el pro- ducto es cero.
Si al eliminar los unos y los inversos queda s´olo un elemento entonces se de- vuelve ese elemento, es decir, se quita la cabecera del producto. Si no qued´o ning´un elemento se devuelve un uno (el neutro de la suma).
El algoritmo 20 es el programa principal para simplificar el producto. En un inicio se verifica si alguno de los t´erminos es indefinido o un booleano, en ese caso se devuelve indefinido, el resto llama a la funci´on simplificaProductoRecursiva para hacer la simplificaci´on. La variable esCero se utiliza para determinar si alguno de los t´erminos de la multiplicaci´on es un cero, si es as´ı se devuelve un cero.
El algoritmo 21 presenta el programa simplificaMultiplicacionRecursiva. La idea de esta funci´on es ir trabajando s´olo dos t´erminos a la vez, por lo que, si hay
Algoritmo 1.20: simplificarProducto input : u: Un producto
output: El producto simplificado
esCero=falso;
1
foreach Sumando(u) do 2
if Tipo(u) ∈ { Indefinido, Booleano } then 3
return “Indefinido” 4
else if u=0 then 5 esCero=verdadero; 6 if esCero=verdadero then 7 return 0; 8
else if numeroOperandos(u)=1 then 9 return u.Operando(1); 10 else 11 simplificado=simplificaMultiplicacionRecursiva(u); 12 if Tipo(simplificado)=“Indefinido” then 13 return “Indefinido”; 14
else if numeroOperandos(simplificado)=0 then 15
return 1; 16
else if numeroOperandos(simplificado)=1 then 17 return simplificado.Operando(1); 18 else 19 return simplificado; 20
1.1. SIMPLIFICACI ´ON AUTOM ´ATICA 25 m´as, entonces se quita el primero y se llama de manera recursiva a la funci´on (por eso su nombre), esto se hace de la l´ınea 41 en adelante, esto permite ir simplificando y acomodando los t´erminos f´acilmente. Si alguno de los sumandos es un producto (tal como se mostr´o en la figura 1.2), entonces se deben unir las multiplicaciones, esto lo hace la funci´on UnirMultiplicaciones que se muestra en el algoritmo 25.
Las funciones que multiplican dos matrices, una expresi´on por una matriz y una multiplicaci´on de dos listas se muestran m´as adelante en los algoritmos 23, 22 y 24.
En la l´ınea 35 se verifica si el operando2 tiene prioridad sobre el operando1, si es as´ı hay que darles vuelta.
En el caso de la l´ınea 29 es cuando se realiza la multiplicaci´on an·am= am+n, si la potencia da uno se devuelve un producto vac´ıo (la funci´on que la recibe la devuelve como uno).
El algoritmo 22 es el que realiza la multiplicaci´on de un t´ermino por una matriz, en este caso el t´ermino se multiplica por cada elemento de la matriz.
El algoritmo 23 es el que realiza la multiplicaci´on de dos matrices.
El algoritmo 24 es el que realiza la multiplicaci´on de dos listas, en este caso el resultado es una lista llena de pares ordenados (en este caso se representan como matrices de dos elementos) representando la combinaci´on de las listas, en donde a cada elemento x de la primera lista se le colocan los elementos de la segunda lista como y.
El algoritmo 25 se utiliza para unir dos multiplicaciones en una sola acomo- dando y simplificando los t´erminos. Lo primero es revisar si ambas expresiones que se reciben son productos, sino se convierten en productos. Luego se van tomando los t´erminos en parejas (uno de a y uno de b) y se simplifican, luego se pasan a los siguientes t´ermnos dependiendo de la simplificaci´on que se ha- ya realizado. Cuando se acaban los t´erminos una de las expresiones se agregan todos los t´erminos de la segunda expresi´on.
Las funciones base y exponente ya se hab´ıan definido previamente, sus algo- ritmos son los n´umero 8 y 9.
Si la expresi´on representa una multiplicaci´on de n´umeros entonces se debe realizar el procedimiento que se muestra en el algoritmo 26. Cuando alguno de los t´erminos es un decimal el resultado se debe revisar si es decimal o entero, esto se debe hacer en la l´ınea 14, en java lo que se hace es tratar de convertir el decimal a entero, si se puede se devuelve como entero, si lanza una excepci´on entonces se devuelve como decimal. La l´ınea 15 se corre cuando alguno de los n´umeros (o ambos) es racional, en este caso se pasan ambos n´umeros a racionales y se multiplican.