MANUAL TÉCNICO PARA

CALCULADORA CIENTÍFICA EN C#
INTRODUCCIÓN
A través de este manual se pretende que el lector sea capaz de realizar
en Visual Studio 2013 una calculadora científica gráfica similar a la
calculadora integrada en Windows. Es por esto que aquí listaremos el
procedimiento usado para desarrollar esta aplicación de una manera fácil y
sencilla para que cualquier persona con conocimientos básicos de C# que lea
este manual pueda hacerlo.

COMENZANDO LA APLICACIÓN
Lo primero que debemos hacer es crear un nuevo proyecto en Visual
Studio 2013 como Windows Forms Application y asignarle un nombre a este.
Una vez que hemos creado este nuevo proyecto, se verá una ventana en
blanco, en la cual procederemos a diseñar nuestra calculadora.

DISEÑO DE LA CALCULADORA
En esta sección veremos cómo se diseña la interface de usuario de la
calculadora, de tal forma en que se vea como en la Figura 1.
Lo primero que debemos hacer es buscar que las propiedades de
nuestra ventana se asemejen a las de la aplicación Calculadora de Windows. Si
una persona abre la Calculadora, uno puede notar como esta no puede
maximizarse ni cambiarse de tamaño. Para realizar estas modificaciones a
nuestra ventana, buscaremos la propiedad, que se encuentra en la sección
Properties en la parte inferior derecha, llamada Maximize y modificaremos en
donde dice True, a False. Así mismo, para cambiar el hecho de que el usuario
pueda modificar la forma y el tamaño de la ventana, buscaremos la propiedad
llamada FormBorderStyle, y en vez de que esta diga Sizable la cambiaremos a
FixedDialog.
El siguiente paso es agregarle un ícono a nuestra aplicación, así como
cambiar el nombre que aparece en la parte superior de nuestra ventana. Para
cambiar el nombre de la parte superior, buscaremos la propiedad Text y en
donde dice Form 1, lo cambiaremos por el nombre deseado. Ahora, lo que
haremos es cambiar el ícono de nuestra aplicación, para esto es necesario
contar con una imagen de tipo .ico, las cuales pueden ser fácilmente
encontradas en Internet. Después lo que haremos es buscar la propiedad
llamada Icon, y daremos clic en el botón con tres puntos, lo cual nos permitirá
Figura 1

buscar en nuestros archivos la imagen que queremos poner como ícono de

