Check the new version here

Popular channels

Pi Calculo, calculadora de notación polaca inversa(progam C)

resumen



Se desarrolló, a través de VisualStudio 2010, un programa íntegramente en lenguaje C. Este emula una calculadora con una interfaz máquina-usuario simple y amigable. Utiliza algoritmos basados en una pila para el ingreso y proceso de los valores a trabajar. El programa utiliza el método de escritura alternativo llamado Notación Polaca Inversa (RPN), que permite trabajar con expresiones más simples y sin la necesidad de utilizar simbología complementaria como paréntesis, corchetes, etc.



palabras clave.




Notación Polaca Inversa(RPN), Pila, Lenguaje C, Calculadora.



abstract





A program entirely written in C language was developed through VisualStudio2010. This one emulates a calculator with a friendly simple user-machine interface. Algorithms based on stack operations are used in order to work out complex math expressions easily. The program use the method Reverse Polish Notation (RPN) to introduce data, which dispose the expressions of complementary symbols such as parentheses, square brackets, etc.}



keywords



Reverse Polish Notation(RPN), Stack, C Language, Calculator.



Introducción




Durante el desarrollo de la materia informática 1 recibí la propuesta de comenzar a trabajar en un proyecto que contenga en su armado los conceptos teóricos aprendidos durante las clases logrando así articular en un proyecto teoría y practica. Surge la idea de realizar para este proyecto una calculadora, que a partir de ahora llamaremos Pi Calculo.
Pi Calculo se caracteriza por ser una calculadora desarrollada íntegramente en lenguaje de programación C, con una interfaz amigable, sin perder las estructuras formales del método de escritura (notación posfija).




La Pila




Una pila (stack en inglés) es una lista ordenada en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, 'ultimo en entrar, primero en salir) que permite almacenar y recuperar datos.




A qué llamamos calculadora con Notación Polaca Inversa?



Las calculadoras que utilizamos comúnmente evalúan expresiones en notación INFIJA, por ejemplo si queremos sumar a y b, para obtener un resultado c; ingresamos: a + b; con lo cual obtenemos c. Por el contrario las calculadoras de Notación polaca inversa evalúan en notación POSFIJA; es decir para sumar a y b ingresamos: a b +; para luego obtener c como resultado. Como se observa en esta última forma de evaluar los operandos se leen primero y el operador va al final; de allí el nombre de evaluación en notación Posfija.
Existe una tercera forma de evaluar expresiones que es la PREFIJA; as'i para sumar a y b se tiene: + a b; es decir primero va el operador y luego los operandos.



Un ejemplo de Cálculo Polaco Inverso




Ejemplo de expresiones equivalentes en notaciones diferentes



Expresión en notación Infija



begin{equation}
sqrt[3]{{[5*(8+6)/2*(9-8)^2]-8}} =3



Expresión en notación Posfija




5 8 6 +*2/9 8-2p*8-3r=3





Reseña histórica





Hewelett-Packard y la polaca

La calculadora HP-35 usaba una tradicional pantalla de coma decimal flotante para los números que podían ser mostrados en ese formato, pero cambiaba automáticamente a notación científica para otros números. La pantalla LED de quince dígitos era capaz de mostrar un significante (parte significativa) de 10 dígitos más su signo y una coma decimal y un e exponente de dos dígitos más su signo. La pantalla era única en el sentido que la multiplexación fue diseñada para iluminar un solo segmento LED a la vez, en lugar de un solo dígito LED, porque las investigaciones de HP habían mostrado que con este método era percibido por el ojo humano como más brillante para una energía equivalente.

La calculadora usaba tres baterías de NiCd de tamaño "AA" ensambladas en un paquete de batería desprendible, de diseño propietario de HP. Los paquetes de la batería de reemplazo ya no están disponibles, dejando los HP-35 existentes dependiendo de la corriente alterna , o los usuarios deben reconstruir el paquete de baterías por sí mismos usando pilas disponibles. Un cargador de batería externo estaba disponible y la calculadora podía también funcionar desde cargador, con o sin las baterías instaladas.
Internamente, la calculadora fue organizada alrededor de un chipset procesador serial (un bit) procesando números de punto flotante de 56 bits, representando números de 14 dígitos

