Added comments to exported model
[pspp-builds.git] / src / regression.q
index 56420c5335e964dd20ee7a3de9a21aa484fd6aa3..28289622aaded41975b27df35eda4830b4d8c2bf 100644 (file)
 #include "case.h"
 #include "casefile.h"
 #include "cat.h"
+#include "cat-routines.h"
 #include "command.h"
+#include "design-matrix.h"
 #include "dictionary.h"
 #include "error.h"
 #include "file-handle.h"
 #include "gettext.h"
 #include "lexer.h"
 #include <linreg/pspp_linreg.h>
+#include "missing-values.h"
 #include "tab.h"
 #include "var.h"
 #include "vfm.h"
 
-/* (headers) */
+#define REG_LARGE_DATA 1000
 
+/* (headers) */
 
 /* (specification)
    "REGRESSION" (regression_):
@@ -60,6 +64,7 @@
    f,
    defaults,
    all;
+   export=custom;
    ^dependent=varlist;
    ^method=enter.
 */
@@ -72,6 +77,12 @@ static struct cmd_regression cmd;
  */
 size_t *indep_vars;
 
+/*
+  File where the model will be saved if the EXPORT subcommand
+  is given. 
+ */
+struct file_handle *model_file;
+
 /*
   Return value for the procedure.
  */
@@ -151,7 +162,7 @@ reg_stats_coeff (pspp_linreg_cache * c)
   struct tab_table *t;
 
   assert (c != NULL);
-  n_rows = 2;
+  n_rows = c->n_coeffs + 2;
 
   t = tab_create (n_cols, n_rows, 0);
   tab_headers (t, 2, 0, 1, 0);
@@ -167,7 +178,7 @@ reg_stats_coeff (pspp_linreg_cache * c)
   tab_text (t, 5, 0, TAB_CENTER | TAT_TITLE, _("t"));
   tab_text (t, 6, 0, TAB_CENTER | TAT_TITLE, _("Significance"));
   tab_text (t, 1, 1, TAB_LEFT | TAT_TITLE, _("(Constant)"));
-  coeff = gsl_vector_get (c->param_estimates, 0);
+  coeff = c->coeff[0].estimate;
   tab_float (t, 2, 1, 0, coeff, 10, 2);
   std_err = sqrt (gsl_matrix_get (c->cov, 0, 0));
   tab_float (t, 3, 1, 0, std_err, 10, 2);
@@ -177,40 +188,39 @@ reg_stats_coeff (pspp_linreg_cache * c)
   tab_float (t, 5, 1, 0, t_stat, 10, 2);
   pval = 2 * gsl_cdf_tdist_Q (fabs (t_stat), 1.0);
   tab_float (t, 6, 1, 0, pval, 10, 2);
-  for (j = 0; j < c->n_indeps; j++)
+  for (j = 1; j <= c->n_indeps; j++)
     {
       i = indep_vars[j];
-      struct variable *v = cmd.v_variables[i];
-      label = var_to_string (v);
-      tab_text (t, 1, j + 2, TAB_CENTER, label);
+      label = var_to_string (c->coeff[j].v);
+      tab_text (t, 1, j + 1, TAB_CENTER, label);
       /*
          Regression coefficients.
        */
-      coeff = gsl_vector_get (c->param_estimates, j + 1);
-      tab_float (t, 2, j + 2, 0, coeff, 10, 2);
+      coeff = c->coeff[j].estimate;
+      tab_float (t, 2, j + 1, 0, coeff, 10, 2);
       /*
          Standard error of the coefficients.
        */
-      std_err = sqrt (gsl_matrix_get (c->cov, j + 1, j + 1));
-      tab_float (t, 3, j + 2, 0, std_err, 10, 2);
+      std_err = sqrt (gsl_matrix_get (c->cov, j, j));
+      tab_float (t, 3, j + 1, 0, std_err, 10, 2);
       /*
          'Standardized' coefficient, i.e., regression coefficient
          if all variables had unit variance.
        */
-      beta = gsl_vector_get (c->indep_std, j + 1);
+      beta = gsl_vector_get (c->indep_std, j);
       beta *= coeff / c->depvar_std;
-      tab_float (t, 4, j + 2, 0, beta, 10, 2);
+      tab_float (t, 4, j + 1, 0, beta, 10, 2);
 
       /*
          Test statistic for H0: coefficient is 0.
        */
       t_stat = coeff / std_err;
-      tab_float (t, 5, j + 2, 0, t_stat, 10, 2);
+      tab_float (t, 5, j + 1, 0, t_stat, 10, 2);
       /*
          P values for the test statistic above.
        */
       pval = 2 * gsl_cdf_tdist_Q (fabs (t_stat), 1.0);
-      tab_float (t, 6, j + 2, 0, pval, 10, 2);
+      tab_float (t, 6, j + 1, 0, pval, 10, 2);
     }
   tab_title (t, 0, _("Coefficients"));
   tab_submit (t);