nuestra aplicación, una vez seleccionada la imagen damos clic en Aceptar y
así será como nuestro ícono podrá ser observado en la barra de Inicio y en la
parte superior de nuestra ventana.
También, es posible cambiarle el color a nuestra ventana, para esto
buscaremos la propiedad llamada BackColor, en donde podremos seleccionar
una de las opciones de color existentes.
Una vez que ya tenemos las propiedades básicas de nuestra ventana
para que esta sea lo más parecido a una aplicación normal, lo que haremos es
comenzar a poner la interfaz gráfica. Para esto, iremos a Toolbox, donde
podremos encontrar botones, cajas de texto y demás objetos que nos
permitirán ensamblar nuestra interfaz de usuario.
Para colocar los botones para los números y los signos de operación,
simplemente arrastraremos de Toolbox la opción que dice Button para añadir
un botón, y con el mouse lo ajustaremos para darle el tamaño que queramos.
Este proceso lo repetiremos hasta contar con el número de botones que se
encuentran en la Figura 1. Ahora, para cambiarles el texto a cada botón,
buscaremos en Properties la propiedad Text y escribiremos los números y
signos de operación correspondientes para cada botón. Al igual que en la
ventana, si deseamos cambiar el color del botón igual iremos a la propiedad
BackColor, en específico para los botones si se quiere cambiar la fuente del
texto iremos a la propiedad Font y para el color de letra simplemente iremos
a la propiedad ForeColor.
Ahora, procederemos a colocar una TextBox para poder desplegar ahí
los números con los que queremos hacer las operaciones y los resultados, esta
se encuentra en Toolbox y al igual que con los botones solamente la
arrastraremos a la ventana .También, a esta se le puede modificar el tipo, el
tamaño y el estilo de letra de la misma forma que en los botones, en la
propiedad Font. De igual forma si se desea cambiar el color de la TextBox y
de la letra dentro de esta, seguiremos los mismos pasos que para el caso de
los botones.
Después, partiremos a añadir un Label desde Toolbox para poder
desplegar las operaciones que se están realizando, y simplemente lo
colocaremos en la parte superior del TextBox y le cambiaremos el texto que
tiene desde la propiedad Text, dejándolo sin texto alguno.
Finalmente, para concluir con el diseño de la interfaz de nuestra
calculadora, agregaremos los últimos dos botones que nos permitirán
cambiar el modo de la calculadora, ya sea radianes o grados. Para esto,
buscaremos en Toolbox la opción RadioButton, y arrastraremos dos de ellos a
nuestra ventana y cambiaremos el texto para uno a “Radianes” y en el otro a
“Grados”, de la misma forma que para los demás botones. Ahora, en Properties
buscaremos la propiedad Checked para el botón de Radianes y cambiaremos
donde dice False a True.
INTERACCIÓN CON BOTONES
En esta sección nos encargaremos de programar que los botones
ejecuten cierta acción de acuerdo a la interacción que el usuario tiene con
estos. Para esto, se tiene que asociar los botones con un evento, por lo cual
buscaremos en el menú debajo de Properties un ícono con un rayo, para así
acceder a los eventos asociados con cada uno de los botones.
Primero que nada comenzaremos con los botones numéricos,
incluyendo el botón para el punto y pi. Para cada uno de estos botones, en
Events, buscaremos la opción Click y en el campo de la derecha le daremos un
nombre a este, como por ejemplo button_Click, de tal forma en que este sea el
mismo para todos los botones que acabamos de nombre al principio de este
párrafo. Una vez acabando de asociar todos estos botones, pasaremos con
todos los signos y expresiones que representan a una operación, y de la
misma forma que para los botones numéricos, en la opción Click le daremos
un nombre distinto como operator_Click.
Ahora, nos referiremos a los casos particulares de los botones C, CE,
Borrar(←) e Igual (=). Para cada uno de estos botones crearemos un evento
diferente, de la misma forma en la opción Click, y le daremos un nombre
distinto a cada uno de estos; por ejemplo, clear_click, clearentry_click,
borrar_click y result_click.
Finalmente, para los botones de radianes y grados, ahora crearemos un
evento, pero en lugar de la opción Click será en CheckedChange, ahí de igual
forma le daremos un nombre distinto a cada botón, como
rbDeg_CheckedChange y rbRad_CheckedChange.
PROGRAMACIÓN DE EVENTOS
En esta parte del manual, nos dedicaremos a asignar una acción para
cada uno de los eventos que se crearon en la sección pasada. Para hacer esto,
nos cambiaremos a la pestaña que dice Form 1.cs, ya que en esta es donde
yace todo el programa principal.
Primero que nada, estableceremos dentro del método que dice: public
partial class Form 1: Form, las variables que usaremos para la mayor parte de
nuestro programa, las cuales son las siguientes:
Double resultValue = 0;
String operationPerformed = "";
bool isOperationPerformed = false;
bool Radians = true;
donde resultValue nos servirá para almacenar el contenido de la TextBox,
operationPerformed para saber que operación se está ejecutando,
isOperationPerformed para cuando una operación se está ejecutando y Radians
para saber la modalidad en la que debe operar la calculadora.
Después, nos iremos a la parte gráfica de nuestro proyecto y le
daremos doble clic a cualquier botón numérico, lo cual nos creará el evento
en el programa principal. Dentro del método que se ha creado, escribiremos
lo siguiente:
private void button_click(object sender, EventArgs e)
{
if ((txtDisplay.Text == "0")||(isOperationPerformed))
txtDisplay.Clear();
isOperationPerformed = false;
Button button = (Button)sender;
//Condicional para evitar que se repitan los puntos
if (button.Text == ".")
{
if (!txtDisplay.Text.Contains("."))
txtDisplay.Text = txtDisplay.Text + button.Text;
}
else
{
txtDisplay.Text = txtDisplay.Text + button.Text;
}
//Pi
if (button.Text == "π")
{
txtDisplay.Text = ((Math.PI).ToString());
 }
}
Nótese, que txtDisplay se trata de la TextBox y button hace referencia a
cualquier botón que tenga este evento. Así mismo, cuando se usa .Text es
para poder usar el texto contenido en el botón o caja de texto. Como se puede
ver, en el código de la parte superior el primer if nos indica que si el texto en
la caja de texto es igual a cero o si isOperationPerformed es true, entonces la
caja de texto quitará el 0 y los sustituirá por el texto que tiene el botón
oprimido, de igual forma isOperationPerformed cambia de valor a false. El
segundo if nos dice que si el texto del botón es un punto (.), entonces si la caja
de texto no contiene un punto la caja de texto agregará un punto después de
los números y si esta condición no se cumple, el else nos dice que no se pondrá
el punto, esto con la intención de que los puntos no se repitan. Finalmente,
debajo del comentario //Pi nos encontramos con otro if que nos dice que si
el texto del botón es igual a π, en la caja de texto aparecerá el valor de pi.
El siguiente evento que haremos será el de los botones de operación, y
de la misma forma le daremos un doble clic a los botones de signo de
operación para invocarlo en el programa principal, escribiendo lo siguiente:
private void operator_click(object sender, EventArgs e)
{
Button button = (Button)sender;
if (resultValue != 0)
{
btnIgual.PerformClick();
operationPerformed = button.Text;
LabelOperations.Text = resultValue + "" + operationPerformed;
isOperationPerformed = true;
}
else
{
operationPerformed = button.Text;
resultValue = Double.Parse(txtDisplay.Text);
LabelOperations.Text = resultValue + "" + operationPerformed;
isOperationPerformed = true;
}
}

