/// <summary>
/// Probability density function
/// </summary>
public double Pdf(double x)
{
if (x < 0 || x > 1)
{
return(0);
}
if (x < 1e-9)
{
if (Alpha > 1)
{
return(0);
}
if (Abs(Alpha - 1) < 1e-9)
{
return(Beta);
}
return(double.PositiveInfinity);
}
if (x > 1 - 1e-9)
{
if (Beta > 1)
{
return(0);
}
if (Abs(Beta - 1) < 1e-9)
{
return(Alpha);
}
return(double.PositiveInfinity);
}
return(Exp((Alpha - 1) * Log(x) + (Beta - 1) * Log(1 - x) - BetaFunction.CompleteLogValue(Alpha, Beta)));
}
public void When_Compute_Beta_Function()
{
var betaFunction = new BetaFunction();
var result = betaFunction.Evaluate(1.5, 0.2);
Assert.True(4.47 < result);
}
public double Quantile(Probability p)
{
double x = BetaFunction.RegularizedIncompleteInverseValue(0.5 * df, 0.5, 2 * Min(p, 1 - p));
x = Sqrt(df * (1 - x) / x);
return(p >= 0.5 ? x : -x);
}
public IActionResult ComputeBetaFunction([FromBody] GetBetaFunctionRequest request)
{
var beta = new BetaFunction();
var result = beta.Evaluate(request.A, request.B);
return(new OkObjectResult(new FunctionResponse {
Value = result
}));
}
public double Cdf(int k)
{
if (k < 0)
{
return(0);
}
if (k > N)
{
return(1);
}
return(BetaFunction.RegularizedIncompleteValue(N - k, 1 + k, 1 - P));
}
public void BetaCompleteLogValue()
{
var comparer = new AbsoluteEqualityComparer(0.0000001);
for (int a = 1; a <= 20; a++)
{
for (int b = 1; b <= 20; b++)
{
double actual = BetaFunction.CompleteLogValue(a, b);
double expected = Math.Log(Factorial(a - 1) * Factorial(b - 1) / Factorial(a + b - 1));
Assert.Equal(expected, actual, comparer);
}
}
}
public double ComputeLowerCumulative(double tStat, double degreeOfFreedom)
{
VariableEntity x = _variableName;
VariableEntity v = _degreeOfFreedomName;
var betaFunction = new BetaFunction();
var betaResult = betaFunction.Evaluate(0.5, degreeOfFreedom / 2);
var firstEntity = MathEntity.Pow(Number.Create(1) + (MathEntity.Pow(x, Number.Create(2)) / v), Number.Create(-1) * ((v + Number.Create(1)) / Number.Create(2)));
var secondEntity = MathEntity.Sqrt(v) * Number.Create(betaResult);
var result = (firstEntity / secondEntity);
result.Assign(v, (NumberEntity)Number.Create(degreeOfFreedom));
var simpsonEstimate = new SimpsonEstimate();
return(simpsonEstimate.Estimate(result, x, _n, _a, tStat));
}
public double Quantile(Probability p) => BetaFunction.RegularizedIncompleteInverseValue(Alpha, Beta, p);
/// <summary> /// Cumulative distribution function /// </summary> public double Cdf(double x) => BetaFunction.RegularizedIncompleteValue(Alpha, Beta, x);
public double Cdf(double x)
{
double p = 0.5 * BetaFunction.RegularizedIncompleteValue(0.5 * df, 0.5, df / (df + x.Sqr()));
return(x > 0 ? 1 - p : p);
}
