public IActionResult Atualizar(Valores valor)
{
try
{
ValorRepositorio.Atualizar(valor);
return(Ok("Valor atualizado com suceso."));
}
catch (Exception ex)
{
return(BadRequest("Ocorreu um erro, não foi possivel atualizar valor."));
}
}
public IActionResult Cadastrar(Valores valor)
{
try
{
ValorRepositorio.Cadastrar(valor);
return(Ok("Valor cadastrado com sucesso."));
}
catch (Exception ex)
{
return(BadRequest("Ocorreu um erro, não foi possível cadastrar valor."));
}
}
private bool LerValor()
{
string entrada = Console.ReadLine();
if (string.IsNullOrEmpty(entrada))
{
return(false);
}
Valores.Add(Int32.Parse(entrada));
return(true);
}
//apartir del rnd, devuelve el valor asociado
public T ObtenerValorAsociado(double rnd)
{
for (var i = 1; i < intervaloHasta.Count; i++)
{
if (rnd < intervaloHasta[i])
{
return(Valores[i - 1].ValorAsociado);
}
}
return(Valores.Last().ValorAsociado);
}
public double CalcularSiguiente(double valor)
{
if (Valores.Count == Cantidad)
{
EliminarPrimero();
}
Valores.Add(valor);
var total = Valores.Sum();
return(total);
}
/// <summary>
/// Realiza cálculo de juros compostos de um porcento
/// </summary>
/// <param name="valores">Valores de entrada, valor inicial e meses</param>
/// <returns>ResultadoValores</returns>
public ResultadoValores CalcularUmPorcentoMeses(Valores valores)
{
return(new ResultadoValores()
{
//Valor Final = Valor Inicial * (1 + juros) ^ Tempo
Resultado = Math.Truncate(
Convert.ToDecimal((double)valores.ValorInicial * Math.Pow(1 + (double)valores.Juros, valores.Meses)) * 100
) / 100,
ResultadoNaoTruncado = Convert.ToDecimal((double)valores.ValorInicial * Math.Pow(1 + (double)valores.Juros, valores.Meses)),
Meses = valores.Meses,
ValorInicial = valores.ValorInicial
});
}
public double CalcularSiguiente(double valor)
{
if (Valores.Count == Cantidad)
{
EliminarPrimero();
}
Valores.Add(valor);
var promedio = Valores.Average();
return(promedio);
}
//apartir del rnd, devuelve el valor asociado
public T ObtenerValorAsociado(double rnd)
{
for (var i = 0; i < intervaloHasta.Count; i++)
{
if (rnd < intervaloHasta[i] * 100)
{
indice = i;
return(Valores[i].ValorAsociado);
}
}
indice = intervaloHasta.Count - 1;
return(Valores.Last().ValorAsociado);
}
private void ExecuteCalcularCommand()
{
float resultado = (float.Parse(Valor, culture) * 1000) / float.Parse(Quant, culture);
Result = resultado.ToString("N2", culture);
Valores.Add(new ValoresModel(Quant, Valor, Result));
float valorMinimo = 9999999;
if (valorMinimo > resultado)
{
Minimo = $"Preço de tabela: R${Valor}, Preço calculado:R${Result}";
valorMinimo = resultado;
}
}
public override float Calcular()
{
Resultado = Valores.GroupBy(i => i).OrderByDescending(grp => grp.Count())
.Select(grp => grp.Key).First();
var _Repeticoes = Valores.GroupBy(i => i).OrderByDescending(grp => grp.Count())
.First().Count();
Modas = Valores.GroupBy(i => i).Where(x => x.Count() == _Repeticoes).Distinct().OrderByDescending(grp => grp.Count()).Select(x => x.Key).ToList();
string RepeticoesCSV = String.Join(",", Modas);
Repeticoes = _Repeticoes == 1 ? 0 : _Repeticoes;
if (Repeticoes >= 0)
{
switch (Modas.Count)
{
case 0:
Classificacao = ClassificacaoModa.Amodal;
break;
case 1:
Classificacao = ClassificacaoModa.Unimodal;
break;
case 2:
Classificacao = ClassificacaoModa.Bimodal;
break;
case 3:
Classificacao = ClassificacaoModa.Trimodal;
break;
default:
Classificacao = ClassificacaoModa.Polimodal;
break;
}
}
else if (Resultado >= 4)
{
Classificacao = ClassificacaoModa.Polimodal;
}
Passos.WriteLineAsyncCounter($"{Titulo("Moda")}: Valor mais frequente ");
string ValoresCSV = String.Join(",", Valores);
Passos.WriteLineAsyncCounter($"{Titulo("Moda")}: " + (Repeticoes == 1 ? "Não existe moda na série": $"{RepeticoesCSV}. Repetiu {Repeticoes} vezes"));
Passos.WriteLineAsyncCounter($"Essa série é classificada como: {Enum.GetName(typeof(ClassificacaoModa), Classificacao)} ");
return(Resultado);
}
public async Task <ActionResult <bool> > GravarPagamentos([FromBody] Valores dados)
{
if (!ModelState.IsValid)
{
return(BadRequest(dados));
}
var result = dados.Tipo == ETipoModel.Provento ? await _repo.GravarValoresReceber(dados) : await _repo.GravarValoresPagar(dados);
if (!result)
{
return(BadRequest(result));
}
return(Ok(result));
}
public void SomarSucesso()
{
//Arrange
var valores = new Valores();
valores.AdicionarValorA(10);
valores.AdicionarValorB(10);
var calc = new Calc();
//Act
var resultado = calc.Adicao(valores);
//Assert
Assert.True(valores.ValorA + valores.ValorB == resultado);
}
public void SomarAleatorioFalha(int valorAleatorio)
{
//Arrange
var valores = new Valores();
valores.AdicionarValorA(10);
valores.AdicionarValorB(10);
var calc = new Calc();
//Act
var resultado = calc.Adicao(valores, valorAleatorio);
//Assert
Assert.False(valores.ValorA + valores.ValorB + valorAleatorio != resultado);
}
public void DivisaoFalha()
{
//Arrange
var valores = new Valores();
valores.AdicionarValorA(10);
valores.AdicionarValorB(10);
var calc = new Calc();
//Act
var resultado = calc.Divisao(valores);
//Assert
Assert.False(valores.ValorA / valores.ValorB != resultado);
}
public void MultiplicarFalha()
{
//Arrange
var valores = new Valores();
valores.AdicionarValorA(10);
valores.AdicionarValorB(10);
var calc = new Calc();
//Act
var resultado = calc.Multiplicacao(valores);
//Assert
Assert.False(valores.ValorA * valores.ValorB != resultado);
}
public void SubtrairAleatorioSucesso(int valorAleatorio)
{
//Arrange
var valores = new Valores();
valores.AdicionarValorA(10);
valores.AdicionarValorB(10);
var calc = new Calc();
//Act
var resultado = calc.Subtracao(valores, valorAleatorio);
//Assert
Assert.True(valores.ValorA - valores.ValorB - valorAleatorio == resultado);
}
/// <summary>
/// Calcular o juros de um determinado valor.
/// https://localhost:xxxx/api/Taxas
///
/// JSON:
/// {
/// "Juros": 0.5,
/// "Valor": 10000
/// }
/// </summary>
/// <param name="valores">Class Valores</param>
/// <returns>Retorna o valor acrescido dos juros</returns>
public HttpResponseMessage Post([FromBody] Valores valores)
{
if (valores == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
decimal Juros = valores.Juros / 100 * valores.Valor;
decimal Resultado = Math.Round(valores.Valor + Juros, 2, MidpointRounding.AwayFromZero);
var response = Request.CreateResponse(HttpStatusCode.OK, Resultado);
return(response);
}
static void CrearTablasGam(OrmLiteConnectionFactory dbfactory, Valores valores)
{
var overwrite = false;
using (var con = dbfactory.Open()) {
con.CreateTable <PersonaRegional>(overwrite);
con.CreateTable <Gam>(overwrite);
con.CreateTable <MiembroGam>(overwrite);
con.CreateTable <PlantillaEncuesta>();
con.CreateTable <PreguntaPlantillaEncuesta>(overwrite);
con.CreateTable <EncuestaGam>(overwrite);
con.CreateTable <RespuestaEncuestaGam>(overwrite);
var codigoEncuestaAlivioEmocional = valores.AlivioEmocionalParametros.CodigoEncuesta;
var plantillaEncuestaAlivioEmocional = con.Single <PlantillaEncuesta>(q => q.Codigo == codigoEncuestaAlivioEmocional) ?? new PlantillaEncuesta();
if (plantillaEncuestaAlivioEmocional.Id == 0)
{
plantillaEncuestaAlivioEmocional.Codigo = codigoEncuestaAlivioEmocional;
plantillaEncuestaAlivioEmocional.Inactiva = false;
plantillaEncuestaAlivioEmocional.Aprobada = true;
plantillaEncuestaAlivioEmocional.Nombre = "Alivio Emocional";
plantillaEncuestaAlivioEmocional.Descripcion = "Encuesta para el seguimiento del alivio emocional participantes GAM";
plantillaEncuestaAlivioEmocional.FechaCreacion = DateTime.UtcNow;
plantillaEncuestaAlivioEmocional.CreadoPorId = 28;
try
{
var idPlantillaEncuesta = con.Insert(plantillaEncuestaAlivioEmocional, selectIdentity: true);
var codigoPreguntaComoMeSiento = valores.AlivioEmocionalParametros.CodigoEPreguntaComoMeSiento;
var pregunta = new PreguntaPlantillaEncuesta
{
PlantillaEncuestaId = (int)idPlantillaEncuesta,
Codigo = codigoPreguntaComoMeSiento,
Texto = "Al día de hoy como considera que se encuentra dentro del proceso de Alivio Emocional",
TipoRespuesta = "Texto",
FechaCreacion = DateTime.UtcNow,
CreadoPorId = 28
};
con.Insert(pregunta, selectIdentity: true);
}
catch (Exception ex) {
Console.WriteLine(ex);
}
}
}
}
// FINALIZA LA PROGRAMACION DE MATERIA
//INICIA LA PROGMACION DE VALORES
private void btnGuardarvalores_Click(object sender, RoutedEventArgs e)
{
if (txtvalor.Text != "")
{
Valores _Valor = new Valores();
_Valor.Nombre = txtvalor.Text;
valoresBL.Create(_Valor);
UpdateGrid();
Clear();
Enable(false);
}
else
{
MessageBox.Show("Los campos son obligatorios", "Guardar", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void buttonSalvar_Click(object sender, EventArgs e)
{
Valores vl = new Valores();
MessageBox.Show("Tem certeza que deseja incluir os valores?", "Confirmacao", MessageBoxButtons.OKCancel);
vl.Id = 1;
vl.ValorAluguel = Convert.ToDecimal(textBoxValorAluguel.Text);
vl.ValorMulta = Convert.ToDecimal(textBoxValorMulta.Text);
vl.ValorDesconto = Convert.ToDecimal(textBoxValorDesconto.Text);
va.ValorAluguelMultaNovo(vl);
MessageBox.Show("Mensagem incluida", "Okey baby", MessageBoxButtons.OK);
Limpartxtbox();
Atualiza();
}
public double ObtenerValor(double random)
{
if (random < 0 || random > 1)
{
throw new NotSupportedException("El número aleatorio debe estar entre 0 y 1");
}
for (var i = 1; i < RandomAsociados.Count; i++)
{
if (random < RandomAsociados[i])
{
return(Valores[i - 1].Valor);
}
}
return(Valores.Last().Valor);
}
private void GenerarTablaRandom()
{
if (Valores.Sum(v => v.ProbabilidadAsociada) > 1)
{
throw new NotSupportedException("La suma de las probabilidades no puede ser mayor a 1");
}
Valores = Valores.OrderBy(v => v.Valor).ToList();
RandomAsociados = new List <double> {
0
};
for (var i = 1; i < Valores.Count; i++)
{
RandomAsociados.Add(RandomAsociados[i - 1] + Valores[i - 1].ProbabilidadAsociada);
}
}
public string ValoresFormat()
{
string val = null;
for (int i = 0; i < (Orden - 1); i++)
{
if (Valores.ElementAt(i) != null)
{
val = val + Valores.ElementAt(i).ToFixedLenghtString();
}
else
{
val = val + $"|{int.MaxValue.ToString("00000000000;-00000000000")}";
}
}
return(val);
}
private void escribirMinHeap()
{
Graphics g = Valores.CreateGraphics();
g.DrawString("MINIMUN HEAP: ", new Font("Algerian", 14, FontStyle.Bold), System.Drawing.Brushes.Black, new Point(10, 20));
g.DrawString("an insert of the nodes, one", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(15, 60));
g.DrawString("at a time, is made, followed", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(15, 80));
g.DrawString("by a push, from bottom to up, ", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(15, 100));
g.DrawString("of the inserted node, checking", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(15, 120));
g.DrawString("if its minor than his father", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(15, 140));
g.FillEllipse(System.Drawing.Brushes.White, 15, 190, 30, 30);
g.DrawString("Inserted Node", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(60, 200));
g.FillEllipse(System.Drawing.Brushes.Red, 15, 240, 30, 30);
g.DrawString("Node about to exchange", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(60, 240));
g.DrawString("with his root", new Font("Algerian", 12, FontStyle.Bold), System.Drawing.Brushes.Gray, new Point(60, 260));
}
public override float Calcular()
{
Valores = Valores.ToList().OrderBy(x => x).ToList();
string ValoresCSV = String.Join(",", Valores);
Passos.WriteLineAsyncCounter($"{Titulo("Ordene os dados (K):")} {GerarTabelaDeFrequencia()}");
NumeroDeElementos = Valores.Count;
ValorMinimo = CalcularValorMinimo(Valores);
ValorMaximo = CalcularValorMaximo(Valores);
Amplitude = CalcularAmplitudeA(ValorMinimo, ValorMaximo);
if (Simples)
{
QuantidadeIntervalos = ValoresDistintos.Count();
}
else
{
QuantidadeIntervalos = CalcularQuantidadeIntervalosK(NumeroDeElementos);
}
Intervalo = CalcularTamanhoIntervaloH(Amplitude, QuantidadeIntervalos);
CalcularTodosOsIntervalos();
Moda.Calcular();
//Passos.Append(Moda.Passos.ToString());
Mediana.Calcular();
//Passos.Append(Mediana.Passos.ToString());
DesvioPadrao.Calcular();
//Passos.Append(DesvioPadrao.Passos.ToString());
Variancia.Calcular();
//Passos.Append(Variancia.Passos.ToString());
Media.Calcular();
//Passos.Append(Media.Passos.ToString());
CoeficienteVariacao.Calcular();
Passos.Close();
return(0f);
}
//Genera la tabla con los intervalos
private void GenerarTabla()
{ //ordena las p(x)
Valores = Valores.OrderBy(v => v.ValorAsociado).ToList();
intervaloHasta = new List <double>();
//setea los intervalos
for (var i = 0; i < Valores.Count; i++)
{
if (intervaloHasta.Count == 0)
{
intervaloHasta.Insert(i, 0 + Valores[i].ProbabilidadAsociada - 0.01);
}
else
{
intervaloHasta.Insert(i, (intervaloHasta[i - 1] + Valores[i - 1].ProbabilidadAsociada));
}
}
}
public Juego(Valores jugador)
{
valorJugador = jugador;
valorMaquina = (Valores)rdm.Next(0, 3);
this.ganador = "maquina";
switch ((int)this.valorJugador)
{
case 0:
if ((int)this.valorMaquina == 0)
{
this.ganador = "empate";
}
else if ((int)this.valorMaquina == 2)
{
this.ganador = "jugador";
}
break;
case 1:
if ((int)this.valorMaquina == 0)
{
this.ganador = "jugador";
}
else if ((int)this.valorMaquina == 1)
{
this.ganador = "empate";
}
break;
case 2:
if ((int)this.valorMaquina == 1)
{
this.ganador = "jugador";
}
else if ((int)this.valorMaquina == 2)
{
this.ganador = "empate";
}
break;
}
actualizarEstadisticas();
}
public string Pop(int position)
{
if (Valores.Count == 1)
{
throw new InvalidOperationException("Cannot pop value from a 1 key node");
}
if (position < Valores.Count)
{
string k = Valores[position];
Valores.RemoveAt(position);
return(k);
}
return(null);
}
private void Calcular(object sender, EventArgs e)
{
try
{
var valor = new Valores();
valor.Valor1 = textBox1.Text;
valor.Valor2 = textBox2.Text;
int resSoma = valor.soma(Convert.ToInt32(valor.Valor1), Convert.ToInt32(valor.Valor2));
int resSubtracao = valor.subtracao(int.Parse(valor.Valor1), int.Parse(valor.Valor2));
int resMultiplicacao = valor.multiplicacao(int.Parse(valor.Valor1), int.Parse(valor.Valor2));
int resDivisao = valor.divisao(int.Parse(valor.Valor1), int.Parse(valor.Valor2));
// Remover todos os itens
listBox1.Items.Clear();
// Adicionar itens
listBox1.Items.Add("A soma é " + resSoma);
listBox1.Items.Add("A subtração é " + resSubtracao);
listBox1.Items.Add("A multiplicação é " + resMultiplicacao);
listBox1.Items.Add("A divição é " + resDivisao);
}
catch (System.FormatException ex)
{
Console.WriteLine("Codigo de erro: " + ex.GetType());
const string message = "Valor Inválido";
const string caption = "ERRO";
var result = MessageBox.Show(message, caption,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
catch (Exception ex)
{
Console.WriteLine(ex.GetType());
Console.WriteLine("Codigo de erro: " + ex.GetType());
const string message = "Erro Desconhecido";
const string caption = "ERRO";
var result = MessageBox.Show(message, caption,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
static async Task execute()
{
Console.Clear();
var valor = new Valores();
Console.Write("Digite o primeiro valor: ");
valor.Valor1 = Console.ReadLine();
Console.Write("Digite o segundo valor: ");
valor.Valor2 = Console.ReadLine();
Console.Clear();
Console.Write("Aguardando...");
await Task.Delay(TimeSpan.FromSeconds(2));
Console.Clear();
Console.WriteLine("A soma é " + valor.soma(int.Parse(valor.Valor1), int.Parse(valor.Valor2)));
Console.WriteLine("A subtração é " + valor.subtracao(int.Parse(valor.Valor1), int.Parse(valor.Valor2)));
Console.WriteLine("A multiplicação é " + valor.multiplicacao(Convert.ToInt32(valor.Valor1), Convert.ToInt32(valor.Valor2)));
Console.WriteLine("A divisão é " + valor.divisao(int.Parse(valor.Valor1), int.Parse(valor.Valor2)));
}
