SAMPLE_VGM *init_ev(void) {
SAMPLE_VGM *ev = NULL;
ev = (SAMPLE_VGM *) emalloc(sizeof(SAMPLE_VGM));
set_mv_double(&(ev->cutoff));
set_mv_double(&(ev->iwidth));
ev->gamma = NULL;
ev->dist = NULL;
ev->nh = NULL;
ev->pairs = NULL;
ev->n_max = 0;
ev->n_est = 0;
ev->zero = ZERO_DEFAULT;
ev->plot_numbers = 1;
ev->is_directional = 0;
ev->evt = NOTSPECIFIED;
ev->fit = NO_FIT;
ev->recalc = 1;
ev->refit = 1;
ev->pseudo = 0;
ev->is_asym = -1;
ev->map = NULL;
ev->S_grid = NULL;
ev->direction.x = 1.0;
ev->direction.y = ev->direction.z = 0.0;
return ev;
}
static void init_variogram_part(VGM_MODEL *p) {
int i;
p->sill = 0.0;
for (i = 0; i < NRANGEPARS; i++) {
p->range[i] = 0.0; /* quiets valgrind? */
set_mv_double(&(p->range[i])); /* trigger errors if misused */
}
p->model = NOT_SP;
p->fit_sill = p->fit_range = 1;
p->fnct = p->da_fnct = NULL;
p->tm_range = NULL;
p->id = -1;
}
void init_data_minmax(void) {
fix_minmax = 0;
set_mv_double(&(min.x));
set_mv_double(&(min.y));
set_mv_double(&(min.z));
set_mv_double(&(max.x));
set_mv_double(&(max.y));
set_mv_double(&(max.z));
}
double da_general(VGM_MODEL *part, double h) {
/* numerical approximation of derivative: */
int i;
double low, high, range, r[NRANGEPARS];
for (i = 0; i < NRANGEPARS; i++) {
if (is_mv_double(&(part->range[i])))
set_mv_double(&(r[i]));
else
r[i] = part->range[i];
}
range = MAX(1e-20, part->range[0]);
r[0] = range * (1.0 + DA_DELTA);
low = part->fnct(h, r);
r[0] = range * (1.0 - DA_DELTA);
high = part->fnct(h, r);
return part->sill * (low - high) / (2.0 * range * DA_DELTA);
}
void report_xvalid(double *xdata, double *xpred, double *xdiff, double *xstd,
double *xzscore, int ndata, int var) {
/*
* DATE: Tue Oct 6 11:55:44 MET 1992
* BY : Edzer J. Pebesma
* PURPOSE: report summary statistics of these five lists
* SIDE EFFECTS: none
*/
int i, nXdata = 0, nXpred = 0, nXdiff = 0, n_std = 0, nZscore = 0,
compare(const double *a, const double *b);
double min[5], max[5], p25[5], p75[5], p50[5], mean[5], std[5];
double corr = 0.0;
set_mv_double(&corr);
calc_r(xdata, xpred, ndata, &corr);
for (i = 0; i < 5; i ++) {
set_mv_double(&(min[i]));
set_mv_double(&(p25[i]));
set_mv_double(&(p50[i]));
set_mv_double(&(p75[i]));
set_mv_double(&(max[i]));
set_mv_double(&(mean[i]));
set_mv_double(&(std[i]));
}
/* select not missing values, put mv's at the end: */
/* sorting arrays: */
qsort(xdata, (size_t) ndata, sizeof(double),
(int (*)(const void *,const void *)) compare);
while (!is_mv_double(&(xdata[nXdata])) && nXdata < ndata)
nXdata++;
qsort(xpred, (size_t) ndata, sizeof(double),
(int (*)(const void *,const void *)) compare);
while (!is_mv_double(&(xpred[nXpred])) && nXpred < ndata)
nXpred++;
qsort(xdiff, (size_t) ndata, sizeof(double),
(int (*)(const void *,const void *)) compare);
while (!is_mv_double(&(xdiff[nXdiff])) && nXdiff < ndata)
nXdiff++;
if (var) { /* do everything for xstd and xzscore */
qsort(xstd, (size_t) ndata, sizeof(double),
(int (*)(const void *,const void *)) compare);
while ((! is_mv_double(&(xstd[n_std]))) && (n_std < ndata))
n_std++;
qsort(xzscore, (size_t) ndata, sizeof(double),
(int (*)(const void *,const void *)) compare);
while ((! is_mv_double(&(xzscore[nZscore]))) && (nZscore < ndata))
nZscore++;
}
/* calculate statistics: */
if (nXdata) {
min[0]=xdata[0];
max[0]=xdata[nXdata-1];
mean[0] = sample_mean(xdata, nXdata);
if (nXdata > 1) {
p25[0]=est_quant(xdata, 0.25, nXdata);
p50[0]=est_quant(xdata, 0.5, nXdata);
p75[0]=est_quant(xdata, 0.75, nXdata);
std[0] = sample_std(xdata, mean[0], nXdata);
}
}
if (nXpred) {
min[1]=xpred[0];
max[1]=xpred[nXpred-1];
mean[1] = sample_mean(xpred, nXpred);
if (nXpred > 1) {
p25[1]=est_quant(xpred, 0.25, nXpred);
p50[1]=est_quant(xpred, 0.5, nXpred);
p75[1]=est_quant(xpred, 0.75, nXpred);
std[1] = sample_std(xpred, mean[1], nXpred);
}
}
if (nXdiff) {
min[2]=xdiff[0];
max[2]=xdiff[nXdiff-1];
mean[2] = sample_mean(xdiff, nXdiff);
if (nXdiff > 1) {
p25[2]=est_quant(xdiff, 0.25, nXdiff);
p50[2]=est_quant(xdiff, 0.5, nXdiff);
p75[2]=est_quant(xdiff, 0.75, nXdiff);
std[2] = sample_std(xdiff, mean[2], nXdiff);
}
}
if (var) {
if (n_std) {
min[3]=xstd[0];
max[3]=xstd[n_std-1];
mean[3] = sample_mean(xstd, n_std);
if (n_std > 1) {
p25[3]=est_quant(xstd, 0.25, n_std);
p50[3]=est_quant(xstd, 0.5, n_std);
p75[3]=est_quant(xstd, 0.75, n_std);
std[3] = sample_std(xstd, mean[3], n_std);
}
}
if (nZscore) {
min[4]=xzscore[0];
max[4]=xzscore[nZscore-1];
mean[4] = sample_mean(xzscore, nZscore);
if (nZscore > 1) {
p25[4]=est_quant(xzscore, 0.25, nZscore);
p50[4]=est_quant(xzscore, 0.5, nZscore);
p75[4]=est_quant(xzscore, 0.75, nZscore);
std[4] = sample_std(xzscore, mean[4], nZscore);
}
}
}
/* output: */
printlog("corr(Obs, Pred): %s [%s]\n\n",
my_dtoa("%6.4g", &corr),
method_string(get_method()));
printlog(" observed predicted pred.-obs. pred.std. zscore\n");
printlog("======================================================================\n");
printlog("%-10s%12s", "minimum", my_dtoa("%6.4g", &(min[0])));
printlog("%12s", my_dtoa("%6.4g", &(min[1])));
printlog("%12s", my_dtoa("%6.4g", &(min[2])));
printlog("%12s", my_dtoa("%6.4g", &(min[3])));
printlog("%12s\n", my_dtoa("%6.4g", &(min[4])));
printlog("%-10s%12s", "1st q.", my_dtoa("%6.4g", &(p25[0])));
printlog("%12s", my_dtoa("%6.4g", &(p25[1])));
printlog("%12s", my_dtoa("%6.4g", &(p25[2])));
printlog("%12s", my_dtoa("%6.4g", &(p25[3])));
printlog("%12s\n", my_dtoa("%6.4g", &(p25[4])));
printlog("%-10s%12s", "median", my_dtoa("%6.4g", &(p50[0])));
printlog("%12s", my_dtoa("%6.4g", &(p50[1])));
printlog("%12s", my_dtoa("%6.4g", &(p50[2])));
printlog("%12s", my_dtoa("%6.4g", &(p50[3])));
printlog("%12s\n", my_dtoa("%6.4g", &(p50[4])));
printlog("%-10s%12s", "3rd q.", my_dtoa("%6.4g", &(p75[0])));
printlog("%12s", my_dtoa("%6.4g", &(p75[1])));
printlog("%12s", my_dtoa("%6.4g", &(p75[2])));
printlog("%12s", my_dtoa("%6.4g", &(p75[3])));
printlog("%12s\n", my_dtoa("%6.4g", &(p75[4])));
printlog("%-10s%12s", "maximum", my_dtoa("%6.4g", &(max[0])));
printlog("%12s", my_dtoa("%6.4g", &(max[1])));
printlog("%12s", my_dtoa("%6.4g", &(max[2])));
printlog("%12s", my_dtoa("%6.4g", &(max[3])));
printlog("%12s\n\n", my_dtoa("%6.4g", &(max[4])));
printlog("%-10s%12d%12d%12d%12d%12d\n", "n",
nXdata, nXpred, nXdiff, n_std, nZscore);
printlog("%-10s%12s", "mean", my_dtoa("%6.4g", &(mean[0])));
printlog("%12s", my_dtoa("%6.4g", &(mean[1])));
printlog("%12s", my_dtoa("%6.4g", &(mean[2])));
printlog("%12s", my_dtoa("%6.4g", &(mean[3])));
printlog("%12s\n", my_dtoa("%6.4g", &(mean[4])));
printlog("%-10s%12s", "std.dev.", my_dtoa("%6.4g", &(std[0])));
printlog("%12s", my_dtoa("%6.4g", &(std[1])));
printlog("%12s", my_dtoa("%6.4g", &(std[2])));
printlog("%12s", my_dtoa("%6.4g", &(std[3])));
printlog("%12s\n", my_dtoa("%6.4g", &(std[4])));
return;
}
DATA *init_one_data(DATA *data) {
if (data == NULL)
data = (DATA *) emalloc(sizeof(DATA));
data->colnvalue = 0;
data->colnx = 0;
data->colny = 0;
data->colnz = 0;
data->colns = 0;
data->coln_id = 0;
data->colnvariance = 0;
data->n_list = -1;
data->n_max = -1;
data->nsim_at_data = 0;
data->init_max = 0;
data->n_sel = -1;
data->n_sel_max = 0;
data->id = -1;
data->log = 0;
data->standard = 0;
data->what_is_u = U_UNKNOWN;
data->centre = 0;
data->region = 0;
data->mode = 0;
data->dummy = 0;
data->force = 0;
data->vdist = 0;
data->square = 0;
data->average = 0;
data->every = 1;
data->offset = 0;
data->prob = 1.0;
data->skip = 0;
data->lambda = 1.0;
data->calc_residuals = 1;
data->is_residual = 0;
data->polynomial_degree = 0;
data->n_averaged = 0;
data->fname = NULL;
data->type = data_types[DATA_UNKNOWN];
data->variable = NULL;
data->x_coord = NULL;
data->y_coord = NULL;
data->z_coord = NULL;
data->s_coord = NULL;
data->V_coord = NULL;
data->point_ids = NULL;
data->id_name = NULL;
data->mean = 0.0;
data->std = 0.0;
data->sel_rad = DBL_MAX;
data->dX = DBL_MAX;
data->sel_max = INT_MAX;
data->sel_min = 0;
data->oct_max = 0; /* default: don't use octant search */
data->oct_filled = 1; /* in case of no octants */
data->list = NULL;
data->sel = NULL;
data->P_base = NULL;
data->X_base = NULL;
data->lm = NULL;
data->glm = NULL;
data->n_merge = 0;
data->mtbl = NULL;
data->n_X = 0;
data->colX = NULL;
data_add_X(data, 0);
/* add intercept -->> UK, defaulting to ordinary kriging */
data->qtree_root = NULL;
data->grid = NULL;
data->togrid = 0;
data->point_norm = NULL;
data->pp_norm2 = NULL;
data->pb_norm2 = NULL;
data->beta = NULL;
data->Category = NULL;
data->var_fn_str = NULL;
data->nscore_table = NULL;
data->variance_fn = NULL;
set_mv_double(&(data->Icutoff));
set_mv_double(&(data->mv));
return data;
}
void predict_all(DATA **data) {
int i = 0, random_path = 0;
DPOINT *here = NULL, *where = NULL;
PRED_AT at_what;
unsigned int row, col;
n_done = 0;
val_data = get_dataval();
if (val_data->id > -1) {
at_what = AT_POINTS;
n_pred_locs = val_data->n_list;
if (val_data->colns)
strata_min = val_data->minstratum;
} else if (get_n_masks() > 0) {
at_what = AT_GRIDMAP;
here = (DPOINT *) emalloc(sizeof(DPOINT));
here->u.stratum = -2; /* only NON-MV cells */
if (max_block_dimension(0) > 0.0)
SET_BLOCK(here);
else
SET_POINT(here);
} else /* what else ? */
return;
if (at_what == AT_GRIDMAP && get_n_outfile() == 0) {
pr_warning("no output maps defined");
return;
}
init_predictions(at_what);
if (at_what == AT_GRIDMAP && !data[0]->dummy) {
if (data[0]->maxX < masks[0]->x_ul ||
data[0]->minX > (masks[0]->x_ul + masks[0]->cols * masks[0]->cellsizex) ||
data[0]->minY > masks[0]->y_ul ||
data[0]->maxY < (masks[0]->y_ul - masks[0]->rows * masks[0]->cellsizey)) {
pr_warning("ALL data are outside the map boundaries");
printlog("data x[%g,%g], y[%g,%g]; map x[%g,%g], y[%g,%g]\n",
data[0]->minX, data[0]->maxX, data[0]->minY, data[0]->maxY,
masks[0]->x_ul,
masks[0]->x_ul + masks[0]->cols * masks[0]->cellsizex,
masks[0]->y_ul - masks[0]->rows * masks[0]->cellsizey,
masks[0]->y_ul
);
}
else if (map_xy2rowcol(masks[0], data[0]->minX, data[0]->minY, &row, &col) ||
map_xy2rowcol(masks[0], data[0]->maxX, data[0]->minY, &row, &col) ||
map_xy2rowcol(masks[0], data[0]->minX, data[0]->maxY, &row, &col) ||
map_xy2rowcol(masks[0], data[0]->maxX, data[0]->maxY, &row, &col))
pr_warning("at least some data are outside the map boundaries");
/* this is not a sufficient test! */
}
if (gl_rp) /* Yes, by default */
random_path = is_simulation(get_method());
row = col = 0;
while ((where = next_location(here, at_what, random_path,
&row, &col, data)) != NULL) {
for (i = 0; i < get_n_outfile(); i++)
set_mv_double(&(est[i])); /* initialize estimates */
if (where->u.stratum >= 0) {
if (get_mode() != STRATIFY) {
for (i = 0; i < get_n_vars(); i++)
select_at(data[i], where);
} else if (where->u.stratum < get_n_vars())
select_at(data[where->u.stratum], where);
get_est(data, get_method(), where, est);
}
/* printf("%g %g\n", est[0], est[1]); */
write_output(est, at_what, where, row, col);
}
exit_predictions(at_what);
if (here != NULL)
efree(here);
print_progress(100, 100);
}
int init_global_variables(void) {
/*
* global variables init. (glvars.h; defautls.h):
*/
method = NSP;
mode = MODE_NSP;
debug_level = DB_NORMAL;
gl_blas = DEF_blas;
gl_choleski = DEF_choleski;
gl_coincide = DEF_coincide;
gl_cressie = DEF_cressie;
gl_fit = DEF_fit;
gl_gauss = DEF_gauss;
gl_iter = DEF_iter;
gl_jgraph = DEF_jgraph;
gl_lhs = DEF_lhs;
gl_longlat = DEF_longlat;
gl_nblockdiscr = DEF_nblockdiscr;
gl_n_intervals = DEF_intervals;
gl_n_marginals = DEF_n_marginals;
gl_nsim = DEF_nsim;
gl_n_uk = DEF_n_uk;
gl_numbers = DEF_numbers;
gl_nocheck = DEF_nocheck;
gl_order = DEF_order;
gl_register_pairs = DEF_pairs;
gl_rowwise = DEF_rowwise;
gl_rp = DEF_rp;
gl_seed = DEF_seed;
gl_sim_beta = DEF_sim_beta;
gl_spiral = DEF_spiral;
gl_split = DEF_split;
gl_sym_ev = DEF_sym_ev;
gl_gls_residuals = DEF_gls_residuals;
gl_sparse = DEF_sparse;
gl_xvalid = DEF_xvalid;
gl_zero_est = DEF_zero_est;
gl_bounds = DEF_bounds;
gl_cutoff = DEF_cutoff;
gl_fit_limit = DEF_fit_limit;
gl_fraction = DEF_fraction;
gl_idp = DEF_idp;
gl_iwidth = DEF_iwidth;
gl_quantile = DEF_quantile;
gl_zmap = DEF_zmap;
gl_alpha = DEF_alpha;
gl_beta = DEF_beta;
gl_tol_hor = DEF_tol_hor;
gl_tol_ver = DEF_tol_ver;
gl_zero = DEF_zero;
init_gstat_data(0);
/* EJPXX
* if (valdata == NULL)
* */
valdata = init_one_data(valdata);
block.x = block.y = block.z = 0.0;
set_mv_double(&gl_zmap);
get_covariance(NULL, 0, 0, 0);
return 0;
}
