static struct cmd_regression cmd;
/* Linear regression models. */
-pspp_linreg_cache **models = NULL;
+static pspp_linreg_cache **models = NULL;
/*
Transformations for saving predicted values
File where the model will be saved if the EXPORT subcommand
is given.
*/
-struct file_handle *model_file;
+static struct file_handle *model_file;
/*
Return value for the procedure.
*/
-int pspp_reg_rc = CMD_SUCCESS;
+static int pspp_reg_rc = CMD_SUCCESS;
static bool run_regression (const struct ccase *,
- const struct casefile *, void *);
+ const struct casefile *, void *,
+ const struct dataset *);
/*
STATISTICS subcommand output functions.
Gets the predicted values.
*/
static int
-regression_trns_pred_proc (void *t_, struct ccase *c, int case_idx UNUSED)
+regression_trns_pred_proc (void *t_, struct ccase *c,
+ casenumber case_idx UNUSED)
{
size_t i;
size_t n_vals;
Gets the residuals.
*/
static int
-regression_trns_resid_proc (void *t_, struct ccase *c, int case_idx UNUSED)
+regression_trns_resid_proc (void *t_, struct ccase *c,
+ casenumber case_idx UNUSED)
{
size_t i;
size_t n_vals;
}
/*
- Returns 0 if NAME is a duplicate of any existing variable name.
+ Returns false if NAME is a duplicate of any existing variable name.
*/
-static int
-try_name (char *name)
+static bool
+try_name (const struct dictionary *dict, const char *name)
{
- if (dict_lookup_var (default_dict, name) != NULL)
- return 0;
+ if (dict_lookup_var (dict, name) != NULL)
+ return false;
- return 1;
+ return true;
}
+
static void
-reg_get_name (char name[LONG_NAME_LEN], const char prefix[LONG_NAME_LEN])
+reg_get_name (const struct dictionary *dict, char name[LONG_NAME_LEN], const char prefix[LONG_NAME_LEN])
{
int i = 1;
snprintf (name, LONG_NAME_LEN, "%s%d", prefix, i);
- while (!try_name (name))
+ while (!try_name (dict, name))
{
i++;
snprintf (name, LONG_NAME_LEN, "%s%d", prefix, i);
}
}
+
static void
-reg_save_var (const char *prefix, trns_proc_func * f,
+reg_save_var (struct dataset *ds, const char *prefix, trns_proc_func * f,
pspp_linreg_cache * c, struct variable **v, int n_trns)
{
+ struct dictionary *dict = dataset_dict (ds);
static int trns_index = 1;
char name[LONG_NAME_LEN];
struct variable *new_var;
t->trns_id = trns_index;
t->n_trns = n_trns;
t->c = c;
- reg_get_name (name, prefix);
- new_var = dict_create_var (default_dict, name, 0);
+ reg_get_name (dict, name, prefix);
+ new_var = dict_create_var (dict, name, 0);
assert (new_var != NULL);
*v = new_var;
- add_transformation (f, regression_trns_free, t);
+ add_transformation (ds, f, regression_trns_free, t);
trns_index++;
}
+
static void
-subcommand_save (int save, pspp_linreg_cache ** models)
+subcommand_save (struct dataset *ds, int save, pspp_linreg_cache ** models)
{
pspp_linreg_cache **lc;
int n_trns = 0;
assert ((*lc)->depvar != NULL);
if (cmd.a_save[REGRESSION_SV_RESID])
{
- reg_save_var ("RES", regression_trns_resid_proc, *lc,
+ reg_save_var (ds, "RES", regression_trns_resid_proc, *lc,
&(*lc)->resid, n_trns);
}
if (cmd.a_save[REGRESSION_SV_PRED])
{
- reg_save_var ("PRED", regression_trns_pred_proc, *lc,
+ reg_save_var (ds, "PRED", regression_trns_pred_proc, *lc,
&(*lc)->pred, n_trns);
}
}
}
}
}
+
static int
reg_inserted (const struct variable *v, struct variable **varlist, int n_vars)
{
}
return 0;
}
+
static void
reg_print_categorical_encoding (FILE * fp, pspp_linreg_cache * c)
{
size_t i;
size_t j;
int n_quantiles = 100;
- double increment;
double tmp;
struct pspp_coeff *coeff;
reg_print_categorical_encoding (fp, c);
}
fprintf (fp, "%s", reg_export_t_quantiles_1);
- increment = 0.5 / (double) increment;
for (i = 0; i < n_quantiles - 1; i++)
{
tmp = 0.5 + 0.005 * (double) i;
fclose (fp);
}
}
+
static int
-regression_custom_export (struct cmd_regression *cmd UNUSED, void *aux UNUSED)
+regression_custom_export (struct dataset *ds UNUSED, struct cmd_regression *cmd UNUSED, void *aux UNUSED)
{
/* 0 on failure, 1 on success, 2 on failure that should result in syntax error */
if (!lex_force_match ('('))
}
int
-cmd_regression (void)
+cmd_regression (struct dataset *ds)
{
- if (!parse_regression (&cmd, NULL))
+ if (!parse_regression (ds, &cmd, NULL))
return CMD_FAILURE;
models = xnmalloc (cmd.n_dependent, sizeof *models);
- if (!multipass_procedure_with_splits (run_regression, &cmd))
+ if (!multipass_procedure_with_splits (ds, run_regression, &cmd))
return CMD_CASCADING_FAILURE;
- subcommand_save (cmd.sbc_save, models);
+ subcommand_save (ds, cmd.sbc_save, models);
free (v_variables);
free (models);
return pspp_reg_rc;
/*
Is variable k the dependent variable?
*/
-static int
+static bool
is_depvar (size_t k, const struct variable *v)
{
/*
names match.
*/
if (!compare_var_names (v, v_variables[k], NULL))
- return 1;
+ return true;
- return 0;
+ return false;
}
/*
size_t row;
const union value *val;
- for (r = casefile_get_reader (cf);
+ for (r = casefile_get_reader (cf, NULL);
casereader_read (r, &c); case_destroy (&c))
{
row = casereader_cnum (r) - 1;
/* Parser for the variables sub command */
static int
-regression_custom_variables (struct cmd_regression *cmd UNUSED,
- void *aux UNUSED)
+regression_custom_variables (struct dataset *ds,
+ struct cmd_regression *cmd UNUSED,
+ void *aux UNUSED)
{
+ const struct dictionary *dict = dataset_dict (ds);
lex_match ('=');
- if ((token != T_ID || dict_lookup_var (default_dict, tokid) == NULL)
+ if ((token != T_ID || dict_lookup_var (dict, tokid) == NULL)
&& token != T_ALL)
return 2;
- if (!parse_variables (default_dict, &v_variables, &n_variables, PV_NONE))
+ if (!parse_variables (dict, &v_variables, &n_variables, PV_NONE))
{
free (v_variables);
return 0;
return n_data;
}
+static void
+coeff_init (pspp_linreg_cache * c, struct design_matrix *dm)
+{
+ c->coeff = xnmalloc (dm->m->size2 + 1, sizeof (*c->coeff));
+ c->coeff[0] = xmalloc (sizeof (*(c->coeff[0]))); /* The first coefficient is the intercept. */
+ c->coeff[0]->v_info = NULL; /* Intercept has no associated variable. */
+ pspp_coeff_init (c->coeff + 1, dm);
+}
static bool
run_regression (const struct ccase *first,
- const struct casefile *cf, void *cmd_ UNUSED)
+ const struct casefile *cf, void *cmd_ UNUSED, const struct dataset *ds)
{
size_t i;
size_t n_data = 0; /* Number of valide cases. */
assert (models != NULL);
- output_split_file_values (first);
+ output_split_file_values (ds, first);
if (!v_variables)
{
- dict_get_vars (default_dict, &v_variables, &n_variables,
+ dict_get_vars (dataset_dict (ds), &v_variables, &n_variables,
1u << DC_SYSTEM);
}
The second pass fills the design matrix.
*/
row = 0;
- for (r = casefile_get_reader (cf); casereader_read (r, &c);
+ for (r = casefile_get_reader (cf, NULL); casereader_read (r, &c);
case_destroy (&c))
/* Iterate over the cases. */
{
and store pointers to the variables that correspond to the
coefficients.
*/
- pspp_coeff_init (models[k], X);
+ coeff_init (models[k], X);
/*
Find the least-squares estimates and other statistics.
projects / pspp-builds.git / blobdiff