Es importante, que sepamos que para este manual, btnIgual es el botón de

igual (=) y LabelOperations es el nombre de nuestro label, así como que los
nombres usados en otras partes del código incluidas en este manual siempre
significarán lo mismo. En este caso, se nos dice que el botón que presionamos
que tenga como evento operator_click se encargará de enviarnos información,
entonces el if nos dice que si nuestra variable resultValue es diferente de 0
entonces el botón igual ejecutará un clic, la variable operationPerformed
tomará como valor el texto del botón, el texto de la label será igual a el
contenido de la variable resultValue más el valor de la variable
operationPerformed, y la variable isOperatonPerformed tomará como valor true.
Si las condiciones que el if tiene no se cumplen, entonces el else nos dice que
la variable operationPerformed será igual al texto del botón, resultValue tendrá
como valor el texto de la caja de texto, el texto de la label será igual a el
resultado y la operación ejecutada y la variable isOperationPerformed será true.
En este pedazo de código, Double.Parse nos permite transformar una variable
tipo string a double.
Ahora, pasaremos a programar los eventos particulares para C, CE, y
Borrar(←). De la misma manera que en los dos casos anteriores, invocaremos
el evento de cada uno de estos botones y escribiremos el siguiente código:
private void clearentry_click(object sender, EventArgs e)
{
txtDisplay.Text = "0";
}

private void clear_click(object sender, EventArgs e)

{
txtDisplay.Text = "0";
resultValue = 0;
}

private void borrar_Click(object sender, EventArgs e)

