#include <language/dictionary/split-file.h>
#include <language/data-io/file-handle.h>
#include <language/lexer/lexer.h>
-#include <libpspp/alloc.h>
#include <libpspp/compiler.h>
#include <libpspp/message.h>
#include <libpspp/taint.h>
#include <math/moments.h>
#include <output/table.h>
+#include "xalloc.h"
+
#include "gettext.h"
#define _(msgid) gettext (msgid)
const struct variable *v;
};
-/* Linear regression models. */
-static pspp_linreg_cache **models = NULL;
-
/*
Transformations for saving predicted values
and residuals, etc.
static struct file_handle *model_file;
static bool run_regression (struct casereader *, struct cmd_regression *,
- struct dataset *);
+ struct dataset *, pspp_linreg_cache **);
/*
STATISTICS subcommand output functions.
double std_err;
double beta;
const char *label;
- char *tmp;
+
const struct variable *v;
const union value *val;
- const char *val_s;
struct tab_table *t;
assert (c != NULL);
- tmp = xnmalloc (MAX_STRING, sizeof (*tmp));
n_rows = c->n_coeffs + 2;
t = tab_create (n_cols, n_rows, 0);
tab_float (t, 6, 1, 0, pval, 10, 2);
for (j = 1; j <= c->n_indeps; j++)
{
+ struct string tstr;
+ ds_init_empty (&tstr);
+
v = pspp_coeff_get_var (c->coeff[j], 0);
label = var_to_string (v);
/* Do not overwrite the variable's name. */
- strncpy (tmp, label, MAX_STRING);
+ ds_put_cstr (&tstr, label);
if (var_is_alpha (v))
{
/*
*/
val = pspp_coeff_get_value (c->coeff[j], v);
- val_s = var_get_value_name (v, val);
- strncat (tmp, val_s, MAX_STRING);
+
+ var_append_value_name (v, val, &tstr);
}
- tab_text (t, 1, j + 1, TAB_CENTER, tmp);
+ tab_text (t, 1, j + 1, TAB_CENTER, ds_cstr (&tstr));
/*
Regression coefficients.
*/
2 * gsl_cdf_tdist_Q (fabs (t_stat),
(double) (c->n_obs - c->n_coeffs));
tab_float (t, 6, j + 1, 0, pval, 10, 2);
+ ds_destroy (&tstr);
}
tab_title (t, _("Coefficients"));
tab_submit (t);
- free (tmp);
}
/*
}
static void
-reg_get_name (const struct dictionary *dict, char name[LONG_NAME_LEN],
- const char prefix[LONG_NAME_LEN])
+reg_get_name (const struct dictionary *dict, char name[VAR_NAME_LEN],
+ const char prefix[VAR_NAME_LEN])
{
int i = 1;
- snprintf (name, LONG_NAME_LEN, "%s%d", prefix, i);
+ snprintf (name, VAR_NAME_LEN, "%s%d", prefix, i);
while (!try_name (dict, name))
{
i++;
- snprintf (name, LONG_NAME_LEN, "%s%d", prefix, i);
+ snprintf (name, VAR_NAME_LEN, "%s%d", prefix, i);
}
}
{
struct dictionary *dict = dataset_dict (ds);
static int trns_index = 1;
- char name[LONG_NAME_LEN];
+ char name[VAR_NAME_LEN];
struct variable *new_var;
struct reg_trns *t = NULL;
for (j = 0; j < n_categories; j++)
{
+ struct string vstr;
const union value *val = cat_subscript_to_value (j, varlist[i]);
+ ds_init_empty (&vstr);
+ var_append_value_name (varlist[i], val, &vstr);
fprintf (fp, "%s.values[%d] = \"%s\";\n\t",
var_get_name (varlist[i]), j,
- var_get_value_name (varlist[i], val));
+ ds_cstr (&vstr));
+
+ ds_destroy (&vstr);
}
}
fprintf (fp, "%s", reg_export_categorical_encode_2);
model_file = NULL;
else
{
+ fh_unref (model_file);
model_file = fh_parse (lexer, FH_REF_FILE);
if (model_file == NULL)
return 0;
{
struct casegrouper *grouper;
struct casereader *group;
+ pspp_linreg_cache **models;
bool ok;
size_t i;
+ model_file = NULL;
if (!parse_regression (lexer, ds, &cmd, NULL))
- return CMD_FAILURE;
+ {
+ fh_unref (model_file);
+ return CMD_FAILURE;
+ }
models = xnmalloc (cmd.n_dependent, sizeof *models);
for (i = 0; i < cmd.n_dependent; i++)
/* Data pass. */
grouper = casegrouper_create_splits (proc_open (ds), dataset_dict (ds));
while (casegrouper_get_next_group (grouper, &group))
- run_regression (group, &cmd, ds);
+ run_regression (group, &cmd, ds, models);
ok = casegrouper_destroy (grouper);
ok = proc_commit (ds) && ok;
subcommand_save (ds, cmd.sbc_save, models);
free (v_variables);
free (models);
+ free_regression (&cmd);
+ fh_unref (model_file);
+
return ok ? CMD_SUCCESS : CMD_FAILURE;
}
/* Identify the explanatory variables in v_variables. Returns
the number of independent variables. */
static int
-identify_indep_vars (const struct variable **indep_vars, const struct variable *depvar)
+identify_indep_vars (const struct variable **indep_vars,
+ const struct variable *depvar)
{
int n_indep_vars = 0;
int i;
for (i = 0; i < n_variables; i++)
if (!is_depvar (i, depvar))
indep_vars[n_indep_vars++] = v_variables[i];
-
+ if ((n_indep_vars < 2) && is_depvar (0, depvar))
+ {
+ /*
+ There is only one independent variable, and it is the same
+ as the dependent variable. Print a warning and continue.
+ */
+ msg (SE,
+ gettext ("The dependent variable is equal to the independent variable."
+ "The least squares line is therefore Y=X."
+ "Standard errors and related statistics may be meaningless."));
+ n_indep_vars = 1;
+ indep_vars[0] = v_variables[0];
+ }
return n_indep_vars;
}
Returns number of valid cases. */
static int
prepare_categories (struct casereader *input,
- const struct variable **vars, size_t n_vars,
- struct moments_var *mom)
+ const struct variable **vars, size_t n_vars,
+ struct moments_var *mom)
{
int n_data;
struct ccase c;
size_t i;
+ assert (vars != NULL);
+ assert (mom != NULL);
+
for (i = 0; i < n_vars; i++)
if (var_is_alpha (vars[i]))
cat_stored_values_create (vars[i]);
for (; casereader_read (input, &c); case_destroy (&c))
{
/*
- The second condition ensures the program will run even if
- there is only one variable to act as both explanatory and
- response.
+ The second condition ensures the program will run even if
+ there is only one variable to act as both explanatory and
+ response.
*/
for (i = 0; i < n_vars; i++)
- {
- const union value *val = case_data (&c, vars[i]);
- if (var_is_alpha (vars[i]))
- cat_value_update (vars[i], val);
- else
- moments1_add (mom[i].m, val->f, 1.0);
- }
+ {
+ const union value *val = case_data (&c, vars[i]);
+ if (var_is_alpha (vars[i]))
+ cat_value_update (vars[i], val);
+ else
+ moments1_add (mom[i].m, val->f, 1.0);
+ }
n_data++;
- }
+ }
casereader_destroy (input);
return n_data;
static bool
run_regression (struct casereader *input, struct cmd_regression *cmd,
- struct dataset *ds)
+ struct dataset *ds, pspp_linreg_cache **models)
{
size_t i;
int n_indep = 0;
assert (models != NULL);
if (!casereader_peek (input, 0, &c))
- return true;
+ {
+ casereader_destroy (input);
+ return true;
+ }
output_split_file_values (ds, &c);
case_destroy (&c);
if (!v_variables)
{
- dict_get_vars (dataset_dict (ds), &v_variables, &n_variables,
- 1u << DC_SYSTEM);
+ dict_get_vars (dataset_dict (ds), &v_variables, &n_variables, 0);
}
for (i = 0; i < cmd->n_dependent; i++)
dep_var = cmd->v_dependent[k];
n_indep = identify_indep_vars (indep_vars, dep_var);
-
reader = casereader_clone (input);
reader = casereader_create_filter_missing (reader, indep_vars, n_indep,
- MV_ANY, NULL);
+ MV_ANY, NULL);
reader = casereader_create_filter_missing (reader, &dep_var, 1,
- MV_ANY, NULL);
- n_data = prepare_categories (casereader_clone (reader),
- indep_vars, n_indep, mom);
+ MV_ANY, NULL);
+ n_data = prepare_categories (casereader_clone (reader),
+ indep_vars, n_indep, mom);
if ((n_data > 0) && (n_indep > 0))
{
lopts.get_indep_mean_std[i] = 1;
}
models[k] = pspp_linreg_cache_alloc (X->m->size1, X->m->size2);
- models[k]->indep_means = gsl_vector_alloc (X->m->size2);
- models[k]->indep_std = gsl_vector_alloc (X->m->size2);
- models[k]->depvar = dep_var;
- /*
+ models[k]->depvar = dep_var;
+ /*
For large data sets, use QR decomposition.
*/
if (n_data > sqrt (n_indep) && n_data > REG_LARGE_DATA)
{
- models[k]->method = PSPP_LINREG_SVD;
+ models[k]->method = PSPP_LINREG_QR;
}
/*
- The second pass fills the design matrix.
- */
- reader = casereader_create_counter (reader, &row, -1);
- for (; casereader_read (reader, &c); case_destroy (&c))
- {
- for (i = 0; i < n_indep; ++i)
- {
- const struct variable *v = indep_vars[i];
- const union value *val = case_data (&c, v);
- if (var_is_alpha (v))
- design_matrix_set_categorical (X, row, v, val);
- else
- design_matrix_set_numeric (X, row, v, val);
- }
- gsl_vector_set (Y, row, case_num (&c, dep_var));
- }
- casereader_destroy (reader);
+ The second pass fills the design matrix.
+ */
+ reader = casereader_create_counter (reader, &row, -1);
+ for (; casereader_read (reader, &c); case_destroy (&c))
+ {
+ for (i = 0; i < n_indep; ++i)
+ {
+ const struct variable *v = indep_vars[i];
+ const union value *val = case_data (&c, v);
+ if (var_is_alpha (v))
+ design_matrix_set_categorical (X, row, v, val);
+ else
+ design_matrix_set_numeric (X, row, v, val);
+ }
+ gsl_vector_set (Y, row, case_num (&c, dep_var));
+ }
/*
Now that we know the number of coefficients, allocate space
and store pointers to the variables that correspond to the
pspp_linreg ((const gsl_vector *) Y, X->m, &lopts, models[k]);
compute_moments (models[k], mom, X, n_variables);
- if (!taint_has_tainted_successor (casereader_get_taint (input)))
- {
- subcommand_statistics (cmd->a_statistics, models[k]);
- subcommand_export (cmd->sbc_export, models[k]);
- }
+ if (!taint_has_tainted_successor (casereader_get_taint (input)))
+ {
+ subcommand_statistics (cmd->a_statistics, models[k]);
+ subcommand_export (cmd->sbc_export, models[k]);
+ }
gsl_vector_free (Y);
design_matrix_destroy (X);
}
else
{
- msg (SE, gettext ("No valid data found. This command was skipped."));
+ msg (SE,
+ gettext ("No valid data found. This command was skipped."));
}
+ casereader_destroy (reader);
+ }
+ for (i = 0; i < n_variables; i++)
+ {
+ moments1_destroy ((mom + i)->m);
}
+ free (mom);
free (indep_vars);
free (lopts.get_indep_mean_std);
casereader_destroy (input);