N HP-35




N HP-35 vista art'iculo nuevo.




N HP-35 vista con su respectiva caja.

Según lo expuesto en el sitio oficial de Hewelett-Packard (HP)

The HP-35 Scientific Calculator, so called because it had 35 keys, was introduced in 1972. It was the world's first handheld scientific calculator. In one of the most amazing displacements in the history of technology, the HP-35 Scientific Calculator electronic calculator, and others like it, quickly replaced the faithful slide rule that had been used by generations of engineers and scientists for rapid calculation and simple computation.
The HP 35 was HP's first product that contained both integrated circuits and LEDs (light-emitting diodes). Both technologies had been developed in HP Labs. Bill Hewlett, who, in 1968, had challenged HP engineers to make a desktop-size computer (the 9100A), challenged them again in 1971 to take that desktop computer and make it small enough to fit into his shirt pocket. When the tiny powerhouse reached the prototype stage, HP asked a local market research firm to do a market study. They did and determined that the HP-35 Scientific Calculator would never sell because it was too expensive. Bill said "We're going to go ahead anyway." The product was so popular that HP couldn't make them fast enough.
Bill remembered, "We figured, in the first year, if we could sell 10,000 calculators, we'd break even. We sold 100,000."
By the time the HP-35 Scientific Calculator was discontinued in 1975, just three and one-half years after its introduction, more than 300,000 had been sold.

ventajas y presentación.

La utilización de Pi Calculo, una calculadora polaca inversa

Al estar pensada con una interfaz amigable su uso puede extenderse tanto a una franja etaria juvenil, como a nostálgicos amantes de los video juegos, o un uso académico, sin perder los funcionamientos básicos de una calculadora de notación polaca inversa.
Está pensada, no sólo para cumplir con el objetivo de calculadora, sino también que su uso resulte agradable por medio de la incorporación de colores llamativos, sonidos de error y melodías programadas que rompen con la concepción estática que un estudiante tiene del entorno c.

Capturas de pantalla

.



Animación de presentación.






Menu de inicio.




Valores en la pila.



Ejemplo infinito.



Animación final con Mario de fondo.


Aspectos a seguir trabajando

Pi Calculo se presenta como una calculadora de codigo abierto esperando una futura continuación de este proyecto a fin de optimizar los recursos que esta calculadora puede ofrecer.



descripción y características técnicas.

Pi Calculo fue programada íntegramente en lenguaje C. Siendo compilada desde Microsoft Visual c++ 2010.
utiliza un método algebraico alternativo: La notación polaca inversa, notación de postfijo, o notación posfija, (en inglés, Reverse Polish notation, o RPN).
Por medio del algoritmo se ingresan los valores de forma ordenada a la pila, trabajando con los últimos dos valores ingresados, guardando el resultado en el espacio de memoria del valor trabajado más antiguo y manteniendo los “desocupados” en valores nulos o 0.
No existen restricciones en cuanto a la cantidad de valores a ingresar, pero hay una capacidad máxima de apilar 5 valores. Los valores ingresados no pueden tener más de 15 cifras, incluidos el punto y el signo negativo. Esto quiere decir que se puede ingresar un número positivo entero de 15 cifras, un número negativo entero de 14 cifras, un número positivo con decimales de 14 cifras total, o un número negativo con decimales de 13 cifras total. Ejemplo “-3.141592653589”.
Las operaciones matemáticas que soporta son la suma, resta, multiplicación, división, potencia y raíz. Los resultados son expresados con sus decimales de ser posible y en casos específicos da como resultado infinito, indefinido o de ser valores muy extensos, hablando de cantidad de cifras, los expresa en notación científica.
Tiene una exactitud de 16 dígitos, en caso de tener más dígitos se pierden datos, pero el resultado es bastante aproximado.
Cuenta con un menú recurrente, tratando de evitar el ingreso incorrecto de datos por parte del usuario. De todos modos, recorta el ingreso a solo un par de teclas habilitadas previamente para minimizar errores. También permite corregir el dato ingresado en tiempo real. En caso de presionar una tecla errónea o intentar ingresar un operador sin tener la cantidad necesaria para operar, Pi Calculo advertirá el error por medio de un mensaje escrito acompañado de una señal sonora que permitirá al usuario dar cuenta del error cometido y permitirá el reingreso del dato sin perder o modificar valores ingresados con anterioridad a la pila. También cuenta con la opción de reinicio sin necesidad de cerrar el programa.
Al iniciar, Pi Calculo, tiene una “animacion de caracteres” con varios colores y al salir cuenta con una nostalgica melodia, también acompañada por cambios bruscos de color al ritmo de la misma.


