public static double Operar(Numero Num1, Numero num2, string operador)
{
double Resultado = 0;
switch (char.Parse(Calculadora.ValidarOperador(operador)))
{
case '+':
Resultado = Num1 + num2;
break;
case '-':
Resultado = Num1 - num2;
break;
case '*':
Resultado = Num1 * num2;
break;
case '/':
try
{
Resultado = Num1 / num2;
}
catch (DivideByZeroException)
{
Resultado = double.MinValue;
}
break;
default:
break;
}
return(Resultado);
}
/// <summary>
/// Realiza una operacion entre dos objetos Numero
/// </summary>
/// <param name="num1"></param> objeto 1
/// <param name="num2"></param> objeto 2
/// <param name="operador"></param> el operador para la operacion
/// <returns></returns> el resultado en variable double
public static double Operar(Numero num1, Numero num2, string operador)
{
int operadorInt;
string operadorString;
char operadorChar;
operadorString = Calculadora.ValidarOperador(Convert.ToChar(operador));
operadorChar = Convert.ToChar(operadorString);
operadorInt = operadorChar;
if (operadorInt == 43)
{
return(num1 + num2);
}
else if (operadorInt == 45)
{
return(num1 - num2);
}
else if (operadorInt == 47)
{
return(num1 / num2);
}
else if (operadorInt == 42)
{
return(num1 * num2);
}
else
{
return(5);
}
}
public double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
switch (Calculadora.ValidarOperador(operador))
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
//if (num2 == 0)
// {
resultado = double.MinValue;
// }
// else {
// return num1 / num2;
// }
break;
}
return(resultado);
}
public static double Operar(Numero num1, Numero num2, string operador)
{
double result = 0;
string aux;
aux = Calculadora.ValidarOperador(operador);
if (aux == "+")
{
result = num1 + num2;
}
else if (aux == "-")
{
result = num1 - num2;
}
else if (aux == "*")
{
result = num1 * num2;
}
else if (aux == "/")
{
result = num1 / num2;
if (Double.IsInfinity(result))
{
result = double.MinValue;
}
}
return(result);
}
/// <summary>
/// Valida y realiza la operacion
/// </summary>
/// <param name="num1">Primer operando</param>
/// <param name="num2">Segundo operando</param>
/// <param name="operador">Operador, indica la operacion a realizar</param>
/// <returns>Resultado de la operacion</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double retorno = 0;
string operadorValidado;
char operadorChar;
if (!(num1 is null) && !(num2 is null))
{
char.TryParse(operador, out operadorChar);
operadorValidado = Calculadora.ValidarOperador(operadorChar);
switch (operadorValidado)
{
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 correspondiente entre dos objetos de tipo Numero basandose en el operador recibido como parametro
/// </summary>
/// <param name="num1" objeto de tipo Numero ></param>
/// <param name="num2" objeto de tipo Numero></param>
/// <param name="operador" caracter que indica la operacion a realizar></param>
/// <returns> retorna el resultado de la operacion </returns>
public static double Operar(Numero num1, Numero num2, char operador)
{
double resultado = 0;
switch (Calculadora.ValidarOperador(operador))
{
case "-":
resultado = num1 - num2;
break;
case "/":
resultado = num1 / num2;
break;
case "*":
resultado = num1 * num2;
break;
default:
resultado = num1 + num2;
break;
}
return(resultado);
}
/// <summary>
/// Metodo estatico que que permite realizar una operacion entre dos objetos de tipo Numero.
/// </summary>
/// <param name="numero1"></param>Primer parametro con el que se va a operar.
/// <param name="numero2"></param>Segundo parametro con el que se va a operar.
/// <param name="operador"></param>Cadena que representa al operador para realizar la operacion entre los objetos recibidos.
/// <returns>Retorna el resultado de la operacion.</returns>
public static double Operar(Numero numero1, Numero numero2, string operador)
{
double resultado = 0;
switch (Calculadora.ValidarOperador(char.Parse(operador)))
{
case "+":
resultado = numero1 + numero2;
break;
case "-":
resultado = numero1 - numero2;
break;
case "*":
resultado = numero1 * numero2;
break;
case "/":
resultado = numero1 / numero2;
break;
}
return(resultado);
}
public static double Operar(Numero num1, Numero num2, string operador)
{
char operadorValidado = Calculadora.ValidarOperador(operador[0]);
double resultado = 0;
switch (operadorValidado)
{
case '+':
resultado = num1 + num2;
break;
case '-':
resultado = num1 - num2;
break;
case '*':
resultado = num1 * num2;
break;
case '/':
resultado = num1 / num2;
break;
}
return(resultado);
}
/// <summary>
/// Realiza una operación autorizada (+,-,*,/) entre dos objetos de clase Numero.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns>Retorna el resultado de la operación en tipo double. </returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
char auxOperador;
if (char.TryParse(operador, out auxOperador))
{
switch (Calculadora.ValidarOperador(auxOperador))
{
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 retorno = 0;
operador = Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
retorno = n1 + n2;
break;
case "-":
retorno = n1 - n2;
break;
case "*":
retorno = n1 * n2;
break;
case "/":
retorno = n1 / n2;
break;
}
return(retorno);
}
/// <summary>
/// hace la operacion entre dos objetos
/// </summary>
/// <param name="auxNumero1"> Primer objeto a operar </param>
/// <param name="auxNumero2"> Segundo objeto a operar </param>
/// <param name="auxOperador"> String que refleja el operador de la cuenta </param>
/// <returns> retorna el resultado de la cuenta </returns>
public static double Operar(Numero auxNumero1, Numero auxNumero2, string auxOperador)
{
string operadorValidado = Calculadora.ValidarOperador(auxOperador);
double resultado = 0;
switch (operadorValidado)
{
case "+":
resultado = auxNumero1 + auxNumero2;
break;
case "-":
resultado = auxNumero1 - auxNumero2;
break;
case "*":
resultado = auxNumero1 * auxNumero2;
break;
case "/":
resultado = auxNumero1 / auxNumero2;
break;
}
return(resultado);
}
public static double Operar(Numero num1, Numero num2, string operador)
{
//validará y realizará la operación pedida entre ambos números.
double resultado = 0;
operador = Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "/":
resultado = num1 / num2;
break;
case "*":
resultado = num1 * num2;
break;
}
return(resultado);
}
/// <summary>
/// recibe los operandos y el operador como argumentos
/// </summary>
/// <param name="num1">primer parametro Numero</param>
/// <param name="num2">segundo parametro Numero</param>
/// <param name="operador"> string operador</param>
/// <returns> retorna un double-resultado de la operacion</returns>
public double Operar(Numero num1, Numero num2, string operador)
{
string auxiliar;
double retorno = 0;
auxiliar = Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
retorno = (num1 + num2);
break;
case "-":
retorno = (num1 - num2);
break;
case "*":
retorno = (num1 * num2);
break;
case "/":
retorno = (num1 / num2);
break;
}
return(retorno);
}
/// <summary>
/// Realiza los calculos en base a los numeros y operador ingresados por el usuario.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns>El valor de la operacion. Sino puede realizarla -1.</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = -1;
if (operador.Length == 1)
{
string operadorValidado = Calculadora.ValidarOperador(operador[0]);
switch (operadorValidado)
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
resultado = num1 / num2;
break;
}
}
else
{
resultado = num1 + num2;
}
return(resultado);
}
public static double Operar(Numero n1, Numero n2, string op)
{
double r = 0;
if (op == "+" || op == "-" || op == "*" || op == "/")
{
switch (Calculadora.ValidarOperador(char.Parse(op)))
{
case "+":
r = n1 + n2;
break;
case "-":
r = n1 - n2;
break;
case "*":
r = n1 * n2;
break;
case "/":
r = n1 / n2;
break;
default:
break;
}
}
else
{
r = n1 + n2;
}
return(r);
}
/// <summary>
/// Validará y realizará la operación pedida entre ambos números
/// </summary>
/// <param name="num1">Número 1</param>
/// <param name="num2">Número 2</param>
/// <param name="operador">Operadores: +, -, /, *</param>
/// <returns>Si se tratara de una división por 0, retornará double.MinValue</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
string aux = Calculadora.ValidarOperador(operador);
switch (aux)
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "/":
if (num1 * num2 == 0)
{
resultado = double.MinValue;
}
else
{
resultado = num1 / num2;
}
break;
case "*":
resultado = num1 * num2;
break;
}
return(resultado);
}
public double Operar(Numero num1, Numero num2, string operador)
{
double resultado;
operador = Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
resultado = num1 / num2;
break;
default:
resultado = 0;
break;
}
return(resultado);
}
/// <summary>
/// Realiza un operacion matematica entre dos objetos de tipo Numero
/// </summary>
/// <param name="num1">Primer operando</param>
/// <param name="num2">Segundo operando</param>
/// <param name="operador">Operacion a relizar</param>
/// <returns></returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double ret = 0;
string operadorValido = Calculadora.ValidarOperador(operador);
switch (operadorValido)
{
case "+":
ret = num1 + num2;
break;
case "-":
ret = num1 - num2;
break;
case "*":
ret = num1 * num2;
break;
case "/":
ret = num1 / num2;
break;
}
return(ret);
}
/// <summary>
/// Metodo que opera dos valores de tipo Numero segun la operacion aritmetica seleccionada.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns></returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double retorno = double.MinValue;
if (!object.Equals(num1, null) && !object.Equals(num2, null))
{
switch (char.Parse(Calculadora.ValidarOperador(operador)))
{
case '+':
retorno = num1 + num2;
break;
case '-':
retorno = num1 - num2;
break;
case '*':
retorno = num1 * num2;
break;
case '/':
retorno = num1 / num2;
break;
}
}
return(retorno);
}
/// <summary>
/// Realiza la operación matemática solicitada
/// </summary>
/// <param name="num1">Número 1</param>
/// <param name="num2">Número 2</param>
/// <param name="operador">Operación a realizar</param>
/// <returns>Resultado de la operación matemática</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
operador = Calculadora.ValidarOperador(operador);//El operador será el que recibe esta función sólo si es válido, sino sera "+"
//Realiza la operación solicitada
switch (operador)
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
resultado = num1 / num2;
break;
default: //Error interno
resultado = double.MinValue;
break;
}
return(resultado);
}
public double Operar(Numero num1, Numero num2, string operador)
{
operador = Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
return(num1 + num2);
case "-":
return(num1 - num2);
case "*":
return(num1 * num2);
case "/":
if (num2.GetNumero == 0)
{
return(double.MinValue);
}
return(num1 / num2);
default:
return(0);
}
}
public static double Operar(Numero num1, Numero num2, string operador)
{
string auxOperador = Calculadora.ValidarOperador(operador);
double numRetorno = 0;
switch (auxOperador)
{
case "-":
numRetorno = num1 - num2;
break;
case "*":
numRetorno = num1 * num2;
break;
case "/":
numRetorno = Double.MinValue;
numRetorno = num1 / num2;
break;
case "+":
numRetorno = num1 + num2;
break;
}
return(numRetorno);
}
/// <summary>
/// Realiza la operacion establecida entre 2 objs Numero
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns></returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
switch (Calculadora.ValidarOperador(operador))
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
resultado = double.MinValue;
if (num2.Dato != 0)
{
resultado = num1 / num2;
}
break;
default:
break;
}
return(resultado);
}
/// <summary>
/// Validara y realizara la operacion pedida entre ambos numeros
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <param name="operador"></param>
/// <returns></returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
double resultado = 0;
string result;
operador = Calculadora.ValidarOperador(Convert.ToChar(operador));
/* resultado = num1 + num2;
*
* Console.WriteLine(" Resultado + :"+ resultado);
* resultado = num1 - num2;
* Console.WriteLine(" Resultado - :" + resultado);
* resultado = num1 * num2;
* Console.WriteLine(" Resultado * :" + resultado);
* resultado = num1 / num2;
* Console.WriteLine(" Resultado / :" + resultado);
*/
resultado = double.Parse(num1.DecimalBinario(31));
Console.WriteLine(" DecimalBinario :" + resultado);
resultado = double.Parse(num1.DecimalBinario("29"));
Console.WriteLine(" DecimalBinario :" + resultado);
result = num1.BinarioDecimal("1101001"); //1001011
//resultado = double.Parse(num1.BinarioDecimal("1101001"));
Console.WriteLine(" BinarioDecimal :" + result);
return(resultado);
}
public double Operar(Numero num1, Numero num2, String operador)
{
double rtaNum = 0;
Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
rtaNum = num1 + num2;
break;
case "-":
rtaNum = num1 - num2;
break;
case "*":
rtaNum = num1 * num2;
break;
case "/":
rtaNum = num1 / num2;
break;
default:
Console.WriteLine("?");
break;
}
return(rtaNum);
}
public static double Operar(Numero numero1, Numero numero2, string operador)
{
double result = 0;
char validOperator = Convert.ToChar(Calculadora.ValidarOperador(operador));
switch (validOperator)
{
case '+':
result = numero1 + numero2;
break;
case '-':
result = numero1 - numero2;
break;
case '*':
result = numero1 * numero2;
break;
case '/':
result = numero1 / numero2;
break;
}
return(result);
}
/// <summary>
/// Realiza una operación según corresponda y retorna el resultado.
/// </summary>
/// <param name="num1">Objeto número que se pasa por parámetro.</param>
/// <param name="num2">Objeto número que se pasa por parámetro.</param>
/// <param name="operador">El operador según la operación que corresponda.</param>
/// <returns>Retorna un resultado según la operación de tipo double.</returns>
public static double Operar(Numero num1, Numero num2, string operador)
{
string operacion = Calculadora.ValidarOperador(operador);
double resultado = 0;
switch (operacion)
{
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 num1, Numero num2, string operador)
{
operador = Calculadora.ValidarOperador(operador);
switch (operador)
{
case "+":
return(num1 + num2);
break;
case "-":
return(num1 - num2);
break;
case "/":
return(num1 / num2);
break;
case "*":
return(num1 * num2);
break;
default:
return(0);
break;
}
}
/// <summary>
/// Realiza la operacion matematica segun corresponda
/// </summary>
/// <param name="numero1">Primer numero</param>
/// <param name="numero2">Segundo numero</param>
/// <param name="operador">Operacion matematica a realizar</param>
/// <returns>"double Devuelve el resultado de la operación."</returns>
public static double operar(Numero num1, Numero num2, String operador)
{
double retorno = 0;
switch (Calculadora.ValidarOperador(operador))
{
case "+":
retorno = num1 + num2;
break;
case "-":
retorno = num1 - num2;
break;
case "*":
retorno = num1 * num2;
break;
case "/":
retorno = num1 / num2;
break;
}
return(retorno);
}
public double Operar(Numero num1, Numero num2, string operador)
{
// Se realiza la operacion segun el operador seleccionado
double resultado = 0;
switch (Calculadora.ValidarOperador(operador))
{
case "+":
resultado = num1 + num2;
break;
case "-":
resultado = num1 - num2;
break;
case "*":
resultado = num1 * num2;
break;
case "/":
resultado = num1 / num2;
break;
}
return(resultado);
}