public List <Tuple <int, decimal, DistribuicaoBinomialCalculoEntity> > CalculoK(DistribuicaoBinomialEntity entidade)
{
var listaCalculosK = new List <Tuple <int, decimal, DistribuicaoBinomialCalculoEntity> >();
foreach (var K in entidade.K)
{
/* N[fatorial] - K[fatorial] * (N - K [Fatorial]) */
var calculobase = MathCoreApp.Fatorial(entidade.N) / (MathCoreApp.Fatorial(K) * MathCoreApp.Fatorial(entidade.N - K));
var calculoA = Math.Pow((double)entidade.P, K);
var calculoB = Math.Pow((double)entidade.Q, (double)(entidade.N - K));
var calculoFinal = (decimal)(calculobase * calculoA * calculoB) * 100;
var calculo = new DistribuicaoBinomialCalculoEntity()
{
A = $"{entidade.N}",
B = $"{K}",
C = $"{entidade.N - K}",
D = $"{(double)entidade.P}",
E = $"{(double)entidade.Q}",
};
listaCalculosK.Add(new Tuple <int, decimal, DistribuicaoBinomialCalculoEntity>((int)K, Math.Round(calculoFinal, 2), calculo));
}
return(listaCalculosK);
}
public MedidasTendenciaEntity Calcular(List <decimal> inputData)
{
return(new MedidasTendenciaEntity
{
Media = MathCoreApp.MediaComum(inputData),
Mediana = MathCoreApp.Mediana(inputData),
Moda = MathCoreApp.Moda(inputData)
});
}
public DistribuicaoUniformeEntity Build(DistribuicaoUniformeEntity entidade)
{
entidade.Media = (entidade.B + entidade.A) / 2;
entidade.DesvioPadrao = Math.Round((decimal)Math.Sqrt(Math.Pow((double)(entidade.B - entidade.A), 2) / 12), 2);
entidade.Variancia = Math.Round(MathCoreApp.Quadrado(entidade.DesvioPadrao), 2);
if (entidade.TipoEntrada != -1)
{
entidade.X = CalcularX(entidade);
entidade.Probabilidade = (decimal)(((decimal)entidade.X / (entidade.B - entidade.A))) * 100;
}
return(entidade);
}
public MedidasDispersaoEntity Calcular(List <decimal> listaXifi, decimal media, bool amostra)
{
var variancia = Variancia(listaXifi, media, listaXifi.Count, amostra);
var DP = MathCoreApp.RaizQuadrada(variancia);
var CV = MathCoreApp.Porcentagem(DP, media);
return(new MedidasDispersaoEntity
{
CV = CV,
Variancia = variancia,
DP = DP,
});
}
public static decimal VarianciaContinua(List <decimal> listaXi, List <decimal> listaFi, decimal media, decimal N, bool amostra)
{
if (amostra)
{
N = N - 1;
}
var listaNova = new List <decimal>();
for (var i = 0; i < listaXi.Count; i++)
{
var conta = MathCoreApp.Quadrado(Math.Round(listaXi[i] - media, 2)) * listaFi[i];
listaNova.Add(conta);
}
var soma = listaNova.Sum();
return(Math.Round((decimal)(soma / (N)), 2));
}
public MedidasDispersaoContainerEntity Build(BaseInputsEntity baseInputs)
{
var media = MathCoreApp.MediaComum(baseInputs.InputValue);
var inputValueQuadrado = MathCoreApp.SomaTodosAoQuadrado(baseInputs.InputValue, media);
var medidasDispersao = Calcular(baseInputs.InputValue, media, baseInputs.Amostra);
return(new MedidasDispersaoContainerEntity()
{
Media = media,
Rol = baseInputs.Rol,
InputValue = baseInputs.InputValue,
InputValueQuadrado = inputValueQuadrado,
SomaInputValueQuadrado = inputValueQuadrado.Sum(),
MedidasDispersaoEntity = medidasDispersao
});
}
/// <summary>
/// Comum
/// </summary>
/// <param name="media"></param>
/// <param name="N"></param>
/// <returns></returns>
public static decimal Variancia(List <decimal> listaXI, decimal media, int N, bool amostra)
{
if (amostra)
{
N = N - 1;
}
var listaNova = new List <decimal>();
foreach (var item in listaXI)
{
listaNova.Add(MathCoreApp.Quadrado(Math.Round(item - media, 2)));
}
var soma = listaNova.Sum();
return(Math.Round((decimal)(soma / (N)), 2));
}
public VariavelContinuaContainerEntity Build(BaseInputsEntity baseInputs)
{
var xMAx = baseInputs.InputValue.Max();
var xMin = baseInputs.InputValue.Min();
var al = (xMAx - xMin) + 1;
var numeroPreK = (int)Math.Sqrt(baseInputs.InputValue.Count());
var K = new List <decimal> {
numeroPreK - 1, numeroPreK, numeroPreK + 1
};
var Ic = GetIC(al, K);
var minimo = xMin;
var maximo = minimo + (int)Ic.IC;
var f = new List <int>();
var fePorcentList = new List <decimal>();
var listaTabelaQuantitativa = new List <VariavelContinuaEntity>();
for (int i = 1; i <= Ic.Classes; i++)
{
var fePorcent = (decimal)(baseInputs.Rol.Count(x => x >= minimo && x < maximo) / (decimal)baseInputs.Rol.Count()) * 100;
var count = baseInputs.Rol.Count(x => x >= minimo && x < maximo);
f.Add(count);
fePorcentList.Add(fePorcent);
var xi = MediaComum(new List <decimal>()
{
minimo, maximo
});
listaTabelaQuantitativa.Add(new VariavelContinuaEntity
{
Classe = i,
XI = xi,
Range = new[] { minimo, maximo },
FI = count,
FEPorcent = Math.Round(fePorcent, 2),
F = f.Sum(),
FPorcent = Math.Round(fePorcentList.Sum(), 2),
XIFI = xi * count,
});
minimo = maximo;
maximo = maximo + (int)Ic.IC;
}
var media = listaTabelaQuantitativa.Sum(e => e.XIFI) / listaTabelaQuantitativa.Sum(e => e.FI);
var variancia = VarianciaContinua(listaTabelaQuantitativa.Select(q => q.XI).ToList(), listaTabelaQuantitativa.Select(x => x.FI).ToList(), media, listaTabelaQuantitativa.Sum(y => y.FI), baseInputs.Amostra);
var dp = MathCoreApp.RaizQuadrada(variancia);
var cv = MathCoreApp.Porcentagem(dp, media);
var medidasDispersao = new MedidasDispersaoEntity
{
Variancia = variancia,
DP = dp,
CV = cv
};
var medidasTendencia = new MedidasTendenciaEntity
{
Media = media,
Mediana = MedianaQuantitativa(listaTabelaQuantitativa, Ic.IC),
Moda = ModaQuantitativa(listaTabelaQuantitativa)
};
return(new VariavelContinuaContainerEntity
{
InputValue = baseInputs.InputValue,
Rol = baseInputs.Rol,
VariavelContinuaEntity = listaTabelaQuantitativa,
MinLinha = xMin,
MaxLinha = xMAx,
AL = al,
K = K,
IC = Ic,
MedidasDispersaoEntity = medidasDispersao,
MedidasTendenciaEntity = medidasTendencia,
EXIFI = listaTabelaQuantitativa.Sum(entity => entity.XIFI),
EFI = listaTabelaQuantitativa.Sum(entity => entity.FI),
});
}