@@ -461,6 +471,76 @@ subcommand_statistics (int *keywords, pspp_linreg_cache * c)
   statistics_keyword_output (reg_stats_tol, keywords[tol], c);
   statistics_keyword_output (reg_stats_selection, keywords[selection], c);
 }
+static void
+subcommand_export (int export, pspp_linreg_cache *c)
+{
+  FILE *fp;
+  size_t i;
+  struct pspp_linreg_coeff coeff;
+
+  if (export)
+    {
+      assert (c != NULL);
+      assert (model_file != NULL);
+      assert (fp != NULL);
+      fp = fopen (handle_get_filename (model_file), "w");
+      fprintf (fp, "#include <string.h>\n\n");
+      fprintf (fp, "/*\n   Estimate the mean of Y, the dependent variable for\n");
+      fprintf (fp, "   the linear model of the form \n\n");
+      fprintf (fp, "      Y = b0 + b1 * X1 + b2 * X2 + ... + bk * X2 + error\n\n");
+      fprintf (fp, "   where X1, ..., Xk are the independent variables\n");
+      fprintf (fp, "   whose values are stored in var_vals and whose names, \n");
+      fprintf (fp, "   as known by PSPP, are stored in var_names. The estimated \n");
+      fprintf (fp, "   regression coefficients (i.e., the estimates of b0,...,bk) \n");
+      fprintf (fp, "   are stored in model_coeffs.\n*/\n");
+      fprintf (fp, "double\npspp_reg_estimate (const double *var_vals, const char *var_names[])\n{\n\tchar *model_depvars[%d] = {", c->n_indeps);
+      for (i = 1; i < c->n_indeps; i++)
+       {
+         coeff = c->coeff[i];
+         fprintf (fp, "\"%s\",\n\t\t", coeff.v->name);
+       }
+      coeff = c->coeff[i];
+      fprintf (fp, "\"%s\"};\n\t", coeff.v->name);
+      fprintf (fp, "double model_coeffs[%d] = {", c->n_indeps);
+      for (i = 1; i < c->n_indeps; i++)
+       {
+         coeff = c->coeff[i];
+         fprintf (fp, "%.15e,\n\t\t", coeff.estimate);
+       }
+      coeff = c->coeff[i];
+      fprintf (fp, "%.15e};\n\t", coeff.estimate);
+      coeff = c->coeff[0];
+      fprintf (fp, "double estimate = %.15e;\n\t", coeff.estimate);
+      fprintf (fp, "int i;\n\tint j;\n\n\t");
+      fprintf (fp, "for (i = 0; i < %d; i++)\n\t", c->n_indeps);
+      fprintf (fp, "{\n\t\tfor (j = 0; j < %d; j++)\n\t\t", c->n_indeps);
+      fprintf (fp, "{\n\t\t\tif (strcmp (var_names[i], model_depvars[j]) == 0)\n");
+      fprintf (fp, "\t\t\t{\n\t\t\t\testimate += var_vals[i] * model_coeffs[j];\n");
+      fprintf (fp, "\t\t\t}\n\t\t}\n\t}\n\treturn estimate;\n}\n");
+      fclose (fp);
+    }
+}
+static int
+regression_custom_export (struct cmd_regression *cmd)
+{
+  /* 0 on failure, 1 on success, 2 on failure that should result in syntax error */
+  if (!lex_force_match ('('))
+    return 0;
+  
+  if (lex_match ('*'))
+    model_file = NULL;
+  else 
+    {
+      model_file = fh_parse ();
+      if (model_file == NULL)
+        return 0; 
+    }
+  
+  if (!lex_force_match (')'))
+    return 0;
+
+  return 1;
+}
 
 int
 cmd_regression (void)