El codigo.

A continuacion se detalla el codigo.


#include
#include
#include
#include
#include
#include

#define time 100
#define vuelta 2
#define PILA_ALTURA 5
#define TRUE 1
#define FALSE 0

//popotitos


//funciones matematicas
long double multiplicacion(long double, long double);
long double suma(long double, long double);
long double resta(long double, long double);
long double division(long double, long double);
long double potencia(long double, long double);
long double raiz(long double, long double);


//jueguitos
void animacion(void);

void finish(void);

struct number
{
char signo;
char num[15];
short modificado;
};

int main(void)
{
char entrada = 'a', operador = 'a';
struct number temp;
long double pila[PILA_ALTURA] =
{-0, -0, -0, -0, -0};
short i = 0, j, k;

temp.modificado = FALSE;
//inicializar temp
temp.signo = '+';
strcpy_s(temp.num, 15, "");

animacion();

system("cls");
puts("tt!!!!....Bienvenidos a Pi Calculo....!!!!nn");
puts("Ingrese valores.nnPara finalizar un ingreso use Enter o un operador.");
puts("nPara reiniciar presione 'c'n");
puts("Para salir presione 'Esc'nn");
puts("Operadores:");
puts("nttsuma '+'ttresta '-'nttmultiplicacion '*'tdivision '/'");
puts("nttpotencia 'p'ttraiz 'r'n");

while (TRUE)
{
//con este bucle organizamos la entrada en el vector temp.num
for (j = 0; (j < 15) && (entrada != 13); j++)
{

entrada = _getche();

if ((entrada >= '0') && (entrada <= '9'))//solo numeros
{
temp.num[j] = entrada;
temp.modificado = TRUE;
}

else if (entrada == '.')//un punto es igual a una coma
{
temp.num[j] = entrada;
}
else if (entrada == ',')//una coma es igual a un punto
{
temp.num[j] = '.';
}
else if (entrada == 'c')//restaurar la calculadora para empezar de 0
{
i = 0;
j = 0;
k = 0;
temp.modificado = FALSE;
entrada = 'a';
operador = 'a';
for (; i < 15; i++)
{
temp.num = 0;
}
i = 0;
for (; i < PILA_ALTURA; i++)
{
pila = -0;
}
temp.signo = '+';
i = 0;
break;
}

else if (entrada == 27)// 27= Esc. salir de la calculadora
{
system("cls");

printf("nnt*******gracias por usar Pi Calculo*******nnn");

finish(); //musiquita
system("pause");
return 0;
}

else if (entrada == '-') //cambia el signo del numero a ingresar
{
if (temp.modificado == TRUE)
{
printf("b b"); //borro el menos recien ingresado
k = j;
while (k--) printf("b b"); //borro el numero entero
if (temp.signo == '+')
{
temp.signo = '-';
printf("-"); //escribo un menos
} else
{
printf("b b"); //borro el menos que estaba escrito
temp.signo = '+';
}
//vuelvo a escribir el numero
for (k = 0; k < j; k++) printf("%c", temp.num[k]);
j--; //resto porque no agregamos nada a
//temp.num y el for agrega automaticamente
} else
{
operador = entrada;
break;
}
}
//operadores matematicos
else if ((entrada == '+') || (entrada == '-') || (entrada == '*') ||
(entrada == '/') || (entrada == 'r') || (entrada == 'p'))
{
operador = entrada;
break;
}
//enter, rompe el bucle para permitir el ingreso de otro valor
else if (entrada == 'r')
{
break;
} else if (entrada == 'b')//borrar un caracter equivocado
{
if (j)
{
--j;
temp.num[j] = 0;

printf(" b");
}
else
{
if(temp.signo=='-')printf(" b");
temp.signo = '+';
temp.modificado=FALSE;
}
--j;//este es para contrarrestar el j++ del for

}


else //si llegamos a este punto significa que el usuario ingreso algun
//caracter que no fue definido por nosotros, entonces zacate!
{
printf("nEntrada no valida, vuelva a intentarlo.n");
for (k = 0; k < j+1; k++) printf("%c", temp.num[k]);

printf("b b");
Beep(1046.502, 500);
--j;

}

}//finalizacion del bucle para el ingreso por caracter.

if (temp.modificado == TRUE)
{
if(i {
sscanf_s(temp.num, "%Lf", &pila);//copio al valor del vector de
//chars temporal al vector de long doubles
//en la posicion i
if (temp.signo == '-') pila = -pila;
i++;//incremento el valor del contador i,
//utilizado para contolar la posicion de la pila.
}

else
{
printf("nntse desbordo la pila(%d espacios)nn",PILA_ALTURA);
system("pause");
}
temp.modificado = FALSE;
}

for (k = 0; k < 15; k++)
{
temp.num[k] = 0;//reinicio el vector temporal
}

temp.signo = '+';
k = 0;//reinicio el contador k

if (operador != 'a') //evaluo si tengo algun operador
{
if (i < 2)//si tengo menos de dos valores no puedo realizar operaciones
{
printf("nno hay suficietes argumentos en la expresionn");
operador = 'a';//reinicio el operador

Beep(1046.502, 500);
system("pause");
}

else if (operador == '+') //operador suma
{
pila[i - 2] = suma(pila[i - 2], pila[i - 1]);//realizo el calculo y
//guardo el resultado en la parte inferior de la pila

pila[i - 1] = -0;//al bajar un nivel de la pila reinicio el campo
i--;
operador = 'a';//reinicio el operador
}

else if (operador == '-') //operador resta
{
pila[i - 2] = resta(pila[i - 2], pila[i - 1]);//lo mismo que en la suma
pila[i - 1] = -0;
i--;
operador = 'a';
}

else if (operador == 'r') //operador raiz
{
pila[i - 2] = raiz(pila[i - 2], pila[i - 1]);
pila[i - 1] = -0;
i--;
operador = 'a';
}

else if (operador == 'p') //operador potencia
{
pila[i - 2] = potencia(pila[i - 2], pila[i - 1]);
pila[i - 1] = -0;
i--;
operador = 'a';
}

else if (operador == '*')//operador multiplicacion
{
pila[i - 2] = multiplicacion(pila[i - 2], pila[i - 1]);
pila[i - 1] = -0;
i--;
operador = 'a';
}

else if (operador == '/')//operador division
{
pila[i - 2] = division(pila[i - 2], pila[i - 1]);
pila[i - 1] = -0;
i--;
operador = 'a';
}

}
system("cls");
entrada = 'a';//reiniciamos el operador
puts("nIngrese valores.nn");
puts("Para finalizar un ingreso use Enter o un operador.nnOperadores:");
puts("ttsuma '+'ttresta '-'nttmultiplicacion '*'tdivision '/'");
puts("nttpotencia 'p'ttraiz 'r'n");
puts("nTambien precionando '-' cambia el signo del numero ingresado.n");

for (k = i - 1; k >= 0; k--)//imprimo la pila desde el valor mas "reciente"
{
printf("n%gn", pila[k]);
}

}

}

//aca van las implementaciones de las funciones

long double multiplicacion(long double j, long double k)
{
long double devolucion;
devolucion = j*k;
return devolucion;
}
long double suma(long double j, long double k)
{
long double devolucion;
devolucion = j + k;
return devolucion;
}
long double resta(long double j, long double k)
{
long double devolucion;
devolucion = j - k;
return devolucion;
}
long double division(long double j, long double k)
{
long double devolucion;
devolucion = j / k;
return devolucion;
}
long double potencia(long double j, long double k)
{
long double devolucion;
devolucion = pow(j, k);
return devolucion;
}
long double raiz(long double j, long double k)
{
long double devolucion;
devolucion = pow(j, (1 / k));
return devolucion;
}


void finish(void)
{
//mario bandera
Sleep(1000); system("color 0c");
Beep(330, 200); system("color 1c");
Beep(330, 100); system("color 2c");
Beep(330, 300); system("color 3c");
Beep(262, 200); system("color 4c");
Beep(330, 200); system("color 5c");
Beep(392, 400); Sleep(200); system("color 6c");
Beep(196, 500); Sleep(700); system("color 7c");
Beep(196, 150); system("color 8c");
Beep(262, 150); system("color 9c");
Beep(330, 150); system("color ac");
Beep(392, 150); system("color bc");
Beep(523, 150); system("color c0");
Beep(660, 150); system("color dc");
Beep(784, 150); Sleep(275); system("color ec");
Beep(660, 200); Sleep(375); system("color fc");
Beep(207, 125); system("color 0c");
Beep(262, 125); system("color 1c");
Beep(311, 125); system("color 2c");
Beep(415, 125); system("color 3c");
Beep(523, 125); system("color 4c");
Beep(622, 125); system("color 5c");
Beep(830, 175); Sleep(375); system("color 6c");
Beep(622, 175); Sleep(375); system("color 7c");
Beep(233, 100); system("color 8c");
Beep(294, 100); system("color 9c");
Beep(349, 100); system("color ac");
Beep(466, 100); system("color bc");
Beep(587, 100); system("color c0");
Beep(698, 100); system("color dc");
Beep(932, 300); Sleep(375); system("color ec");
Beep(932, 100); system("color fc");
Beep(932, 100); system("color 0c");
Beep(932, 100); system("color 1c");
Beep(1046, 300); system("color 2c");
system("color 0a");
}

void animacion(void)
{
int i;
system("color 1f");
SetConsoleTitle("Pi calculo");
/*0 = Negro 1 = Azul 2 = Verde 3 = Aguamarina 4 = Rojo
5 = Purpura 6 = Amarillo 7 = Blanco 8 = Gris 9 = Azul claro
A = Verrde claro B = Aguamarina claro C = Rojo claro
D = Purpura claro E = Amarillo claro F = Blanco brillante*/
for (i = 0; i < vuelta; i++)
{
printf("ntPi");
system("color 09");
Sleep(time);
system("cls");

printf("nnttCal");
Sleep(time);
system("color e5");
system("cls");

printf("ntttcu");
Sleep(time);
system("color f1");
system("cls");

printf("nnttttlo");
Sleep(time);
system("color d3");
system("cls");

printf("nttttt");
Sleep(time);
system("color 0A");
system("cls");
}

printf("ntPittcuttnttCalttlon");
printf("nnnttPi Calculonnn");
Sleep(1000);
system("pause");
}



resultados y conclusiones.

A partir del desarrollo de este proyecto, llamado Pi Calculo, podemos decir que se superaron ampliamente las expectativas, logrando una clase dinámica, con lugar a la creatividad y el desarrollo de las potencialidades del estudiante. Resultando este proyecto, también una herramienta pedagógica, ya que el docente de la materia informatica 1 puede compartir a sus estudiantes el proceso realizado por este grupo, con el fin de ejemplificar como de manera práctica se pueden incorporar los conocimientos técnicos que se presentan en la materia, como así también algunos temas extracurriculares, incentivando a la investigación particular y grupal a fin de aplicarlas en algo concreto.

Referencias

Aparicio, Hugo. Casabuono, Alegandro. Ferlat, Claudio. Informática para Ingeniería Electrónica.
Pascual,Gustavo. Bassi,Mat'ias. Ejercicios INFO 1‏. Año2014.
Romero, Juan. “Apuntes de clase”. año 2014
http://es.wikipedia.org/wiki/HP-35
www.hp.com/hpinfo/abouthp/histnfacts/museum/personalsystems/0023/
http://mstatic.mit.edu/mit150/
http://www.hpcalculators.net/
http://www.hpmuseum.org/3qs/
0
0
0
0
0No comments yet