void betabinom(){
apop_model *beta = apop_model_set_parameters(apop_beta, 10, 5);
apop_model *drawfrom = apop_model_copy(apop_multinomial);
drawfrom->parameters = apop_data_falloc((2), 30, .4);
drawfrom->dsize = 2;
int draw_ct = 80;
apop_data *draws = apop_model_draws(drawfrom, draw_ct);
apop_model *betaup = apop_update(draws, beta, apop_binomial);
apop_model_show(betaup);
beta->more = apop_beta;
beta->log_likelihood = fake_ll;
apop_model *bi = apop_model_fix_params(apop_model_set_parameters(apop_binomial, 30, NAN));
apop_model *upd = apop_update(draws, beta, bi);
apop_model *betaed = apop_estimate(upd->data, apop_beta);
deciles(betaed, betaup, 1);
beta->log_likelihood = NULL;
apop_model *upd_r = apop_update(draws, beta, bi);
betaed = apop_estimate(apop_data_pmf_expand(upd_r->data, 2000), apop_beta);
deciles(betaed, betaup, 1);
apop_data *d2 = apop_model_draws(upd, draw_ct*2);
apop_model *d2m = apop_estimate(d2, apop_beta);
deciles(d2m, betaup, 1);
}
void gammaexpo(){
printf("gamma/exponential\n");
apop_model *gamma = apop_model_set_parameters(apop_gamma, 1, 0.4);
apop_model *drawfrom = apop_model_set_parameters(apop_exponential, 0.4);
int draw_ct = 120;
apop_data *draws = apop_model_draws(drawfrom, draw_ct);
apop_model *gammaup = apop_update(draws, gamma, apop_exponential);
apop_model_show(gammaup);
gamma->more = apop_gamma;
gamma->log_likelihood = fake_ll;
Apop_settings_add_group(gamma, apop_mcmc, .burnin=.1, .periods=1e5,
.proposal=apop_model_set_parameters(apop_normal, 1, .001));
apop_model *upd = apop_update(draws, gamma, apop_exponential);
apop_model *gammaed = apop_estimate(upd->data, apop_gamma);
apop_model_show(gammaed);
deciles(gammaed, gammaup, 3);
Apop_settings_add_group(gamma, apop_mcmc, .burnin=.1, .periods=1e5,
.proposal=apop_model_set_parameters(apop_normal, 1, .01));
gamma->log_likelihood = NULL;
apop_model *upd_r = apop_update(draws, gamma, apop_exponential);
apop_model *gammafied2 = apop_estimate(apop_data_pmf_expand(upd_r->data, 2000), apop_gamma);
deciles(gammafied2, gammaup, 5);
}
void gammafish(){
printf("gamma/poisson\n");
apop_model *gamma = apop_model_set_parameters(apop_gamma, 1.5, 2.2);
apop_model *drawfrom = apop_model_set_parameters(apop_poisson, 3.1);
int draw_ct = 90;
apop_data *draws = apop_model_draws(drawfrom, draw_ct);
apop_model *gammaup = apop_update(draws, gamma, apop_poisson);
apop_model_show(gammaup);
gamma->more = apop_gamma;
gamma->log_likelihood = fake_ll;
apop_model *proposal = apop_model_fix_params(apop_model_set_parameters(apop_normal, NAN, 1));
proposal->parameters = apop_data_falloc((1), .9);
//apop_data_set(apop_settings_get(gamma, apop_mcmc, proposal)->parameters, .val=.9);
Apop_settings_add_group(gamma, apop_mcmc, .burnin=.1, .periods=1e4, .proposal=proposal);
apop_model *upd = apop_update(draws, gamma, apop_poisson);
apop_model *gammafied = apop_estimate(upd->data, apop_gamma);
deciles(gammafied, gammaup, 5);
//Apop_settings_add_group(beta, apop_mcmc, .burnin=.4, .periods=1e4);
gamma->log_likelihood = NULL;
apop_model *upd_r = apop_update(draws, gamma, apop_poisson);
apop_model *gammafied2 = apop_estimate(apop_data_pmf_expand(upd_r->data, 2000), apop_gamma);
deciles(gammafied2, gammaup, 5);
deciles(gammafied, gammafied2, 5);
}
void one_run(int grid_size, int pop_size){
printf("------ A run with a %i X %i grid and %i agents:\n", grid_size, grid_size, pop_size);
search_sim.dsize = pop_size;
apop_data_set(search_sim.parameters, 0, .val=grid_size);
apop_data_set(search_sim.parameters, 1, .val=pop_size);
apop_model *model_out = apop_estimate(apop_model_draws(&search_sim, 1000), weibull);
apop_model_show(model_out);
}
void make_draws(){
apop_model *multinom = apop_model_copy(apop_multivariate_normal);
multinom->parameters = apop_data_falloc((2, 2, 2),
1, 1, .1,
8, .1, 1);
multinom->dsize = 2;
apop_model *d1 = apop_estimate(apop_model_draws(multinom), apop_multivariate_normal);
for (int i=0; i< 2; i++)
for (int j=-1; j< 2; j++)
assert(fabs(apop_data_get(multinom->parameters, i, j)
- apop_data_get(d1->parameters, i, j)) < .25);
multinom->draw = NULL; //so draw via MCMC
apop_model *d2 = apop_estimate(apop_model_draws(multinom, 10000), apop_multivariate_normal);
for (int i=0; i< 2; i++)
for (int j=-1; j< 2; j++)
assert(fabs(apop_data_get(multinom->parameters, i, j)
- apop_data_get(d2->parameters, i, j)) < .25);
}
//The probability: draw from the rng, smooth with a kernel density, calculate p.
long double p(apop_data *d, apop_model *m){
int draw_ct = 100;
apop_data *draws = apop_model_draws(m, draw_ct);
apop_model *smoothed = apop_model_copy_set(apop_kernel_density, apop_kernel_density,
.base_data =draws, .kernel=apop_uniform, .set_fn=set_midpoint);
double out = apop_p(d, smoothed);
apop_data_free(draws);
apop_model_free(smoothed);
return out;
}
int main(){
apop_model *uniform_20 = apop_model_set_parameters(apop_uniform, 0, 20);
apop_data *d = apop_model_draws(uniform_20, 10);
//Estimate a Normal distribution from the data:
apop_model *N = apop_estimate(d, apop_normal);
print_draws(N);
//estimate a one-dimensional multivariate Normal from the data:
apop_model *mvN = apop_estimate(d, apop_multivariate_normal);
print_draws(mvN);
//fixed parameter list:
apop_model *std_normal = apop_model_set_parameters(apop_normal, 0, 1);
print_draws(std_normal);
//variable-size parameter list:
apop_model *std_multinormal = apop_model_copy(apop_multivariate_normal);
std_multinormal->msize1 =
std_multinormal->msize2 =
std_multinormal->vsize =
std_multinormal->dsize = 3;
std_multinormal->parameters = apop_data_falloc((3, 3, 3),
1, 1, 0, 0,
1, 0, 1, 0,
1, 0, 0, 1);
print_draws(std_multinormal);
//estimate a KDE using the defaults:
apop_model *k = apop_estimate(d, apop_kernel_density);
print_draws(k);
/*the documentation tells us that a KDE estimation consists of filling
an apop_kernel_density_settings group, so we can set it to use a
Normal(μ, 2) kernel via: */
apop_model *k2 = apop_model_copy_set(apop_kernel_density, apop_kernel_density,
.base_data=d,
.kernel = apop_model_set_parameters(apop_normal, 0, 2));
print_draws(k2);
}
apop_model *fuzz(apop_model sim){
int draws = 100;
gsl_rng *r = apop_rng_alloc(1);
apop_model *prior = apop_model_cross(
apop_model_set_parameters(apop_normal, 10, 2),
apop_model_set_parameters(apop_normal, 10, 2));
apop_data *outdata = apop_data_alloc(draws, weibull->vsize);
double *params = sim.parameters->vector->data;
for (int i=0; i< draws; i++){
do {
apop_draw(params, r, prior);
} while (params[1]*2 > pow(params[0], 2));
sim.dsize=params[1];
apop_model *est = apop_estimate(apop_model_draws(&sim, 1000), weibull);
Apop_row_v(outdata, i, onerow);
gsl_vector_memcpy(onerow, est->parameters->vector);
apop_model_free(est);
}
return apop_estimate(outdata, apop_pmf);
}
int main(){
apop_model_print (
apop_estimate(
apop_update(
apop_model_draws(
apop_model_mixture(
apop_model_set_parameters(apop_poisson, 2.8),
apop_model_set_parameters(apop_poisson, 2.0),
apop_model_set_parameters(apop_poisson, 1.3)
),
1e4
),
truncate_model(
apop_model_set_parameters(apop_normal, 2, 1),
0
),
apop_poisson
)->data,
apop_normal
)
, NULL);
}
int main(){
size_t ct = 5e4;
//set up the model & params
apop_data *params = apop_data_falloc((2,2,2), 8, 1, 0.5,
2, 0.5, 1);
apop_model *pvm = apop_model_copy(apop_multivariate_normal);
pvm->parameters = apop_data_copy(params);
pvm->dsize = 2;
apop_data *d = apop_model_draws(pvm, ct);
//set up and estimate a model with fixed covariance matrix but free means
gsl_vector_set_all(pvm->parameters->vector, GSL_NAN);
apop_model *mep1 = apop_model_fix_params(pvm);
apop_model *e1 = apop_estimate(d, mep1);
//compare results
printf("original params: ");
apop_vector_print(params->vector);
printf("estimated params: ");
apop_vector_print(e1->parameters->vector);
assert(apop_vector_distance(params->vector, e1->parameters->vector)<1e-2);
}
apop_data *draw_some_data(){
apop_model *uniform_0_20 = apop_model_set_parameters(apop_uniform, 0, 20);
apop_data *d = apop_model_draws(uniform_0_20, 10);
apop_data_print(apop_data_sort(d), .output_pipe=stderr);
return d;
}
