public void Test1() { var pc = new CDF(_samples); var percentile = pc.Calculate(999); Assert.Equal(0, percentile); }
private static void normal_truncated_b_cdf_test() //****************************************************************************80 // // Purpose: // // NORMAL_TRUNCATED_B_CDF_TEST tests NORMAL_TRUNCATED_B_CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 11 April 2016 // // Author: // // John Burkardt // { int i; const double b = 150.0; const double mu = 100.0; const double s = 25.0; int seed = 123456789; Console.WriteLine(""); Console.WriteLine("NORMAL_TRUNCATED_B_CDF_TEST"); Console.WriteLine(" NORMAL_TRUNCATED_B_CDF evaluates the Normal Truncated B CDF."); Console.WriteLine(" NORMAL_TRUNCATED_B_CDF_INV inverts the Normal Truncated B CDF."); Console.WriteLine(" NORMAL_TRUNCATED_B_PDF evaluates the Normal Truncated B PDF."); Console.WriteLine(""); Console.WriteLine(" The parent normal distribution has"); Console.WriteLine(" mean = " + mu + ""); Console.WriteLine(" standard deviation = " + s + ""); Console.WriteLine(" The parent distribution is truncated to"); Console.WriteLine(" the interval [-oo," + b + "]"); Console.WriteLine(""); Console.WriteLine(" X PDF CDF CDF_INV"); Console.WriteLine(""); for (i = 1; i <= 10; i++) { double x = Truncated.normal_truncated_b_sample(mu, s, b, ref seed); double pdf = Truncated.normal_truncated_b_pdf(x, mu, s, b); double cdf = CDF.normal_truncated_b_cdf(x, mu, s, b); double x2 = CDF.normal_truncated_b_cdf_inv(cdf, mu, s, b); Console.WriteLine(" " + x.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + pdf.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + cdf.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x2.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
public IActionResult OnGet() { if (!ModelState.IsValid) { return(Page()); } var samples = GetSamples(); var cdf = new CDF(samples); Percentile = cdf.Calculate(GetRandomVariable()); var cdfInv = new InverseCDF(samples); const double eps = .0001; for (var perc = 0.0; perc <= .95 + eps; perc += .05) { var inv = cdfInv.Calculate(perc); Percentiles.Add(inv); XAxis.Add(Convert.ToInt32(perc * 100)); } return(Page()); }
public void Test3() { var pc = new CDF(_samples); var percentile = pc.Calculate(1001); Assert.Equal(1, percentile); }
public static double log_normal_truncated_ab_mean(double mu, double sigma, double a, double b) //****************************************************************************80 // // Purpose: // // LOG_NORMAL_TRUNCATED_AB_MEAN: mean of the Log Normal truncated AB PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 March 2016 // // Author: // // John Burkardt // // Parameters: // // Input, double MU, SIGMA, the parameters of the PDF. // 0.0 < SIGMA. // // Input, double A, B, the lower and upper truncation limits. // A < B. // // Output, double LOG_NORMAL_TRUNCATED_AB_MEAN, the mean of the PDF. // { bool check = log_normal_truncated_ab_check(mu, sigma, a, b); switch (check) { case false: Console.WriteLine(""); Console.WriteLine("LOG_NORMAL_TRUNCATED_AB_MEAN - Fatal error!"); Console.WriteLine(" Parameters are not legal."); return(1); } double a0 = (Math.Log(a) - mu) / sigma; double b0 = (Math.Log(b) - mu) / sigma; double c1 = CDF.normal_01_cdf(sigma - a0); double c2 = CDF.normal_01_cdf(sigma - b0); double c3 = CDF.normal_01_cdf(+a0); double c4 = CDF.normal_01_cdf(+b0); double ln_mean = Math.Exp(mu + 0.5 * sigma * sigma); double mean = ln_mean * (c1 - c2) / (c4 - c3); return(mean); }
public static double log_normal_truncated_ab_sample(double mu, double sigma, double a, double b, ref int seed) //****************************************************************************80 // // Purpose: // // LOG_NORMAL_TRUNCATED_AB_SAMPLE samples the Log Normal truncated AB PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 March 2016 // // Author: // // John Burkardt // // Parameters: // // Input, double MU, SIGMA, the parameters of the PDF. // 0.0 < SIGMA. // // Input, double A, B, the lower and upper truncation limits. // A < B. // // Input/output, int &SEED, a seed for the random number generator. // // Output, double LOG_NORMAL_TRUNCATED_AB_SAMPLE, a sample of the PDF. // { bool check = log_normal_truncated_ab_check(mu, sigma, a, b); switch (check) { case false: Console.WriteLine(""); Console.WriteLine("LOG_NORMAL_TRUNCATED_AB_SAMPLE - Fatal error!"); Console.WriteLine(" Parameters are not legal."); return(1); } double lncdf_a = CDF.log_normal_cdf(a, mu, sigma); double lncdf_b = CDF.log_normal_cdf(b, mu, sigma); double cdf = UniformRNG.r8_uniform_ab(lncdf_a, lncdf_b, ref seed); double x = CDF.log_normal_cdf_inv(cdf, mu, sigma); return(x); }
public ActionResult TestCDF() { try { var fi = new FileInfo(@"E:\video\191006-20.D02"); var CDF = new CDF(fi); } catch (Exception ex) { } return(View("All")); }
public static void normal_01_cdf_inverse_test( ) //****************************************************************************80 // // Purpose: // // NORMAL_01_CDF_INVERSE_TEST tests NORMAL_01_CDF_INVERSE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 14 February 2015 // // Author: // // John Burkardt // { double fx = 0; int n_data = 0; double x = 0; double x2 = 0; Console.WriteLine(""); Console.WriteLine("NORMAL_01_CDF_INVERSE_TEST:"); Console.WriteLine(" NORMAL_01_CDF_INVERSE inverts the normal 01 CDF."); Console.WriteLine(""); Console.WriteLine(" FX X NORMAL_01_CDF_INVERSE(FX)"); Console.WriteLine(""); n_data = 0; for ( ; ;) { Burkardt.Values.Normal.normal_01_cdf_values(ref n_data, ref x, ref fx); if (n_data == 0) { break; } x2 = CDF.normal_01_cdf_inv(fx); Console.WriteLine(" " + fx.ToString(CultureInfo.InvariantCulture).PadLeft(8) + " " + x.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x2.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
public static double normal_truncated_a_pdf(double x, double mu, double sigma, double a) //****************************************************************************80 // // Purpose: // // TRUNCATED_NORMAL_A_PDF evaluates the lower truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 24 January 2017 // // Author: // // John Burkardt // // Parameters: // // Input, double X, the argument of the PDF. // // Input, double MU, SIGMA, the mean and standard deviation of the // parent Normal distribution. // // Input, double A, the lower truncation limit. // // Output, double TRUNCATED_NORMAL_A_PDF, the value of the PDF. // { double pdf; if (x < a) { pdf = 0.0; } else { double alpha = (a - mu) / sigma; double xi = (x - mu) / sigma; double alpha_cdf = CDF.normal_01_cdf(alpha); double xi_pdf = Normal.normal_01_pdf(xi); pdf = xi_pdf / (1.0 - alpha_cdf) / sigma; } return(pdf); }
public static double log_normal_cdf(double x, double a, double b) //****************************************************************************80 // // Purpose: // // LOG_NORMAL_CDF evaluates the Lognormal CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 19 September 2004 // // Author: // // John Burkardt // // Parameters: // // Input, double X, the argument of the PDF. // 0.0 < X. // // Input, double A, B, the parameters of the PDF. // 0.0 < B. // // Output, double CDF, the value of the CDF. // { double cdf; switch (x) { case <= 0.0: cdf = 0.0; break; default: { double logx = Math.Log(x); cdf = CDF.normal_cdf(logx, a, b); break; } } return(cdf); }
public static double normal_truncated_ab_sample(double mu, double s, double a, double b, ref int seed) //****************************************************************************80 // // Purpose: // // NORMAL_TRUNCATED_AB_SAMPLE samples the truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 14 August 2013 // // Author: // // John Burkardt // // Parameters: // // Input, double MU, S, the mean and standard deviation of the // parent Normal distribution. // // Input, double A, B, the lower and upper truncation limits. // // Input/output, int &SEED, a seed for the random number // generator. // // Output, double NORMAL_TRUNCATED_AB_SAMPLE, a sample of the PDF. // { double alpha = (a - mu) / s; double beta = (b - mu) / s; double alpha_cdf = CDF.normal_01_cdf(alpha); double beta_cdf = CDF.normal_01_cdf(beta); double u = UniformRNG.r8_uniform_01(ref seed); double xi_cdf = alpha_cdf + u * (beta_cdf - alpha_cdf); double xi = CDF.normal_01_cdf_inv(xi_cdf); double x = mu + s * xi; return(x); }
public static double half_normal_cdf_inv(double cdf, double a, double b) //****************************************************************************80 // // Purpose: // // HALF_NORMAL_CDF_INV inverts the Half Normal CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 17 October 2004 // // Author: // // John Burkardt // // Parameters: // // Input, double CDF, the value of the CDF. // 0.0 <= CDF <= 1.0. // // Input, double A, B, the parameters of the PDF. // 0.0 < B. // // Output, double HALF_NORMAL_CDF_INV, the corresponding argument. // { switch (cdf) { case < 0.0: case > 1.0: Console.WriteLine(" "); Console.WriteLine("HALF_NORMAL_CDF_INV - Fatal error!"); Console.WriteLine(" CDF < 0 or 1 < CDF."); return(1); } double cdf2 = 0.5 * (cdf + 1.0); double x = CDF.normal_cdf_inv(cdf2, a, b); return(x); }
public static double normal_truncated_ab_pdf(double x, double mu, double s, double a, double b) //****************************************************************************80 // // Purpose: // // NORMAL_TRUNCATED_AB_PDF evaluates the truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 14 August 2013 // // Author: // // John Burkardt // // Parameters: // // Input, double X, the argument of the PDF. // // Input, double MU, S, the mean and standard deviation of the // parent Normal distribution. // // Input, double A, B, the lower and upper truncation limits. // // Output, double NORMAL_TRUNCATED_AB_PDF, the value of the PDF. // { double alpha = (a - mu) / s; double beta = (b - mu) / s; double xi = (x - mu) / s; double alpha_cdf = CDF.normal_01_cdf(alpha); double beta_cdf = CDF.normal_01_cdf(beta); double xi_pdf = Normal.normal_01_pdf(xi); double pdf = xi_pdf / (beta_cdf - alpha_cdf) / s; return(pdf); }
public static double normal_truncated_ab_variance(double mu, double s, double a, double b) //****************************************************************************80 // // Purpose: // // NORMAL_TRUNCATED_AB_VARIANCE returns the variance of the truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 14 August 2013 // // Author: // // John Burkardt // // Parameters: // // Input, double MU, S, the mean and standard deviation of the // parent Normal distribution. // // Input, double A, B, the lower and upper truncation limits. // // Output, double NORMAL_TRUNCATED_AB_VARIANCE, the variance of the PDF. // { double alpha = (a - mu) / s; double beta = (b - mu) / s; double alpha_pdf = Normal.normal_01_pdf(alpha); double beta_pdf = Normal.normal_01_pdf(beta); double alpha_cdf = CDF.normal_01_cdf(alpha); double beta_cdf = CDF.normal_01_cdf(beta); double variance = s * s * (1.0 + (alpha * alpha_pdf - beta * beta_pdf) / (beta_cdf - alpha_cdf) - Math.Pow((alpha_pdf - beta_pdf) / (beta_cdf - alpha_cdf), 2)); return(variance); }
public static double half_normal_cdf(double x, double a, double b) //****************************************************************************80 // // Purpose: // // HALF_NORMAL_CDF evaluates the Half Normal CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 17 October 2004 // // Author: // // John Burkardt // // Parameters: // // Input, double X, the argument of the CDF. // // Input, double A, B, the parameters of the PDF. // 0.0 < B. // // Output, double HALF_NORMAL_CDF, the value of the CDF. // { double cdf; if (x <= a) { cdf = 0.0; } else { double cdf2 = CDF.normal_cdf(x, a, b); cdf = 2.0 * cdf2 - 1.0; } return(cdf); }
public static double normal_truncated_b_mean(double mu, double s, double b) //****************************************************************************80 // // Purpose: // // NORMAL_TRUNCATED_B_MEAN returns the mean of the upper truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 21 August 2013 // // Author: // // John Burkardt // // Parameters: // // Input, double MU, S, the mean and standard deviatione of the // parent Normal distribution. // // Input, double B, the upper truncation limit. // // Output, double NORMAL_TRUNCATED_B_MEAN, the mean of the PDF. // { double beta = (b - mu) / s; double beta_cdf = CDF.normal_01_cdf(beta); double beta_pdf = Normal.normal_01_pdf(beta); double mean = mu - s * beta_pdf / beta_cdf; return(mean); }
public static double log_normal_sample(double mu, double sigma, ref int seed) //****************************************************************************80 // // Purpose: // // LOG_NORMAL_SAMPLE samples the Log Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 19 September 2004 // // Author: // // John Burkardt // // Parameters: // // Input, double MU, SIGMA, the parameters of the PDF. // 0.0 < SIGMA. // // Input/output, int &SEED, a seed for the random number generator. // // Output, double LOG_NORMAL_SAMPLE, a sample of the PDF. // { double cdf = UniformRNG.r8_uniform_01(ref seed); double x = CDF.log_normal_cdf_inv(cdf, mu, sigma); return(x); }
public static double normal_truncated_ab_moment(int order, double mu, double sigma, double a, double b) //****************************************************************************80 // // Purpose: // // TRUNCATED_NORMAL_AB_MOMENT: moments of the truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 11 September 2013 // // Author: // // John Burkardt // // Reference: // // Phoebus Dhrymes, // Moments of Truncated Normal Distributions, // May 2005. // // Parameters: // // Input, int ORDER, the order of the moment. // 0 <= ORDER. // // Input, double MU, SIGMA, the mean and standard deviation of the // parent Normal distribution. // 0.0 < S. // // Input, double A, B, the lower and upper truncation limits. // A < B. // // Output, double TRUNCATED_NORMAL_AB_MOMENT, the moment of the PDF. // { int r; switch (order) { case < 0: Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_AB_MOMENT - Fatal error!"); Console.WriteLine(" ORDER < 0."); return(1); } switch (sigma) { case <= 0.0: Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_AB_MOMENT - Fatal error!"); Console.WriteLine(" SIGMA <= 0.0."); return(1); } if (b <= a) { Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_AB_MOMENT - Fatal error!"); Console.WriteLine(" B <= A."); return(1); } double a_h = (a - mu) / sigma; double a_pdf = Normal.normal_01_pdf(a_h); double a_cdf = CDF.normal_01_cdf(a_h); switch (a_cdf) { case 0.0: Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_AB_MOMENT - Fatal error!"); Console.WriteLine(" PDF/CDF ratio fails, because A_CDF too small."); Console.WriteLine(" A_PDF = " + a_pdf + ""); Console.WriteLine(" A_CDF = " + a_cdf + ""); return(1); } double b_h = (b - mu) / sigma; double b_pdf = Normal.normal_01_pdf(b_h); double b_cdf = CDF.normal_01_cdf(b_h); switch (b_cdf) { case 0.0: Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_AB_MOMENT - Fatal error!"); Console.WriteLine(" PDF/CDF ratio fails, because B_CDF too small."); Console.WriteLine(" B_PDF = " + b_pdf + ""); Console.WriteLine(" B_CDF = " + b_cdf + ""); return(1); } double moment = 0.0; double irm2 = 0.0; double irm1 = 0.0; for (r = 0; r <= order; r++) { double ir = r switch { 0 => 1.0, 1 => - (b_pdf - a_pdf) / (b_cdf - a_cdf), _ => (r - 1) * irm2 - (Math.Pow(b_h, r - 1) * b_pdf - Math.Pow(a_h, r - 1) * a_pdf) / (b_cdf - a_cdf) }; moment += typeMethods.r8_choose(order, r) * Math.Pow(mu, order - r) * Math.Pow(sigma, r) * ir; irm2 = irm1; irm1 = ir; } return(moment); }
private static void log_normal_truncated_ab_cdf_test() //****************************************************************************80 // // Purpose: // // LOG_NORMAL_TRUNCATED_AB_CDF_TEST tests LOG_NORMAL_TRUNCATED_AB_CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 March 2016 // // Author: // // John Burkardt // { int i; int seed = 123456789; Console.WriteLine(""); Console.WriteLine("LOG_NORMAL_TRUNCATED_AB_CDF_TEST"); Console.WriteLine(" LOG_NORMAL_TRUNCATED_AB_CDF evaluates the Log Normal Truncated AB CDF;"); Console.WriteLine(" LOG_NORMAL_TRUNCATED_AB_CDF_INV inverts the Log Normal Truncated AB CDF."); Console.WriteLine(" LOG_NORMAL_TRUNCATED_AB_PDF evaluates the Log Normal Truncated AB PDF;"); double mu = 0.5; double sigma = 3.0; double a = Math.Exp(mu); double b = Math.Exp(mu + 2.0 * sigma); Console.WriteLine(""); Console.WriteLine(" PDF parameter MU = " + mu + ""); Console.WriteLine(" PDF parameter SIGMA = " + sigma + ""); Console.WriteLine(" PDF parameter A = " + a + ""); Console.WriteLine(" PDF parameter B = " + b + ""); if (!PDF.log_normal_truncated_ab_check(mu, sigma, a, b)) { Console.WriteLine(""); Console.WriteLine("LOG_NORMAL_TRUNCATED_AB_CDF_TEST - Fatal error!"); Console.WriteLine(" The parameters are not legal."); return; } Console.WriteLine(""); Console.WriteLine(" X PDF CDF CDF_INV"); Console.WriteLine(""); for (i = 1; i <= 10; i++) { double x = PDF.log_normal_truncated_ab_sample(mu, sigma, a, b, ref seed); double pdf = PDF.log_normal_truncated_ab_pdf(x, mu, sigma, a, b); double cdf = CDF.log_normal_truncated_ab_cdf(x, mu, sigma, a, b); double x2 = CDF.log_normal_truncated_ab_cdf_inv(cdf, mu, sigma, a, b); Console.WriteLine(" " + x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + pdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + cdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + x2.ToString(CultureInfo.InvariantCulture).PadLeft(12) + ""); } }
private XmlElement ConvertToXML() { XmlDocument doc = new System.Xml.XmlDocument(); return(CDF.ToXml(doc)); }
public static double normal_truncated_b_moment(int order, double mu, double sigma, double b) //****************************************************************************80 // // Purpose: // // TRUNCATED_NORMAL_B_MOMENT: moments of the upper truncated Normal PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 11 September 2013 // // Author: // // John Burkardt // // Reference: // // Phoebus Dhrymes, // Moments of Truncated Normal Distributions, // May 2005. // // Parameters: // // Input, int ORDER, the order of the moment. // 0 <= ORDER. // // Input, double MU, SIGMA, the mean and standard deviation of the // parent Normal distribution. // // Input, double B, the upper truncation limit. // // Output, double TRUNCATED_NORMAL_B_MOMENT, the moment of the PDF. // { int r; switch (order) { case < 0: Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_B_MOMENT - Fatal error!"); Console.WriteLine(" ORDER < 0."); return(1); } double h = (b - mu) / sigma; double h_pdf = Normal.normal_01_pdf(h); double h_cdf = CDF.normal_01_cdf(h); switch (h_cdf) { case 0.0: Console.WriteLine(""); Console.WriteLine("TRUNCATED_NORMAL_B_MOMENT - Fatal error!"); Console.WriteLine(" CDF((B-MU)/SIGMA) = 0."); return(1); } double f = h_pdf / h_cdf; double moment = 0.0; double irm2 = 0.0; double irm1 = 0.0; for (r = 0; r <= order; r++) { double ir = r switch { 0 => 1.0, 1 => - f, _ => - Math.Pow(h, r - 1) * f + (r - 1) * irm2 }; moment += typeMethods.r8_choose(order, r) * Math.Pow(mu, order - r) * Math.Pow(sigma, r) * ir; irm2 = irm1; irm1 = ir; } return(moment); }
private static void normal_cdf_test() //****************************************************************************80 // // Purpose: // // NORMAL_CDF_TEST tests NORMAL_CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 February 2007 // // Author: // // John Burkardt // { int i; int seed = 123456789; Console.WriteLine(""); Console.WriteLine("NORMAL_CDF_TEST"); Console.WriteLine(" NORMAL_CDF evaluates the Normal CDF;"); Console.WriteLine(" NORMAL_CDF_INV inverts the Normal CDF."); Console.WriteLine(" NORMAL_PDF evaluates the Normal PDF;"); const double mu = 100.0; const double sigma = 15.0; Console.WriteLine(""); Console.WriteLine(" PDF parameter MU = " + mu + ""); Console.WriteLine(" PDF parameter SIGMA = " + sigma + ""); if (!Normal.normal_check(mu, sigma)) { Console.WriteLine(""); Console.WriteLine("NORMAL_CDF_TEST - Fatal error!"); Console.WriteLine(" The parameters are not legal."); return; } Console.WriteLine(""); Console.WriteLine(" X PDF CDF CDF_INV"); Console.WriteLine(""); for (i = 1; i <= 10; i++) { double x = Normal.normal_sample(mu, sigma, ref seed); double pdf = Normal.normal_pdf(x, mu, sigma); double cdf = CDF.normal_cdf(x, mu, sigma); double x2 = CDF.normal_cdf_inv(cdf, mu, sigma); Console.WriteLine(" " + x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + pdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + cdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + x2.ToString(CultureInfo.InvariantCulture).PadLeft(12) + ""); } }
public static double log_normal_truncated_ab_pdf(double x, double mu, double sigma, double a, double b) //****************************************************************************80 // // Purpose: // // LOG_NORMAL_TRUNCATED_AB_PDF evaluates the Log Normal truncated AB PDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 March 2016 // // Author: // // John Burkardt // // Parameters: // // Input, double X, the argument of the PDF. // 0.0 < X // // Input, double MU, SIGMA, the parameters of the PDF. // 0.0 < SIGMA. // // Input, double A, B, the lower and upper truncation limits. // A < B. // // Output, double LOG_NORMAL_TRUNCATED_AB_PDF, the value of the PDF. // { double pdf; bool check = log_normal_truncated_ab_check(mu, sigma, a, b); switch (check) { case false: Console.WriteLine(""); Console.WriteLine("LOG_NORMAL_TRUNCATED_AB_PDF - Fatal error!"); Console.WriteLine(" Parameters are not legal."); return(1); } if (x <= a) { pdf = 0.0; } else if (b <= x) { pdf = 0.0; } else { double lncdf_a = CDF.log_normal_cdf(a, mu, sigma); double lncdf_b = CDF.log_normal_cdf(b, mu, sigma); double lnpdf_x = log_normal_pdf(x, mu, sigma); pdf = lnpdf_x / (lncdf_b - lncdf_a); } return(pdf); }