@@ -497,104 +577,136 @@ static void
 run_regression (const struct casefile *cf, void *cmd_ UNUSED)
 {
   size_t i;
-  size_t k;
   size_t n_data = 0;
   size_t row;
+  size_t case_num;
   int n_indep;
   int j = 0;
+  /*
+     Keep track of the missing cases.
+   */
+  int *is_missing_case;
   const union value *val;
   struct casereader *r;
   struct casereader *r2;
   struct ccase c;
-  const struct variable *v;
-  struct recoded_categorical_array *ca;
-  struct recoded_categorical *rc;
+  struct variable *v;
+  struct variable **indep_vars;
   struct design_matrix *X;
   gsl_vector *Y;
   pspp_linreg_cache *lcache;
   pspp_linreg_opts lopts;
 
   n_data = casefile_get_case_cnt (cf);
+
+  is_missing_case = xnmalloc (n_data, sizeof (*is_missing_case));
+  for (i = 0; i < n_data; i++)
+    is_missing_case[i] = 0;
+
   n_indep = cmd.n_variables - cmd.n_dependent;
   indep_vars = xnmalloc (n_indep, sizeof *indep_vars);
 
-  Y = gsl_vector_alloc (n_data);
   lopts.get_depvar_mean_std = 1;
   lopts.get_indep_mean_std = xnmalloc (n_indep, sizeof (int));
 
-  lcache = pspp_linreg_cache_alloc (n_data, n_indep);
-  lcache->indep_means = gsl_vector_alloc (n_indep);
-  lcache->indep_std = gsl_vector_alloc (n_indep);
 
   /*
      Read from the active file. The first pass encodes categorical
-     variables.
+     variables and drops cases with missing values.
    */
-  ca = cr_recoded_cat_ar_create (cmd.n_variables, cmd.v_variables);
-  for (r = casefile_get_reader (cf);
-       casereader_read (r, &c); case_destroy (&c))
+  j = 0;
+  for (i = 0; i < cmd.n_variables; i++)
     {
-      for (i = 0; i < ca->n_vars; i++)
+      if (!is_depvar (i))
        {
-         v = (*(ca->a + i))->v;
-         val = case_data (&c, v->fv);
-         cr_value_update (*(ca->a + i), val);
+         v = cmd.v_variables[i];
+         indep_vars[j] = v;
+         j++;
+         if (v->type == ALPHA)
+           {
+             /* Make a place to hold the binary vectors 
+                corresponding to this variable's values. */
+             cat_stored_values_create (v);
+           }
+         for (r = casefile_get_reader (cf);
+              casereader_read (r, &c); case_destroy (&c))
+           {
+             row = casereader_cnum (r) - 1;
+             
+             val = case_data (&c, v->fv);
+             cat_value_update (v, val);
+             if (mv_is_value_missing (&v->miss, val))
+               {
+                 if (!is_missing_case[row])
+                   {
+                     /* Now it is missing. */
+                     n_data--;
+                     is_missing_case[row] = 1;
+                   }
+               }
+           }
        }
     }
-  cr_create_value_matrices (ca);
+
+  Y = gsl_vector_alloc (n_data);
   X =
-    design_matrix_create (n_indep, (const struct variable **) cmd.v_variables,
-                         ca, n_data);
+    design_matrix_create (n_indep, (const struct variable **) indep_vars,
+                         n_data);
+  lcache = pspp_linreg_cache_alloc (X->m->size1, X->m->size2);
+  lcache->indep_means = gsl_vector_alloc (X->m->size2);
+  lcache->indep_std = gsl_vector_alloc (X->m->size2);
 
   /*
      The second pass creates the design matrix.
    */
+  row = 0;
   for (r2 = casefile_get_reader (cf); casereader_read (r2, &c);
        case_destroy (&c))
     /* Iterate over the cases. */
     {
-      k = 0;
-      row = casereader_cnum (r2) - 1;
-      for (i = 0; i < cmd.n_variables; ++i)    /* Iterate over the variables
+      case_num = casereader_cnum (r2) - 1;
+      if (!is_missing_case[case_num])
+       {
+         for (i = 0; i < cmd.n_variables; ++i) /* Iterate over the variables
                                                   for the current case. 
                                                 */
-       {
-         v = cmd.v_variables[i];
-         val = case_data (&c, v->fv);
-         /*
-            Independent/dependent variable separation. The
-            'variables' subcommand specifies a varlist which contains
-            both dependent and independent variables. The dependent
-            variables are specified with the 'dependent'
-            subcommand. We need to separate the two.
-          */
-         if (is_depvar (i))
-           {
-             if (v->type != NUMERIC)
-               {
-                 msg (SE, gettext ("Dependent variable must be numeric."));
-                 pspp_reg_rc = CMD_FAILURE;
-                 return;
-               }
-             lcache->depvar = (const struct var *) v;
-             gsl_vector_set (Y, row, val->f);
-           }
-         else
            {
-             if (v->type == ALPHA)
+             v = cmd.v_variables[i];
+             val = case_data (&c, v->fv);
+             /*
+                Independent/dependent variable separation. The
+                'variables' subcommand specifies a varlist which contains
+                both dependent and independent variables. The dependent
+                variables are specified with the 'dependent'
+                subcommand. We need to separate the two.
+              */
+             if (is_depvar (i))
                {
-                 rc = cr_var_to_recoded_categorical (v, ca);
-                 design_matrix_set_categorical (X, row, v, val, rc);
+                 if (v->type != NUMERIC)
+                   {
+                     msg (SE,
+                          gettext ("Dependent variable must be numeric."));
+                     pspp_reg_rc = CMD_FAILURE;
+                     return;
+                   }
+                 lcache->depvar = (const struct variable *) v;
+                 gsl_vector_set (Y, row, val->f);
                }
-             else if (v->type == NUMERIC)
+             else
                {
-                 design_matrix_set_numeric (X, row, v, val);
+                 if (v->type == ALPHA)
+                   {
+                     design_matrix_set_categorical (X, row, v, val);
+                   }
+                 else if (v->type == NUMERIC)
+                   {
+                     design_matrix_set_numeric (X, row, v, val);
+                   }
+
+                 lopts.get_indep_mean_std[i] = 1;
                }
-
-             indep_vars[k] = i;
-             k++;
-             lopts.get_indep_mean_std[i] = 1;
            }
+         row++;
        }
     }
   /*
@@ -608,17 +720,27 @@ run_regression (const struct casefile *cf, void *cmd_ UNUSED)
       j = i + 1;               /* The first coeff is the intercept. */
       lcache->coeff[j].v =
        (const struct variable *) design_matrix_col_to_var (X, i);
+      assert (lcache->coeff[j].v != NULL);
+    }
+  /*
+    For large data sets, use QR decomposition.
+   */
+  if (n_data > sqrt (n_indep) && n_data > REG_LARGE_DATA)
+    {
+      lcache->method = PSPP_LINREG_SVD;
     }
   /* 
      Find the least-squares estimates and other statistics.
    */
   pspp_linreg ((const gsl_vector *) Y, X->m, &lopts, lcache);
   subcommand_statistics (cmd.a_statistics, lcache);
+  subcommand_export (cmd.sbc_export, lcache);
   gsl_vector_free (Y);
   design_matrix_destroy (X);
   pspp_linreg_cache_free (lcache);
   free (lopts.get_indep_mean_std);
   free (indep_vars);
+  free (is_missing_case);
   casereader_destroy (r);
   return;
 }