/// <summary>
/// Realiza una operacion matematica entre dos numeros
/// </summary>
private static double Operar(string numero1, string numero2, string operador)
{
Operando n1 = new Operando(numero1);
Operando n2 = new Operando(numero2);
return(Calculadora.Operar(n1, n2, operador));
}
//METOODOS
/// <summary>
/// recibe los valores para operar y el operador, retorna el resultado
/// </summary>
/// <param name="numero1"></param>
/// <param name="numero2"></param>
/// <param name="operador"></param>
/// <returns></returns>
private static double Operar(string numero1, string numero2, string operador)
{
Operando numeroUno = new Operando(numero1);
Operando numeroDos = new Operando(numero2);
return(Calculadora.Operar(numeroUno, numeroDos, operador));
}
public override string GenerarCodigo()
{
string codigo = "";
if (Operando != null)
codigo = Operando.GenerarCodigo() + "--";
return codigo;
}
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
if (lblResultado.Text != string.Empty)
{
lblResultado.Text = Operando.BinarioDecimal(lblResultado.Text);
}
}
/// <summary>
/// Realiza el cálculo entre los operandos recibidos, validando previamente que el operador a utilizar sea
/// +,-,*,/. Operará con '+' en caso de que se haya ingresado cualquier otro valor a través del parámetro char.
/// </summary>
/// <param name="num1">Operando uno</param>
/// <param name="num2">Operando dos</param>
/// <param name="operador">Operador</param>
/// <returns></returns>
public static double Operar(Operando num1, Operando num2, char operador)
{
char operadorValidado = ValidarOperador(operador);
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);
}
//El método Operar será estático recibirá los dos números y el operador para luego
//llamar al método Operar de Calculadora y retornar el resultado al método de
//evento del botón btnOperar que reflejará el resultado en el Label txtResultado.
private static double Operar(string numero1, string numero2, string operador)
{
Operando num1 = new Operando(numero1);
Operando num2 = new Operando(numero2);
return(Calculadora.Operar(num1, num2, operador.ToCharArray()[0]));
}
/// <summary>
/// Convierte el resultado de la operación en un numero binario y lo muestra en lblResultado
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvertirABinario_Click(object sender, EventArgs e)
{
this.lblResultado.Text = Operando.DecimalBinario(this.lblResultado.Text);
btnConvertirABinario.Enabled = false;
btnConvertirADecimal.Enabled = true;
this.lstOperaciones.Items.Add(this.lblResultado.Text);
}
/// <summary>
/// utiliza el metodo operar() de la clase Calculadora para realizar la operacion solicitada
/// </summary>
/// <param name="numero1"></param>
/// <param name="numero2"></param>
/// <param name="operador"></param>
/// <returns> double resultado de la operacion solicitada </returns>
private static double Operar(string numero1, string numero2, char operador)
{
Operando primerOperando = new Operando(numero1);
Operando segundoOperando = new Operando(numero2);
return(Calculadora.Operar(primerOperando, segundoOperando, operador));
}
/// <summary>
/// Accion del boton Convertir a Decimal. Convierte el numero contenido en el
/// label del resultado a decimal si es posible. Caso contrario devuelve
/// "Valor invalido"
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvertirABinario_Click(object sender, EventArgs e)
{
Operando numero = new Operando();
string temp = this.lblResultado.Text;
this.lblResultado.Text = numero.DecimalBinario(temp);
}
/// <summary>
/// Convierte el numero en el label a Decimal
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
string numero = lblResultado.Text;
Operando num = new Operando();
lblResultado.Text = num.BinarioDecimal(numero);
}
/// <summary>
/// Operar recibe los numeros ingresados y el string, y llama a la función Calculadora.Operar.
/// </summary>
/// <param name="numero1"></param>
/// <param name="numero2"></param>
/// <param name="operador"></param>
/// <returns></returns>
private static double Operar(string numero1, string numero2, string operador)
{
Operando num1 = new Operando(numero1);
Operando num2 = new Operando(numero2);
double resultado = Calculadora.Operar(num1, num2, Convert.ToChar(operador));
return(resultado);
}
/// <summary>
/// Convierte el resultado a Binario.
/// </summary>
private void btnConvertirABinario_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(this.lblResultado.Text))
{
Operando nro1 = new Operando();
this.lblResultado.Text = nro1.DecimalBinario(this.lblResultado.Text);
}
}
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
lblResultado.Text = Operando.BinarioDecimal(lblResultado.Text);
btnConvertirABinario.Enabled = lblResultado.Text != "Valor invalido" ? true : false;
btnConvertirADecimal.Enabled = false;
}
public override TiposBases ValidateSemantic()
{
var identificador = Operando.ValidateSemantic();
var tipo = new YreferenciaTipo();
tipo.tipoReferencia = identificador;
return(tipo);
}
/// <summary>
/// Metodo que toma los dos string de la aplicacion Form y el string elegido
/// en el combobox para crear dos objetos numeros y realizar la operacion
/// matematica deseada mediante el metodo Operar de la clase estatica
/// Calculadora
/// </summary>
/// <param name="numero1">el primer miembro de la operacion. </param>
/// <param name="numero2">el segundo miebro de la operacion. </param>
/// <param name="operador">El caracter que identifica al operador de la funcion</param>
/// <returns>el double resultado de la operacion</returns>
private double Operar(string numero1, string numero2, string operador)
{
Operando objetoOperando1 = new Operando(numero1);
Operando objetoOperando2 = new Operando(numero2);
return(Calculadora.Operar(objetoOperando1, objetoOperando2, operador));
}
/// <summary>
/// Realiza el cálculo entre los numeros pasados por parámetro de acuerdo al operador.
/// </summary>
/// <param name="numero1">Primer operando</param>
/// <param name="numero2">Segundo operando</param>
/// <param name="operador">Operador que determina el cálculo a realizar</param>
/// <returns></returns>
private static double Operar(string numero1, string numero2, string operador)
{
char.TryParse(operador, out char operadorAChar);
Operando num1 = new Operando(numero1.Replace('.', ','));
Operando num2 = new Operando(numero2.Replace('.', ','));
return(Calculadora.Operar(num1, num2, operadorAChar));
}
/// <summary>
/// Convierte el resultado a Decimal.
/// </summary>
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
Operando nro1 = new Operando();
if (this.lblResultado.Text != "")
{
this.lblResultado.Text = nro1.BinarioDecimal(this.lblResultado.Text);
}
}
private void btnConvertirABinario_Click(object sender, EventArgs e)
{
Operando resultado = new Operando();
// Traigo resultado y lo pongo en label
this.lblResultado.Text = resultado.DecimalBinario(this.lblResultado.Text);
btnConvertirADecimal.Enabled = true;
btnConvertirABinario.Enabled = false;
}
public static double Operar(string numero1, string numero2, string operador)
{
Operando num1 = new Operando(numero1);
Operando num2 = new Operando(numero2);
char simbolo = Convert.ToChar(operador);
double respuesta = Calculadora.Operar(num1, num2, simbolo);
return(respuesta);
}
/// <summary>
/// Realiza la operacion deseada entre los dos numeros ingresados
/// </summary>
/// <param name="numero1">Primer operando</param>
/// <param name="numero2">Segundo operando</param>
/// <param name="operador">Operador escogido</param>
/// <returns>El resultado de la operacion</returns>
private static double Operar(string numero1, string numero2, string operador)
{
char auxChar;
Operando PrimerNumero = new Operando(numero1);
Operando SegundoNumero = new Operando(numero2);
char.TryParse(operador, out auxChar);
return(Calculadora.Operar(PrimerNumero, SegundoNumero, auxChar));
}
public override TiposBases ValidateSemantic()
{
var expresion = Operando.ValidateSemantic();
if (expresion is BooleanTipo)
{
return(new BooleanTipo());
}
throw new SemanticoException("La expresion debe ser booleana" + Operando._TOKEN.Fila + " columna " + Operando._TOKEN.Columna);
}
public override TiposBases ValidateSemantic()
{
var operador = Operando.ValidateSemantic();
if (operador is IntTipo || operador is CharTipo)
{
return(new IntTipo());
}
throw new Sintactico.SintanticoException(" no se puede negar el tipo " + operador + " " + Operando._TOKEN.Fila + " columna " + Operando._TOKEN.Columna);
}
public override TiposBases ValidateSemantic()
{
var expresion = Operando.ValidateSemantic();
if (expresion is IntTipo || expresion is FloatTipo)
{
return(expresion);
}
throw new SemanticoException("se esperaba un literal numerica " + Operando._TOKEN.Fila + " columna " + Operando._TOKEN.Columna);
}
/// <summary>
/// Llama a la funcion BinarioDecimal, y la imprime en el lblResultado y en el lstOperaciones.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
string aux = lblResultado.Text;
lblResultado.Text = Operando.BinarioDecimal(lblResultado.Text);
if (lblResultado.Text != "Valor inválido" && lblResultado.Text != "No se admiten negativos")
{
lstOperaciones.Items.Add(aux + " a decimal: " + lblResultado.Text);
}
}
public override TiposBases ValidateSemantic()
{
var expresion = Operando.ValidateSemantic();
if (expresion is StructTipo || expresion is ConstTipo || expresion is BooleanTipo || expresion is EnumTipo)
{
throw new Sintactico.SintanticoException("este tipo no puede incrementarse" + Operando._TOKEN.Fila + " columna " + Operando._TOKEN.Columna);
}
return(expresion);
}
public override string GenerarCodigo()
{
string codigo = "";
if (Operando != null)
{
codigo = "--" + Operando.GenerarCodigo();
}
return(codigo);
}
public override TiposBases ValidateSemantic()
{
var expresion = Operando.ValidateSemantic();
if (!(Operando is IdentificadorNode))
throw new SemanticoException("no se puede autoIncrementarLiterales literales fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
if (expresion is FloatTipo || expresion is IntTipo || expresion is CharTipo || expresion is EnumTipo)
return expresion;
throw new Sintactico.SintanticoException("este tipo no puede decrementarse fila" + Operando._TOKEN.Fila + " columna " + Operando._TOKEN.Columna);
}
/// <summary>
/// Convierte el valor que esté en ese momento en el labelResultado a Decimal, deshabilitando el botón que permitió esta operación
/// y habilitando el que permite volver a pasar el número a Binario.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnConvertirADecimal_Click(object sender, EventArgs e)
{
Operando numeroBinario = new Operando();
this.lblResultado.Text = numeroBinario.BinarioDecimal(this.lblResultado.Text);
this.lstOperaciones.Items.Add("Conv. Binario a Decimal:");
this.lstOperaciones.Items.Add(this.lblResultado.Text);
this.btnConvertirADecimal.Enabled = false;
this.btnConvertirABinario.Enabled = true;
}
/// <summary>
/// Realiza operacion matematica
/// </summary>
/// <param name="numero1">Operando tipo string</param>
/// <param name="numero2">Operador tipo string</param>
/// <param name="operador">Operador tipo string</param>
/// <returns>Resultado de operacion double</returns>
private static double Operar(string numero1, string numero2, string operador)
{
char operadorChar;
Operando numUnoObj = new Operando(numero1);
Operando numDosObj = new Operando(numero2);
char.TryParse(operador, out operadorChar);
return(Calculadora.Operar(numUnoObj, numDosObj, operadorChar));
}
public DadosAlerta Cadastrar(
string Chave,
string IdCliente,
string Instrumento,
Operando TipoOperando,
Operador TipoOperador,
decimal Valor,
DateTime dataHoraCadastro)
{
DadosAlerta Dados = new DadosAlerta();
Dados.IdAlerta = Chave;
Dados.IdCliente = IdCliente;
Dados.Instrumento = Instrumento;
Dados.TipoOperando = TipoOperando;
Dados.TipoOperador = TipoOperador;
Dados.Valor = Valor;
Dados.DataCadastro = dataHoraCadastro;
alertas.Add(Chave, Dados);
// Adiciona em clienteVsAlertas
HashSet <string> alertasCliente;
if (clienteVsAlertas.ContainsKey(IdCliente))
{
alertasCliente = clienteVsAlertas[IdCliente];
alertasCliente.Add(Chave);
}
else
{
alertasCliente = new HashSet <string>();
alertasCliente.Add(Chave);
clienteVsAlertas.Add(IdCliente, alertasCliente);
}
// Adiciona em instrumentosVsAlertas
HashSet <string> alertasInstrumento;
if (instrumentoVsAlertas.ContainsKey(Instrumento))
{
alertasInstrumento = instrumentoVsAlertas[Instrumento];
alertasInstrumento.Add(Chave);
}
else
{
alertasInstrumento = new HashSet <string>();
alertasInstrumento.Add(Chave);
instrumentoVsAlertas.Add(Instrumento, alertasInstrumento);
}
return(Dados);
}