{
txtDisplay.Text = txtDisplay.Text.Substring(0, txtDisplay.Text.Length - 1);
if (txtDisplay.Text.Length == 0)
{
txtDisplay.Text = "0";
}
}
Como se puede observar, se han creado tres eventos diferentes. El evento
clearentry_click pertenece al botón CE y nos indica que cada vez que este sea
presionado el texto contenido en la caja de texto será 0. El evento clear_click,
el cual está asociado con el botón C nos indica que el texto contenido en la
caja de texto será 0 y además la variable resultValue cambiará su valor a 0. Por
último, el evento borrar_Click nos indica que cada vez que el botón (←) sea
presionado, el texto contenido en la caja de texto disminuirá un carácter, lo
cual está expresado por txtDisplay.Text.Length – 1, y si la longitud del texto
contenido en la caja de texto es igual a cero, entonces la caja de texto tendrá
un cero.
El caso del botón igual es quizá el más importante de todos, ya que este
es el que permite que se despliegue el resultado de la operación, haremos lo
mismo que en los casos anteriores para invocar su evento y escribiremos lo
siguiente:

private void result_click(object sender, EventArgs e)

{
//Variables utilizadas en la clase de operaciones
double numero1;
double numero2;
Operaciones Oper = new Operaciones();

numero1 = resultValue;
numero2 = Double.Parse(txtDisplay.Text);
//Casos en los que se ejecutan los métodos establecidos en la clase de operaciones
switch(operationPerformed)
{
case "+":
txtDisplay.Text = (Oper.Suma(numero1, numero2).ToString());

break;
case "-":
txtDisplay.Text = (Oper.Resta(numero1, numero2).ToString());
break;
case "x":
txtDisplay.Text = (Oper.Multiplicacion(numero1, numero2).ToString());
break;
case "÷":
txtDisplay.Text = (Oper.Division(numero1, numero2).ToString());
break;
case "√":
txtDisplay.Text = (Oper.Raiz(numero2).ToString());
break;
 case "Mod":
txtDisplay.Text = (Oper.Modulo(numero1, numero2).ToString());
break;
case "1/x":
txtDisplay.Text = (Oper.Inverso(numero2).ToString());
break;
case "!":
txtDisplay.Text = (Oper.Factorial(numero2).ToString());
break;
case "±":
txtDisplay.Text = (Oper.Signo(numero2).ToString());
break;
case "x²":
txtDisplay.Text = (Oper.Cuadrado(numero2).ToString());
break;
case "x^y":
txtDisplay.Text = (Oper.Potencia(numero1, numero2).ToString());
break;
case "x³":
txtDisplay.Text = (Oper.Cubo(numero2).ToString());
break;
case "log":
txtDisplay.Text = (Oper.Logaritmo(numero2).ToString());
break;
case "ln":
txtDisplay.Text = (Oper.Logn(numero2).ToString());
break;
case "y√":
txtDisplay.Text = (Oper.Raizx(numero1, numero2).ToString());
break;
case "³√":
txtDisplay.Text = (Oper.RaizCubo(numero2).ToString());
break;
case "10^x":
txtDisplay.Text = (Oper.Diez(numero2).ToString());
break;
case "sin":
txtDisplay.Text = (Oper.Sin(numero2, Radians).ToString());
break;
case "cos":
txtDisplay.Text = (Oper.Cos(numero2, Radians).ToString());
break;
case "tan":
txtDisplay.Text = (Oper.Tan(numero2, Radians).ToString());
break;
case "sinh":
txtDisplay.Text = (Oper.Sinh(numero2, Radians).ToString());
break;
case "cosh":
txtDisplay.Text = (Oper.Cosh(numero2, Radians).ToString());
break;
case "tanh":
txtDisplay.Text = (Oper.Tanh(numero2, Radians).ToString());
break;
case "Exp":;
txtDisplay.Text = (Oper.Exp(numero2).ToString());
break;
default:
break;

}
 resultValue = Double.Parse(txtDisplay.Text);
LabelOperations.Text = "";
}

Lo primero que se hizo es establecer dos nuevas variables que utilizaremos en

