Question

我之前发布了这个，用户告诉我将它发布在codereview上。我做了，他们关闭了......所以再一次在这里:(我删除了旧问题）

我有这些公式：

我需要erlangC公式的泊松公式：

我尝试在C：

中重建公式

double getPoisson(double m, double u, bool cumu)
{
    double ret = 0;
    if(!cumu)
    {
        ret = (exp(-u)*pow(u,m)) / (factorial(m));
    }
    else
    {
        double facto = 1;
        double ehu = exp(-u);
        for(int i = 0; i < m; i++)
        {
            ret = ret + (ehu * pow(u,i)) / facto;
            facto *= (i+1);
        }
     }
     return ret;
}

Erlang C公式：

double getErlangC(double m, double u, double p)
{
    double numerator = getPoisson(m, u, false);
    double denominator = getPoisson(m, u, false) + (1-p) * getPoisson(m, u, true);
    return numerator/denominator;
}

主要问题是，m中的getPoisson参数值很大（> 170）所以它想要计算> 170！但它无法处理它。我认为原始数据类型太小而无法正常工作，或者您说什么？

BTW：这是我用于第一个Poisson的阶乘函数：

double factorial(double n)
{
    if(n >= 1)
        return n*factorial(n-1);
    else
        return 1;
}

一些样本：

输入：

double l = getErlangC(50, 48, 0.96);
printf("%g", l);

输出：

0.694456 (correct)

输入：

double l = getErlangC(100, 96, 0.96);
printf("%g", l);

输出：

0.5872811 (correct)

如果我使用高于170的值作为getErlangC的第一个参数（m），如：

输入：

double l = getErlangC(500, 487, 0.974);
printf("%g", l);

输出：

naN (incorrect)

的例外：

0.45269

我的方法怎么样？有没有更好的方法来计算Poisson和erlangC？

一些信息：Excel具有POISSON功能，并且在Excel上它可以运行...有没有办法看到EXCEL用于POISSON的算法（代码）？

Answer 1

(pow(u, m)/factorial(m))可以表示为递归循环，每个元素显示为u / n，其中每个n都是m！的元素。

double ratio(double u, int n)
{
    if(n > 0)
     {
        // Avoid the ratio overflow by calculating each ratio element
        double val;
        val = u/n;
        return val*ratio(u, n-1);
      }
    else
      {
         // Avoid division by 0 as power and factorial of 0 are 1
        return 1;
      }
}

请注意，如果您想避免递归，您也可以将其作为循环

double ratio(double u, int n)
{
    int i;
    // Avoid the ratio overflow by calculating each ratio element
    // default the ratio to 1 for n == 0
    double val = 1;
    // calculate the next n-1 ratios and put them into the total
    for (i = 1; i<=n; i++)
      {
        // Put in the next element of the ratio 
        val *=  u/i;
      }
    // return the final value of the ratio
    return val;
}

Answer 2

要处理超出amOnPage范围的值，请重新编码以使用值的日志。下行 - 一些精确损失。

使用改进的代码可以重新获得精度，但这至少可以解决范围问题。

OP代码的轻微变体如下：用于比较。

double

建议的更改

long double factorial(unsigned m) {
  long double f = 1.0;
  while (m > 0) {
    f *= m;
    m--;
  }
  return f;
}

double getPoisson(unsigned m, double u, bool cumu) {
  double ret = 0;
  if (!cumu) {
    ret = (double) ((exp(-u) * pow(u, m)) / (factorial(m)));
  } else {
    double facto = 1;
    double ehu = exp(-u);
    for (unsigned i = 0; i < m; i++) {
      ret = ret + (ehu * pow(u, i)) / facto;
      facto *= (i + 1);
    }
  }
  return ret;
}

double getErlang(unsigned m, double u, double p) {
  double numerator = getPoisson(m, u, false);
  double denominator = numerator + (1.0 - p) * getPoisson(m, u, true);
  return numerator / denominator;
}

测试代码

#ifdef M_PI
  #define  MY_PI M_PI
#else
  #define  MY_PI 3.1415926535897932384626433832795
#endif

// log of n!
//
// Gosper Approximation of Stirling's Approximation
// http://mathworld.wolfram.com/StirlingsApproximation.html
// n! about= sqrt(pi*(2*n + 1/3.)) * pow(n,n)  * exp(-n)
static double ln_factorial(unsigned n) {
  if (n <= 1) return 0.0;
  double x = n;
  return log(sqrt(MY_PI * (2 * x + 1 / 3.0))) + log(x) * x - x;
}


double getPoisson_2(unsigned m, double u, bool cumu) {
  double ret = 0.0;
  if (cumu) {
    // Simplify term calculation.  `mul` does not get too large nor small.
    double mul = exp(-u);
    for (unsigned i = 0; i < m; i++) {
      ret += mul;
      mul *= u/(i + 1);
      // printf("ret:% 10e  mul:% 10e\n", ret, mul);
    }
  } else {
    // ret = (exp(-u) * pow(u, m)) / (factorial(m));
    double ln_ret = -u + log(u) * m - ln_factorial(m);
    return exp(ln_ret);
  }
  return ret;
}

double getErlang_2(unsigned m, double u, double p) {
  double numerator = getPoisson_2(m, u, false);
  double denominator = numerator + (1 - p) * getPoisson_2(m, u, true);
  return numerator / denominator;
}

Answer 3

您的大型递归factorial是一个问题，因为它可能会产生堆栈溢出以及值溢出。 pow也可能会变大。

这是一种以递增方式组合事物的方法：

double
getPoisson(double m, double u, bool cumu)
{
    double sum = 0;
    double facto = 1;
    double u_i = 1;
    double ehu = exp(-u);
    double cur = ehu;

    // u_i -- pow(u,i)
    // cur -- current/last term in series
    // sum -- sum of terms

    for (int i = 0; i < m; i++) {
        cur = (ehu * u_i) / facto;
        sum += cur;

        u_i *= u;
        facto *= (i + 1);
    }

    return cumu ? sum : cur;
}

上面的内容“还可以”，但由于u_i和facto条款，仍然可能会溢出某些值。

这是将术语组合为比率的替代方案。它不太可能溢出：

double
getPoisson(double m, double u, bool cumu)
{
    double sum = 0;
    double ehu = exp(-u);
    double cur = ehu;
    double ratio = 1;

    // cur -- current/last term in series
    // sum -- sum of terms
    // ratio -- u^i / factorial(i)

    for (int i = 0; i < m; i++) {
        cur = ehu * ratio;
        sum += cur;

        ratio *= u;
        ratio /= (i + 1);
    }

    return cumu ? sum : cur;
}

以上可能仍会产生一些大值。如果是这样，您可能必须使用long double，quadmath或多精度算术。或者，提出方程/算法的“模拟”。

泊松计算（erlang C）

3 个答案: