zinb_par_t *
mle_nb
(
int *x,
unsigned int nobs
)
{
tab_t *tab = tabulate(x, nobs);
double a = nb_est_alpha(tab);
// Return NULL if failed.
if (a < 0) return NULL;
// Allocate return struct.
zinb_par_t *par = calloc(1, sizeof(zinb_par_t));
if (par == NULL) {
fprintf(stderr, "memory error: %s:%d\n", __FILE__, __LINE__);
return NULL;
}
double sum = 0.0;
unsigned int nona = 0;
for (size_t i = 0 ; i < tab->size ; i++) {
nona += tab->num[i];
sum += tab->val[i]*tab->num[i];
}
free(tab);
par->a = a;
par->p = a / (a + (sum/nona));
return par;
}
void
test_nb_est_alpha
(void)
{
tab_t *tab;
// 0:14, 1:5, 2:4, 3:1, 5:1
int x1[25] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,2,2,2,2,3,5 };
tab = tabulate(x1, 25);
test_assert_critical(tab != NULL);
test_assert(fabs(nb_est_alpha(tab)-0.9237) < 1e-3);
free(tab);
// 0:27, 1:12, 2:8, 3:1, 4:1, 5:1
int x2[50] = {3,0,1,2,0,0,1,0,0,0,0,1,1,0,0,1,2,2,0,0,0,1,2,
0, 0,0,0,0,4,0,0,0,1,5,1,0,1,2,1,2,2,2,0,0,0,1,0,1,0,0};
tab = tabulate(x2, 50);
test_assert_critical(tab != NULL);
test_assert(fabs(nb_est_alpha(tab)-1.3436) < 1e-3);
free(tab);
// 0:12, 1:7, 2:13, 3:4, 4:6, 5:2, 6:1, 7:3, 8:1, 9:1
int x3[50] = {4,5,2,1,2,4,2,2,0,4,2,1,3,6,0,0,7,3,0,8,4,2,0,
0,2,3,2,3,7,9,2,4,0,4,2,0,0,2,5,1,1,2,1,0,0,0,1,2,1,7};
tab = tabulate(x3, 50);
test_assert_critical(tab != NULL);
test_assert(fabs(nb_est_alpha(tab)-1.7969) < 1e-3);
free(tab);
// 0:39, 1:8, 2:2, 3:1
int x4[50] = {1,0,0,0,0,0,3,1,0,1,0,0,0,0,0,0,0,1,0,0,0,2,0,
2,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0};
tab = tabulate(x4, 50);
test_assert_critical(tab != NULL);
test_assert(fabs(nb_est_alpha(tab)-0.7073) < 1e-3);
free(tab);
// 0:59, 1:83, 2:99, 3:67, 4:67, 5:49, 6:27, 7:22, 8:11, 9:6
// 10:6, 11:3, 12:2, 13:3
int x5[500] = {1,0,0,1,1,2,1,0,5,7,1,3,3,1,6,0,2,5,7,0,5,2,1,
10,5,3,4,5,7,0,8,6,3,0,2,1,1,0,2,3,7,2,3,2,2,1,0,4,4,2,4,2,
0,6,3,2,5,2,1,4,3,4,2,2,5,3,2,0,2,8,1,3,1,7,5,1,4,1,1,0,2,
2,4,1,1,1,4,1,3,4,4,10,5,2,0,7,1,6,1,3,6,4,0,2,4,1,12,2,5,
6,5,4,1,11,0,1,3,2,4,2,0,2,3,4,0,2,9,9,7,4,2,1,3,3,3,4,2,9,
2,4,3,2,2,4,2,5,3,0,1,3,2,0,3,3,4,1,3,3,5,7,3,3,2,1,5,5,4,
6,1,1,1,2,9,5,1,2,4,0,2,1,0,3,2,4,3,1,4,2,1,4,1,6,0,6,5,3,
5,2,0,1,2,1,0,5,3,2,7,6,4,3,2,5,7,5,5,1,1,3,10,2,0,5,0,1,2,
0,5,1,2,3,6,4,0,3,1,2,2,4,3,0,3,2,5,4,10,1,2,4,4,2,13,4,3,
1,5,4,8,5,6,2,3,4,3,1,5,5,1,8,2,0,5,7,3,2,2,4,2,3,1,5,3,7,
13,1,4,7,5,5,0,3,0,4,2,3,1,2,4,2,8,1,2,5,6,1,1,0,7,2,2,3,5,
12,2,2,2,0,3,3,4,0,2,5,1,10,0,7,6,5,0,11,2,3,7,3,5,4,2,1,2,
4,0,2,2,2,0,6,2,3,4,2,3,7,3,5,2,5,0,4,4,6,3,1,2,7,3,0,2,5,
7,2,2,0,0,0,6,3,0,1,1,5,5,2,6,2,4,6,0,1,2,3,2,2,2,3,4,1,1,
4,0,2,0,1,3,4,1,2,2,3,1,4,4,3,4,4,1,5,2,13,4,10,5,6,1,0,5,
0,0,5,6,0,1,8,5,1,3,1,8,1,8,1,6,7,2,8,2,2,3,3,0,4,2,1,9,6,
0,6,7,1,8,2,2,1,11,3,0,4,2,5,1,6,8,3,4,7,0,4,2,4,1,1,1,6,0,
4,4,6,2,1,3,1,0,4,9,3,1,4,2,2,0,1};
tab = tabulate(x5, 500);
test_assert_critical(tab != NULL);
test_assert(fabs(nb_est_alpha(tab)-3.0057) < 1e-3);
free(tab);
}
zinb_par_t *
mle_zinb
(
int *x,
unsigned int nobs
)
{
tab_t *tab = tabulate(x, nobs);
double sum = 0.0;
unsigned int nona = 0;
for (size_t i = 0 ; i < tab->size ; i++) {
sum += tab->val[i]*tab->num[i];
nona += tab->num[i];
}
// Extract the number of all-zero observaions.
const unsigned int z0 = tab->val[0] == 0 ? tab->num[0] : 0;
double deficit[11] = {0,.1,.2,.3,.4,.5,.6,.7,.8,.9,1};
double init_a[12] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1};
double init_p[12] = {0,0,0,0,0,0,0,0,0,0,0,.5};
// Deplete some 0s from the observations, compute alpha
// and p0 with standard negative binomial estimation
// and keep the values to be used as initial conditions.
for (size_t i = 0 ; i < 11 ; i++) {
if (tab->val[0] == 0) tab->num[0] = z0 * (1-deficit[i]);
double newmean = sum / nona / (1.0 - z0*deficit[i]/nobs);
double alpha = nb_est_alpha(tab);
init_a[i] = alpha;
init_p[i] = alpha / (alpha + newmean);
}
// Reset 'tab'.
if (tab->val[0] == 0) tab->num[0] = z0;
zinb_par_t *par = calloc(1, sizeof(zinb_par_t));
if (par == NULL) {
fprintf(stderr, "memory error: %s:%d\n", __FILE__, __LINE__);
return NULL;
}
// Try initial conditions. Number 12 is a safety in case
// all the rest failed during the first phase.
double max_loglik = -1.0/0.0;
for (size_t i = 0 ; i < 12 ; i++) {
if (init_a[i] < 0) continue; // Skip failures.
double a = init_a[i];
double p = init_p[i];
double grad;
unsigned int iter = 0;
double f = eval_zinb_f(a, p, nobs-z0, sum);
double g = eval_zinb_g(a, p, tab);
// Newton-Raphson iterations.
while ((grad = f*f+g*g) > sq(ZINM_TOL) && iter++ < ZINM_MAXITER) {
double dfda, dfdp, dgda, dgdp;
dfda = dgdp = eval_zinb_dfda(a, p, nobs-z0);
dfdp = eval_zinb_dfdp(a, p, nobs-z0, sum);
dgda = eval_zinb_dgda(a, p, tab);
double denom = dfdp*dgda - dfda*dgdp;
double da = (f*dgdp - g*dfdp) / denom;
double dp = (g*dfda - f*dgda) / denom;
// Maintain 'a' and 'p' in their domain of definition.
while (a+da < 0 || p+dp < 0 || p+dp > 1) {
da /= 2;
dp /= 2;
}
f = eval_zinb_f(a+da, p+dp, nobs-z0, sum);
g = eval_zinb_g(a+da, p+dp, tab);
// Backtrack if necessary.
for (int j = 0 ; j < ZINM_MAXITER && f*f+g*g > grad ; j++) {
da /= 2;
dp /= 2;
f = eval_zinb_f(a+da, p+dp, nobs-z0, sum);
g = eval_zinb_g(a+da, p+dp, tab);
}
a = a+da;
p = p+dp;
}
double pi = (nobs-z0) / (1-pow(p,a)) / nobs;
if (pi > 1) pi = 1.0;
if (pi < 0) pi = 0.0;
double loglik = ll_zinb(a, p, pi, tab);
if (loglik > max_loglik) {
max_loglik = loglik;
par->a = a;
par->pi = pi;
par->p = p;
}
}
free(tab);
return par;
}