una nueva clase que crearemos más adelante, estas en este caso se llaman
numero1 y numero2, y ambas pertenecen al tipo double, siendo que numero1 es
igual a la variable resultValue y numero2 a lo que se encuentra en la caja de
texto. Después se establece un nuevo objeto para la clase que titularemos más
adelante Operaciones, este objeto se llamará Oper, y se crea con la expresión
new Operaciones(). Ahora, lo siguiente es que con un switch que evaluará a la
variable operationPerformed, se decidirá que hacer en cada operación en
específico; y como se puede ver en cada caso siempre se establece que el texto
de la caja de texto será igual a Oper.Nombre de la operación(variables utilizadas
para realizar la operación) y se pasa a tipo string con la expresión ToString().
Finalmente, después de que el switch evalúa las opciones, se establece que la
variable resultValue es igual a lo que se encuentra dentro de la caja de texto, y
el texto del label se cambia para que no diga nada.
Por último, tenemos los dos Radio Buttons para radianes y grados por
lo que invocaremos sus eventos de la misma manera que como se hizo
previamente y haremos lo siguiente para cada uno de sus eventos:
private void rbDeg_CheckedChanged(object sender, EventArgs e)
{
if (true)
{
Radians = false;
}
}

private void rbRad_CheckedChanged(object sender, EventArgs e)

