#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;
}
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++)
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;
/*
For large data sets, use QR decomposition.
}
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);