private double Operar(String numero1, String numero2, String operador)
{
Entidades.Numero a = new Entidades.Numero(numero1);
Entidades.Numero b = new Entidades.Numero(numero2);
return(Calculadora.Operar(a, b, this.cmbOperador.Text));
}
private static double Operar(string numero1, string numero2, string operador)
{
double resultado;
Numero n1 = new Entidades.Numero(numero1);
Numero n2 = new Entidades.Numero(numero2);
resultado = Entidades.Calculadora.Operar(n1, n2, operador);
return(resultado);
}
/// <summary>
/// Realiza la operación matemática entre 2 numeros
/// </summary>
/// <param name="numero1"></param>
/// <param name="numero2"></param>
/// <param name="operador"></param>
/// <returns></returns>
private double Operar(string numero1, string numero2, string operador)
{
Entidades.Numero num1 = new Entidades.Numero(numero1);
Entidades.Numero num2 = new Entidades.Numero(numero2);
if (operador == "")
{
operador = "+";
cmbOperador.Text = "+";
}
return(Entidades.Calculadora.Operar(num1, num2, operador));
}
/// <summary>
/// Realiza el calculo de dos numeros.
/// </summary>
/// <param name="num1">Primer argumento de la operacion</param>
/// <param name="num2">Segundo argumento de la operacion</param>
/// <param name="operador">Indica la operacion entre los numeros</param>
/// <returns>Resultado de la operacion</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
char operadorChar = new char();
if (!string.IsNullOrEmpty(operador))
{
operadorChar = Convert.ToChar(operador);
}
operador = ValidarOperador(operadorChar);
double retorno = 0;
switch (operador)
{
case "+":
retorno = num1 + num2;
break;
case "-":
retorno = num1 - num2;
break;
case "/":
retorno = num1 / num2;
break;
case "*":
retorno = num1 * num2;
break;
default:
return(0);
}
return(retorno);
}
public static double operar(Numero num1, Numero num2, string operador)
{
double numero = 0;
switch (Calculadora.ValidarOperador(operador))
{
case "+":
numero = num1 + num2;
break;
case "-":
numero = num1 - num2;
break;
case "*":
numero = num1 * num2;
break;
case "/":
numero = num1 / num2;
break;
}
return(numero);
}
/// <summary>
/// Realiza una operacion matematica con dos numeros, en caso de no recibir operador,realiza una suma
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns>Retorna el resultado de la operación</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado;
char calculo;
if (!("".Equals(operador)))
{
operador = ValidarOperador(Convert.ToChar(operador));
calculo = Convert.ToChar(operador);
}
else
{
calculo = '+';
}
switch (calculo)
{
case '-':
resultado = num1 - num2;
break;
case '/':
resultado = num1 / num2;
break;
case '*':
resultado = num1 * num2;
break;
default:
resultado = num1 + num2;
break;
}
return(resultado);
}
/// <summary>
/// Recive dos parametros de clase Numero y un string
/// Realiza la operacion matematica segun el operador que se ingreso por parametro(string)
/// Retorna el resultado de la operacion
/// </summary>
/// <param name="numero1"></param>
/// <param name="numero2"></param>
/// <param name="operador"></param>
/// <returns>double</returns>
public static double Operar(Numero numero1, Numero numero2, char operador)
{
double total = 0;
switch (ValidarOperador(operador))
{
case "+":
total = numero1 + numero2;
break;
case "-":
total = numero1 - numero2;
break;
case "/":
total = numero1 / numero2;
break;
case "*":
total = numero1 * numero2;
break;
}
return(total);
}
/// <summary>
/// Método estático para realizar operaciones.
/// </summary>
/// <param name="num1">Primero numero para operación</param>
/// <param name="num2">Segundo numero para operación</param>
/// <param name="operador">Tipo de operador</param>
/// <returns>Retorno resultado de la operacion</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
switch (ValidarOperador(operador))
{
case "+": //Suma
resultado = num1 + num2;
break;
case "-": //Resta
resultado = num1 - num2;
break;
case "/": //Division
resultado = num1 / num2;
break;
case "*": //Multiplicacion
resultado = num1 * num2;
break;
}
return(resultado);
}
//METODOS
public static double Operar(Numero n1, Numero n2, string operador)
{
double xReturn;
switch (ValidarOperador(operador))
{
case "*":
xReturn = n1 * n2;
break;
case "/":
xReturn = n1 / n2;
break;
case "-":
xReturn = n1 - n2;
break;
default:
xReturn = n1 + n2;
break;
}
return(xReturn);
}
/// <summary>Funcion que realizara la suma,resta,multiplicacion o division entre 2 numeros
/// </summary>
/// <param name="numero1">Numero numero1</param>
/// <param name="numero2">Numero numero2</param>
/// <param name="operador">String operador</param>
/// <returns>depende del operador que le llegue a la funcion, retornara la opcion indicada.</returns>
public double OperarCalculadora(Numero numero1, Numero numero2, string operador)
{
double retorno = 0;
switch (ValidarOperador(operador))
{
case "+":
retorno = numero1 + numero2;
break;
case "-":
retorno = numero1 - numero2;
break;
case "*":
retorno = numero1 * numero2;
break;
case "/":
retorno = numero1 / numero2;
break;
}
return(retorno);
}
/// <summary>
/// Realiza la operacion indicada entre los numeros
/// </summary>
/// <param name="num1">Operando 1</param>
/// <param name="num2">Operando 2</param>
/// <param name="operador">Operacion a realizar</param>
/// <returns>Retorna el resultado de la operacion</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
operador = ValidarOperador(operador);
switch (operador)
{
case "*":
return num1 * num2;
case "-":
return num1 - num2;
case "/":
return num1 / num2;
//+
default:
return num1 + num2;
}
}
public static double Operar(Numero numUno, Numero numDos, string operador)
{
double retorno = 0;
switch (ValidarOperador(operador))
{
case "+":
retorno = numUno + numDos;
break;
case "-":
retorno = numUno - numDos;
break;
case "*":
retorno = numUno * numDos;
break;
case "/":
retorno = numUno / numDos;
break;
}
return(retorno);
}
/// <summary>
/// Convierte un numero binario a decimal
/// </summary>
/// <param name="binario"></param>
/// <returns>
/// Devuelve el numero decimal en formato string
/// En caso de que la cadena no sea un binario valdo, devuelve el mensaje valor invalido
/// </returns>
public static string BinarioDecimal(string binario)
{
string retorno;
int largo = binario.Length;
int numAux;
double numResult = 0;
if (Numero.EsBinario(binario))
{
for (int i = 1; i <= largo; i++)
{
numAux = binario[i - 1] - '0'; //'0' es 48, al restarlo con cualquier numero, por ejemplo '9' es 57, entonces 57 - 48 = 9
//i-1 porque quiero el indice 0
numResult += (numAux * Math.Pow(2, largo - i)); //Elevo el caracter 0 o 1 por la posicion en la que esta,
//pongo - i porque quiero que sea 4, despues 3, 2, 1, 0
}
retorno = numResult.ToString();
}
else
{
retorno = "Valor invalido";
}
return(retorno);
}
public static double Operar(Numero numeroUno, Numero numeroDos, string operador)
{
double resultado = default;
switch (ValidarOperador(operador))
{
case "+":
resultado = numeroUno + numeroDos;
break;
case "-":
resultado = numeroUno - numeroDos;
break;
case "*":
resultado = numeroUno * numeroDos;
break;
case "/":
resultado = numeroUno / numeroDos;
break;
}
return(resultado);
}
/// <summary>
///
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns></returns>
public double Operar(Numero num1, Numero num2, string operador)
{
double retorno = 0;
string verificado = ValidarOperador(operador);
if (verificado == "-")
{
retorno = num1 - num2;
}
else if (verificado == "+")
{
retorno = num1 + num2;
}
else if (verificado == "/")
{
retorno = num1 / num2;
}
else
{
retorno = num1 * num2;
}
return retorno;
}
/// <summary>
/// Este método realiza una operación aritmética sobre dos operandos y un operador que el usuario elija
/// </summary>
/// <param name="num1">Primer operando</param>
/// <param name="num2">Segundo operando</param>
/// <param name="operador">Operador aritmético</param>
/// <returns>Devuelve un valor de tipo double con el resultado de la operación.</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
switch (ValidarOperador(operador))
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
resultado = num1 / num2;
break;
}
return(resultado);
}
public static double Operar(Numero n1, Numero n2, string operador)
{
double ret = 0;
switch (ValidarOperador(operador))
{
case "+":
ret = n1 + n2;
break;
case "-":
ret = n1 - n2;
break;
case "*":
ret = n1 * n2;
break;
case "/":
ret = n1 / n2;
break;
}
return(ret);
}
/// <summary>
/// Realiza operaciones entre 2 numeros
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns>Devuelve el resultado de la operacion</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double retorno;
switch (ValidarOperacion(Convert.ToChar(operador)))
{
case "/":
retorno = num1 / num2;
break;
case "*":
retorno = num1 * num2;
break;
case "-":
retorno = num1 - num2;
break;
default:
retorno = num1 + num2;
break;
}
return(retorno);
}
/// <summary>
/// Realiza la operacion a los dos valosres que se le pasan
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns></returns>
public double Operar(Numero num1, Numero num2, string operador)
{
string auxString = ValidarOperador(operador);
double retorno = 0;
switch (auxString)
{
case "+":
{
retorno = num1 + num2;
break;
}
case "-":
{
retorno = num1 - num2;
break;
}
case "*":
{
retorno = num1 * num2;
break;
}
case "/":
{
retorno = num1 / num2;
break;
}
default:
break;
}
return(retorno);
}
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
Entidades.Numero numeroAConvertir = new Entidades.Numero();
this.lblResultado.Text = numeroAConvertir.BinarioDecimal(this.lblResultado.Text);
}
/// <summary>
/// Si el metodo convertir a binario fue exitoso entonces estara habilitado para poder convertir de binario a decimal
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
string lblBackup = lblResultado.Text;
this.lblResultado.Text = Numero.BinarioDecimal(lblResultado.Text);
}
/// <summary>
/// Setter
/// </summary>
/// <param name="numero">Cadena de numeros</param>
public void SetNumero(string numero)
{
this.numero = Numero.ValidarNumero(numero);
}
/// <summary>
/// Convierte de decimal a binario
/// </summary>
/// <param name="numero">Cadena de caracteres numericos</param>
/// <returns>["Valor Invalido"] si es 0 o negativo [Numero binario] si se puede convertir</returns>
public static string DecimalBinario(string numero)
{
Numero numer0 = new Numero(numero);
return(DecimalBinario(numer0.numero));
}
private void BtnDecimalBinario_Click(object sender, EventArgs e)
{
Numero numeroUno = new Numero(label1.Text);
this.label1.Text = numeroUno.DecimalBinario(label1.Text);
}
public static double operator *(Numero num1, Numero num2)
{
Numero resultado = new Numero(num1.numero * num2.numero);
return(resultado.numero);
}
private void SetNumero(string strNumero)
{
this.numero = Numero.ValidarNumero(strNumero);
}
/// <summary>
/// Convierte un dato de tipo double en binario
/// </summary>
/// <param name="numero"></param>
/// <returns></returns>
public static string DecimalBinario(double numero)
{
return(Numero.DecimalBinario(numero.ToString()));
}
/// <summary>
/// Asigna el valor que recibe al atributo numero
/// </summary>
/// <param name="numero"></param>
/// <returns></returns>
private void setNumero(string numero)
{
this.numero = Numero.validarNumero(numero);
}
public void SetNumero(Numero numeroAIngresar, string numero)
{
this.numeroIngresado = ValidarNumero(numero);
}
private void Button5_Click(object sender, EventArgs e)
{
Numero numeroUno = new Numero(label1.Text);
this.label1.Text = numeroUno.BinarioDecimal();
}