{

En este pedazo de código se puede observar el evento para grados que es

rbDeg_CheckedChanged y el evento para radianes que rbRad_CheckedChanged.
En el caso de grados, simplemente se establece que si el valor del botón es
true, el cual lo establece la propiedad Checked y que cambia cuando el usuario
lo aprieta, entonces la variable Radians será false. Mientras que para radianes
no sucederá nada, ya que normalmente Visual Studio 2013 trabaja con
radianes.

OPERACIONES
En esta sección, se trabajará con la realización de cada una de las
operaciones que hace nuestra calculadora. Para esto, crearemos una nueva
clase que contendrá todos los diferentes métodos que se realizan para obtener
los resultados de cada operación. Para crear una nueva clase, simplemente
tenemos que buscar en la parte derecha en SolutionExplorer donde diga C# +
Nombre del proyecto, y dar clic derecho y en menú que se despliega dar clic en
Add y después en Class y le daremos el nombre Operaciones.
Una vez que hemos creado nuestra nueva clase, crearemos primero que nada
una nueva variable llamada angle tipo double. Después crearemos un método
diferente para cada operación, todos los métodos serán de la forma public
double Nombre del método(variables utilizadas desde la clase principal). Una vez
creado el método para todas las operaciones, con excepción de las funciones
trigonométricas, se utilizara la expresión return para que ese valor sea
regresado a la clase principal y se desplieguen los resultados. En el caso de
las funciones trigonométricas se colocará un if que establezca que si Radians
es igual a false, entonces angle sea la conversión de grados a radianes, para
que así se realice la operación correctamente y si no se utilice el numero
insertado.
A continuación se presenta una tabla con cada una de las operaciones y como
expresarlas en lenguaje de C#.
 Operación Expresión en C#
Suma numero1 + numero2
Resta numero1 - numero2
Multiplicación numero1 * numero2
División numero1 / numero2
Módulo numero1 +% numero2
Raíz Math.Sqrt(numero2)
Inverso 1/numero2
Cambio de Signo -1* numero2
Cuadrado Math.Pow(numero2, 2)
Potencia Math.Pow(numero1, numero2)
Cubo Math.Pow(numero2, 3)
Logaritmo Math.Log10(numero2)
Logaritmo natural Math.Log(numero2, Math.E)
Raíz de y Math.Pow(numero1, (1.0/numero2)
Raíz cúbica Math.Pow(numero2, 3)
Potencia de 10 Math.Pow(10, numero2)
Seno Math.Sin(numero2 ó angle)
Coseno Math.Cos(numero2 ó angle)
Tangente Math.Tan(numero2 ó angle)
Seno hiperbólico Math.Sinh(numero2 ó angle)
Coseno hiperbólico Math.Cosh(numero2 ó angle)
Tangente hiperbólica Math.Tanh(numero2 ó angle)
Exponencial Math.Exp(numero2)
Así mismo, aquí se puede observar el código terminado para todas las
operaciones.
class Operaciones
{
double angle;

//Suma
public double Suma(double numero1, double numero2)
{
return (numero1 + numero2);
}
//Resta
public double Resta(double numero1, double numero2)
{
return (numero1 - numero2);
}
//Multiplicacion
public double Multiplicacion(double numero1, double numero2)
{
return (numero1 * numero2);
}
//Division
public double Division(double numero1, double numero2)
{
return (numero1 / numero2);
}
//Modulo
public double Modulo(double numero1, double numero2)
{
return (numero1 % numero2);
}
//Raiz
public double Raiz(double numero2)
{
return (Math.Sqrt(numero2));
}
//Inverso

public double Inverso(double numero2)

{
return (1/numero2);
}
//Cambio de signo
public double Signo(double numero2)
{
return (-1*numero2);
}
//Factorial
public double Factorial(double numero2)
{
int i = Factor(Convert.ToInt32(numero2));
return (i);
}

//Factorial
static int Factor (int x)
{
if (x <= 1)
return (1);
 else
return (x * Factor(x - 1));
}
//Cuadrado
public double Cuadrado(double numero2)
{
return (Math.Pow(numero2,2));
}
//Potencia
public double Potencia(double numero1, double numero2)
{
return (Math.Pow(numero1, numero2));
}
//Cubo
public double Cubo(double numero2)
{
return (Math.Pow(numero2, 3));
}
//Logaritmo
public double Logaritmo(double numero2)
{
return (Math.Log10(numero2));
}
//Logaritmo natural
public double Logn(double numero2)
{
return (Math.Log(numero2,(Math.E)));
}
//Raiz x
public double Raizx(double numero1, double numero2)
{
return (Math.Pow(numero1,1.0/numero2));
}
//Raiz cubica
public double RaizCubo(double numero2)
{
return (Math.Pow(numero2,(1.0/3.0)));
}
//Potencia 10
public double Diez(double numero2)
{

return (Math.Pow(10, numero2));

}

//Seno
public double Sin(double numero2, bool Radians)
{
if (Radians == false)
{
angle = ((Math.PI) * numero2) / 180.0;
return Math.Sin(angle);
}
else
{
return Math.Sin(numero2);
}

}
//Coseno
public double Cos(double numero2, bool Radians)
{
if (Radians == false)
{
angle = ((Math.PI) * numero2) / 180.0;
return Math.Cos(angle);
}
else
{
return Math.Cos(numero2);
}
}
//Tangente
public double Tan(double numero2, bool Radians)
{
if (Radians == false)
{
angle = ((Math.PI) * numero2) / 180.0;
return Math.Tan(angle);
}
else
{
return Math.Tan(numero2);
}
}
//Senoh
public double Sinh(double numero2, bool Radians)
{
if (Radians == false)
{
angle = ((Math.PI) * numero2) / 180.0;
return Math.Sinh(angle);
}
else
{
return Math.Sinh(numero2);
}
}
//Cosenoh
public double Cosh(double numero2, bool Radians)
{
if (Radians == false)
{
angle = ((Math.PI) * numero2) / 180.0;
return Math.Cosh(angle);
}
else
{
return Math.Cosh(numero2);
}
}
//Tangenteh
public double Tanh(double numero2, bool Radians)
{
if (Radians == false)
{
angle = ((Math.PI) * numero2) / 180.0;
return Math.Tanh(angle);
}
else
{
return Math.Tanh(numero2);
 }
}
//Exp
public double Exp( double numero2)
{
return (Math.Exp(numero2));
}

Una vez terminado de realizar este código, nuestra calculadora se

encuentra lista para operar completamente de la misma forma que la misma
aplicación de calculadora de Windows. Y como se puede notar es muy
sencillo realizar proyectos que en un principio parecen ser muy complicados
si se tiene un poco de paciencia y se trata de entender cada uno de los
conocimientos más básicos de C#.
Autores:
Daniel Gutiérrez Pavón – A01420372
Jesús Rafael Fernández Cavagna – A01338140
María Fernanda Velázquez Miranda – A01338768