// Use this for initialization
void Start()
{
// Inicializaçao do Controle do Personagem
controller = GetComponent<CharacterController> ();
passos = GetComponent<Passos> ();
mira = GameObject.Find ("Mira").GetComponent<Mira> ();
}
public override float Calcular()
{
float Media = Valores.Average();
Passos.WriteLineAsyncCounter($"O {Titulo("Desvio padrão")} é uma medida que expressa o grau de dispersão de um conjunto de dados:");
Passos.WriteLineAsyncCounter($" {HTMLElements.Img(Properties: "src='https://dados-agrupados-api.herokuapp.com/Imagens/desvio-padrao-1.png'")}");
Passos.WriteLineAsyncCounter($"Obter a média aritimética dos dados (Ma) = {Media}");
Passos.WriteLineAsyncCounter($"Obter o número de termos (N) = {Valores.Count}");
Passos.WriteLineAsyncCounter($"(Somátorio de Xi = 1 até a posição N ({Valores.Count}) menos a média ({Media})) elevado ao quadrado{HTMLElements.Hr()}");
int xi = 1;
foreach (var Elemento in Valores)
{
//Passos.WriteLineAsync($"Termo (x{xi}) = {Elemento}");
var operacao = (Elemento - Media) * (Elemento - Media);
Resultado += operacao;
Passos.WriteLineAsync($"$$ {(xi > 1 ? '+' : ' ')}(" + Elemento + " - " + Media.ToString("F2") + $")^ 2 = {operacao} ..." + Resultado + $" $$ {HTMLElements.Hr()}");
xi++;
}
Passos.WriteLineAsyncCounter($"Obter a raíz quadrada da divisão do somatório ({Resultado}) pelo numero de termos ({Valores.Count}) {HTMLElements.Hr()}");
var operacaoFinal = (float)Math.Sqrt(Resultado / Valores.Count());
Passos.WriteLineAsync($"\n $$ Resultado = \\sqrt {{ \\dfrac{{ {{{Resultado}}} }} {{{Valores.Count()}}} }} = {{{operacaoFinal}}}$$");
Resultado = operacaoFinal;
return(Resultado);
}
private float CalcularAmplitudeA(float ValorMinimo, float ValorMaximo)
{
Amplitude = ValorMaximo - ValorMinimo;
Passos.WriteLineAsyncCounter($"{Titulo("Calcule a Amplitude (A)")}: $$ A = ValorMaximo - ValorMinimo $$");
Passos.WriteLineAsync($"$$ A = {ValorMaximo} - {ValorMinimo} = {Amplitude} $$");
return(Amplitude);
}
public override float Calcular()
{
int pos = Math.Abs((Valores.Count / 2) - 1);
string ValoresCSV = String.Join(",", Valores);
Valores = Valores.ToList().OrderBy(x => x).ToList();
Passos.WriteLineAsyncCounter($"Elementos: {ValoresCSV}");
if (Valores.Count == 1)
{
Resultado = Valores[0];
}
else if (Valores.Count % 2 != 0)
{
Resultado = Valores[Valores.Count / 2];
}
else
{
Passos.WriteLineAsyncCounter($"Lista de contagem par:");
Passos.WriteLineAsyncCounter($"Some os dois elementos do centro ({Valores[pos]} e {Valores[pos + 1]}) e divida por 2(dois):");
Resultado = Math.Abs((Valores[pos] + Valores[pos + 1]) / 2);
Passos.WriteLineAsync($"$$ \\dfrac{{ {{ {Valores[pos]} + {Valores[pos + 1]} }} }} {{2}} = \\dfrac{{ {{ {Valores[pos] + Valores[pos + 1]} }} }} {{2}} = {Resultado} $$");
}
Passos.WriteLineAsyncCounter($"{HTMLElements.Hr()} {Titulo("Mediana")}: Valores no centro da lista : {Resultado}");
return(Resultado);
}
private float CalcularMediaXI(float Abertura, float Fim)
{
float resultado = (Abertura + Fim) / 2;
Passos.WriteLineAsync($"{Titulo("Média do intervalo")}: $$ Ma = {{ \\dfrac{{ {{Abertura + Fim}} }} {{2}} }}$$");
Passos.WriteLineAsync($"$$ Ma = {{ \\dfrac{{ {{{Abertura + Fim}}} }} {{{2}}} }} = {resultado} $$");
return(resultado);
}
private float CalcularTamanhoIntervaloH(float Amplitude, double QuantidadeIntervalos)
{
var Intervalo = (float)(Amplitude / QuantidadeIntervalos);
Passos.WriteLineAsync($"{Titulo("Calcule o Tamanho do Intervalo (H)")}: {HTMLElements.Br()} $$ H = \\dfrac{{ {{A}} }} {{K}} $$");
Passos.WriteLineAsync($"$$ H = \\dfrac{{ {{{Amplitude}}} }} {{{QuantidadeIntervalos}}} = {Intervalo} $$");
Intervalo = (float)((Intervalo % 1) > 0 ? Amplitude / RecalcularK() : Intervalo);
return(Intervalo);
}
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);
}
private float CalcularFrequenciaRelativa(int pos)
{
float Fr = fi[pos] / NumeroDeElementos * 100;
Passos.WriteLineAsyncCounter($"{Titulo(ClassToHTML.AninharEmEm($"Freq. Relativa de {ClassToHTML.AninharEmEm($"{ValoresDistintos[pos].Key}")} [x{pos + 1}]"))}: ");
if (pos == 0)
{
Passos.WriteLine($" $$ Fr = {{ \\dfrac{{ {{Fi}} }} {{N}} }} * 100 $$");
}
else
{
Passos.WriteLine($" $$ Fi = {fi[pos]} $$ $$ N = {NumeroDeElementos} $$");
}
Passos.WriteLineAsync($"$$ Fr = {{ \\dfrac{{ {{{fi[pos]}}} }} {{{NumeroDeElementos}}} }} * 100 = {Fr} $$");
return(Fr);
}
private double CalcularQuantidadeIntervalosK(int NumeroDeElementos, bool HEraDecimal = false)
{
if (HEraDecimal)
{
var sqrt = Math.Sqrt(Valores.Count);
var K = Math.Floor(sqrt);
if (!Simples)
{
QuantidadeIntervalos = K;
}
Passos.WriteLineAsync($"$$ K = \\sqrt {NumeroDeElementos} = {sqrt} ... { K} $$");
return(QuantidadeIntervalos);
}
Passos.WriteLineAsyncCounter($"{Titulo("Calcule a Quantidade de Intervalos (h)")}:");
Passos.WriteLineAsyncCounter($"{Titulo("- Tabela de Truman")}:");
Passos.WriteLineAsyncCounter($"Usado para o caso N descrito:");
Passos.WriteLineAsync(GerarTabelaDeTruman());
switch (NumeroDeElementos)
{
case 5:
QuantidadeIntervalos = 2;
break;
case 10:
QuantidadeIntervalos = 4;
break;
case 25:
QuantidadeIntervalos = 6;
break;
case 50:
QuantidadeIntervalos = 8;
break;
case 100:
QuantidadeIntervalos = 10;
break;
default:
QuantidadeIntervalos = (float)Math.Sqrt(NumeroDeElementos);
break;
}
return(QuantidadeIntervalos);
}
private float CalcularFrequenciaSimplesAcumulada(int pos)
{
Passos.WriteLineAsyncCounter($"{Titulo("Freq. Simples Acum. de")} {ClassToHTML.AninharEmEm($"{ValoresDistintos[pos].Key}")} {ClassToHTML.AninharEmEm($"[x{pos + 1}]")}: {(pos > 0 ? fi.Sum().ToString(): fi[pos].ToString())} ");
float resultado;
if (pos > 0)
{
resultado = fi.Sum();
}
else
{
resultado = fi[pos];
}
Passos.WriteLineAsync($"{GerarTabelaDeFsAcumulada(pos,resultado)}");
return(resultado);
}
private float CalcularFrequenciaRelativaAcumulada(int pos)
{
float resultado;
if (pos > 0)
{
resultado = fr.Sum();
}
else
{
resultado = fr[pos];
}
Passos.WriteLineAsyncCounter($"{Titulo(ClassToHTML.AninharEmEm($"Freq. Relativa Acumu. de {ClassToHTML.AninharEmEm($"{ValoresDistintos[pos].Key}")} [x{pos + 1}] "))}: {resultado}% {HTMLElements.Hr()}");
Passos.WriteLineAsync($"{GerarTabelaDeFrAcumulada(pos,resultado)}");
return(resultado);
}
private void CalcularTodosOsIntervalos()
{
float Abertura = ValorMinimo;
Passos.WriteLineAsyncCounter($"{Titulo("Calcular Abertura do Intervalo")}: Começa pelo Valor Minimo = {ValorMinimo} {HTMLElements.Hr()}");
for (int i = 0; i < QuantidadeIntervalos; i++)
{
try
{
if (!Simples)
{
float FimIntervalo = Abertura + Intervalo;
intervalos.Add($"{Abertura.ToString("0.00")}|--{FimIntervalo.ToString("0.00")}");
Passos.WriteLineAsyncCounter($"{Titulo("Calcule o Final do Intervalo")}: Abertura + Intervalo ");
Passos.WriteLineAsync($"$$ {Abertura} + {Intervalo} = {Abertura + Intervalo}$$");
Passos.WriteLineAsyncCounter($"{Titulo("Calcule o Intervalo")}: Abertura |-- Fim ");
Passos.WriteLineAsync($"$${Abertura.ToString("0.00")}|--{FimIntervalo.ToString("0.00")} $$");
xi.Add(CalcularMediaXI(Abertura, FimIntervalo));
fi.Add(CalcularFrequenciaSimples(Abertura, FimIntervalo));
Fi.Add(CalcularFrequenciaSimplesAcumulada(i));
fr.Add(CalcularFrequenciaRelativa(i));
Fr.Add(CalcularFrequenciaRelativaAcumulada(i));
Abertura = FimIntervalo;
}
else
{
Passos.WriteLineAsyncCounter($"{Titulo("Freq. Simples de ")} {ClassToHTML.AninharEmEm($"{ValoresDistintos[i].Key} [x{i + 1}]")}: {ValoresDistintos[i].Value}");
xi.Add(ValoresDistintos[i].Key);
fi.Add(ValoresDistintos[i].Value);
Fi.Add(CalcularFrequenciaSimplesAcumulada(i));
fr.Add(CalcularFrequenciaRelativa(i));
Fr.Add(CalcularFrequenciaRelativaAcumulada(i));
}
}
catch (Exception)
{
continue;
}
}
}
public override float Calcular()
{
DesvioPadrao dp = new DesvioPadrao(Valores);
Media ma = new Media(Valores);
dp.Calcular();
ma.Calcular();
Passos.WriteLineAsyncCounter($"O {Titulo("Coeficiênte de Variação")} é igual ao quociente entre o desvio padrão e a média:");
Passos.WriteLineAsync($"$$ Dp = {dp.Resultado}$$");
Passos.WriteLineAsync($"$$ Ma = {ma.Resultado}$$");
var operacao = dp.Resultado / ma.Resultado;
Passos.WriteLineAsync($"$$ \\dfrac{{ {{{dp.Resultado}}} }} {{{ma.Resultado}}} = {operacao} $$ {HTMLElements.Hr()}");
Resultado = operacao;
return(0f);
}
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);
}
public override float Calcular()
{
Resultado = Valores.Average();
Passos.WriteLineAsyncCounter($"{Titulo("Média Aritimética")}: $$ \\sum {{ Xi }} \\over n $$");
Passos.WriteLineAsyncCounter($"Elementos:");
string ValoresCSV = String.Join(",", Valores);
string ValoresSoma = String.Join(" + ", Valores);
Passos.WriteLineAsyncCounter($"{ValoresCSV}");
Passos.WriteLineAsyncCounter("Some todos os termos: ");
Passos.WriteLineAsync($"$$ {ValoresSoma} $$");
Passos.WriteLineAsync($"$$ = {Valores.Sum().ToString()} $$");
Passos.WriteLineAsyncCounter($"Divida o resultado ({Valores.Sum()}) pelo numero de termos ({Valores.Count()}) ");
Passos.WriteLineAsync($"$$ Resultado = \\dfrac{{ {{{Valores.Sum()}}} }} {{{Valores.Count()}}} = {Resultado} $$");
return(Resultado);
}
private float CalcularFrequenciaSimples(float Abertura, float Fim)
{
float resultado = 0;
List <float> resultadosFS = new List <float>();
if (Fim >= ValorMaximo)
{
resultadosFS = Valores.Where(x => x >= Abertura && x <= Fim).ToList();
resultado = Valores.Where(x => x >= Abertura && x <= Fim).Count();
}
else
{
resultadosFS = Valores.Where(x => x >= Abertura && x < Fim).ToList();
resultado = Valores.Where(x => x >= Abertura && x < Fim).Count();
}
Passos.WriteLineAsyncCounter($"{Titulo("Freq. Simples")}: Contagem de valores entre {Abertura} e {Fim} : {resultado}");
Passos.WriteLineAsync($"{GerarTabelaDeFS(resultadosFS)}");
return(resultado);
}
public override float Calcular()
{
float Media = Valores.Average();
Passos.WriteLineAsyncCounter($"{Titulo("Variância")}: A variância mede quão dispersos estão os dados na amostra. = $$ \\sum_ {{Xi - Ma²}} \\over n $$");
Passos.WriteLineAsyncCounter($"Calcule a média (Ma) = {Media}");
Passos.WriteLineAsyncCounter($"Calcule o número de termos (N) = {Valores.Count} {HTMLElements.Hr()}");
int xi = 1;
foreach (var Elemento in Valores)
{
//Passos.WriteLineAsync($" $$ ( x{xi} - Ma ) ^2 $$");
var operacao = (Elemento - Media) * (Elemento - Media);
Resultado += operacao;
Passos.WriteLineAsync(" $$ (" + Elemento + " - " + Media.ToString("F2") + $")^ 2 = {operacao} ..." + Resultado + $" + $$ {HTMLElements.Hr()}");
xi++;
}
Passos.WriteLineAsync($"\n $$ Resultado: \\dfrac{{ {{{Resultado}}} }} {{{Valores.Count()}}} = {{{Resultado /= Valores.Count()}}} $$");
return(Resultado);
}
private Passo ValidarPassoAtual()
{
Passo passo = null;
if (Passos.Any())
{
foreach (var item in Passos)
{
if (item.Any())
{
foreach (var steps in item)
{
if (!steps.Aprovado)
{
passo = steps;
return(passo);
}
}
}
}
}
return(passo);
}
void FixedUpdate()
{
#region Movimentação Horizontal
if (Input.GetKey(KeyCode.A))
{
transform.Translate(Vector3.left * Velocidade * Time.deltaTime, Space.World);
Andando = true;
}
if (Input.GetKey(KeyCode.D))
{
transform.Translate(Vector3.right * Velocidade * Time.deltaTime, Space.World);
Andando = true;
}
if (Input.GetKey(KeyCode.S))
{
transform.Translate(Vector3.down * Velocidade * Time.deltaTime, Space.World);
Andando = true;
}
if (Input.GetKey(KeyCode.W))
{
transform.Translate(Vector3.up * Velocidade * Time.deltaTime, Space.World);
Andando = true;
}
if (Input.GetKey(KeyCode.W) && Input.GetKey(KeyCode.S) && Input.GetKey(KeyCode.D) && Input.GetKey(KeyCode.A))
{
Andando = false;
}
if (!(Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.A)))
{
Andando = false;
}
if (Andando)
{
if (!Callpassos)
{
Passos.Play();
Callpassos = true;
}
}
else
{
Passos.Stop();
Callpassos = false;
}
AnimPlayer.SetBool("Andando", Andando);
#endregion
#region Ativação Luz
if (Input.GetKeyDown(KeyCode.F) && couldownLuz <= 0)
{
InputadoLuz = true;
couldownLuz = couldownIncialLuz;
Acesa = !Acesa;
Lanterna.SetActive(Acesa);
ClickLanterna.Play();
}
if (Acesa)
{
if (barras <= 0)
{
InputadoLuz = true;
couldownLuz = couldownIncialLuz;
Acesa = !Acesa;
Lanterna.SetActive(Acesa);
}
else
{
if (TempoLuz <= 0)
{
barras--;
TempoLuz = DuraçãoLuz;
}
else
{
TempoLuz -= Time.deltaTime;
}
}
}
if (couldownLuz > 0)
{
couldownLuz -= Time.deltaTime;
}
#endregion
}
public void AdicionarPassos(Passo[] passos)
{
Passos.AddRange(passos);
}
private double RecalcularK()
{
Passos.WriteLineAsync($"{Titulo("Se o intervalo possuir casas decimais, considere $$ K = \\sqrt N $$ ")}");
return(CalcularQuantidadeIntervalosK(Valores.Count, HEraDecimal: true));
}
public void AdicionarPasso(List <Passo> passo)
{
Passos.Add(passo);
}
