X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fglm.c;h=e4b3c17b21bb66ec4f46a30a52114668059cd90b;hb=983dc88647eb2826dd866c8109cf3968ce1e79a9;hp=f5feab0e369eaae1541288789b54408bac14b82f;hpb=ec6f62cd6df384f06c1de6ed8a02dbeceafcd633;p=pspp diff --git a/src/language/stats/glm.c b/src/language/stats/glm.c index f5feab0e36..e4b3c17b21 100644 --- a/src/language/stats/glm.c +++ b/src/language/stats/glm.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -18,6 +18,7 @@ #include #include +#include #include #include "data/case.h" @@ -32,6 +33,7 @@ #include "language/lexer/lexer.h" #include "language/lexer/value-parser.h" #include "language/lexer/variable-parser.h" +#include "libpspp/assertion.h" #include "libpspp/ll.h" #include "libpspp/message.h" #include "libpspp/misc.h" @@ -39,6 +41,7 @@ #include "linreg/sweep.h" #include "math/categoricals.h" #include "math/covariance.h" +#include "math/interaction.h" #include "math/moments.h" #include "output/tab.h" @@ -53,13 +56,8 @@ struct glm_spec size_t n_factor_vars; const struct variable **factor_vars; - /* In the current implementation, design_vars will - normally be the same as factor_vars. - This will change once interactions, nested variables - and repeated measures become involved. - */ - size_t n_design_vars; - const struct variable **design_vars; + size_t n_interactions; + struct interaction **interactions; enum mv_class exclude; @@ -68,9 +66,12 @@ struct glm_spec const struct dictionary *dict; + int ss_type; bool intercept; double alpha; + + bool dump_coding; }; struct glm_workspace @@ -88,6 +89,37 @@ struct glm_workspace gsl_vector *ssq; }; + +/* Default design: all possible interactions */ +static void +design_full (struct glm_spec *glm) +{ + int sz; + int i = 0; + glm->n_interactions = (1 << glm->n_factor_vars) - 1; + + glm->interactions = xcalloc (glm->n_interactions, sizeof *glm->interactions); + + /* All subsets, with exception of the empty set, of [0, glm->n_factor_vars) */ + for (sz = 1; sz <= glm->n_factor_vars; ++sz) + { + gsl_combination *c = gsl_combination_calloc (glm->n_factor_vars, sz); + + do + { + struct interaction *iact = interaction_create (NULL); + int e; + for (e = 0 ; e < gsl_combination_k (c); ++e) + interaction_add_variable (iact, glm->factor_vars [gsl_combination_get (c, e)]); + + glm->interactions[i++] = iact; + } + while (gsl_combination_next (c) == GSL_SUCCESS); + + gsl_combination_free (c); + } +} + static void output_glm (const struct glm_spec *, const struct glm_workspace *ws); static void run_glm (struct glm_spec *cmd, struct casereader *input, @@ -100,20 +132,23 @@ static bool parse_design_spec (struct lexer *lexer, struct glm_spec *glm); int cmd_glm (struct lexer *lexer, struct dataset *ds) { + int i; struct const_var_set *factors = NULL; struct glm_spec glm; bool design = false; glm.dict = dataset_dict (ds); glm.n_dep_vars = 0; glm.n_factor_vars = 0; - glm.n_design_vars = 0; + glm.n_interactions = 0; + glm.interactions = NULL; glm.dep_vars = NULL; glm.factor_vars = NULL; - glm.design_vars = NULL; glm.exclude = MV_ANY; glm.intercept = true; glm.wv = dict_get_weight (glm.dict); glm.alpha = 0.05; + glm.dump_coding = false; + glm.ss_type = 3; if (!parse_variables_const (lexer, glm.dict, &glm.dep_vars, &glm.n_dep_vars, @@ -231,9 +266,10 @@ cmd_glm (struct lexer *lexer, struct dataset *ds) goto error; } - if (3 != lex_integer (lexer)) + glm.ss_type = lex_integer (lexer); + if (1 > glm.ss_type || 3 < glm.ss_type ) { - msg (ME, _("Only type 3 sum of squares are currently implemented")); + msg (ME, _("Only types 1, 2 & 3 sums of squares are currently implemented")); goto error; } @@ -251,14 +287,16 @@ cmd_glm (struct lexer *lexer, struct dataset *ds) if (! parse_design_spec (lexer, &glm)) goto error; - - if ( glm.n_design_vars == 0) - { - msg (ME, _("One or more design variables must be given")); - goto error; - } - - design = true; + + if (glm.n_interactions > 0) + design = true; + } + else if (lex_match_id (lexer, "SHOWCODES")) + /* Undocumented debug option */ + { + lex_match (lexer, T_EQUALS); + + glm.dump_coding = true; } else { @@ -269,8 +307,7 @@ cmd_glm (struct lexer *lexer, struct dataset *ds) if ( ! design ) { - lex_error (lexer, _("/DESIGN is mandatory in GLM")); - goto error; + design_full (&glm); } { @@ -287,7 +324,10 @@ cmd_glm (struct lexer *lexer, struct dataset *ds) const_var_set_destroy (factors); free (glm.factor_vars); - free (glm.design_vars); + for (i = 0 ; i < glm.n_interactions; ++i) + interaction_destroy (glm.interactions[i]); + + free (glm.interactions); free (glm.dep_vars); @@ -297,90 +337,239 @@ error: const_var_set_destroy (factors); free (glm.factor_vars); - free (glm.design_vars); + for (i = 0 ; i < glm.n_interactions; ++i) + interaction_destroy (glm.interactions[i]); + + free (glm.interactions); free (glm.dep_vars); return CMD_FAILURE; } -static void get_ssq (struct covariance *, gsl_vector *, - const struct glm_spec *); +static inline bool +not_dropped (size_t j, const bool *ff) +{ + return ! ff[j]; +} -static bool -not_dropped (size_t j, size_t * dropped, size_t n_dropped) +static void +fill_submatrix (const gsl_matrix * cov, gsl_matrix * submatrix, bool *dropped_f) { size_t i; - - for (i = 0; i < n_dropped; i++) + size_t j; + size_t n = 0; + size_t m = 0; + + for (i = 0; i < cov->size1; i++) { - if (j == dropped[i]) - return false; + if (not_dropped (i, dropped_f)) + { + m = 0; + for (j = 0; j < cov->size2; j++) + { + if (not_dropped (j, dropped_f)) + { + gsl_matrix_set (submatrix, n, m, + gsl_matrix_get (cov, i, j)); + m++; + } + } + n++; + } } - return true; } + +/* + Type 1 sums of squares. + Populate SSQ with the Type 1 sums of squares according to COV + */ static void -get_ssq (struct covariance *cov, gsl_vector * ssq, const struct glm_spec *cmd) +ssq_type1 (struct covariance *cov, gsl_vector *ssq, const struct glm_spec *cmd) { - const struct variable **vars; - gsl_matrix *small_cov = NULL; - gsl_matrix *cm = covariance_calculate_unnormalized (cov); + const gsl_matrix *cm = covariance_calculate_unnormalized (cov); size_t i; - size_t j; size_t k; - size_t n; - size_t m; - size_t *dropped; - size_t n_dropped; + bool *model_dropped = xcalloc (covariance_dim (cov), sizeof (*model_dropped)); + bool *submodel_dropped = xcalloc (covariance_dim (cov), sizeof (*submodel_dropped)); + const struct categoricals *cats = covariance_get_categoricals (cov); - dropped = xcalloc (covariance_dim (cov), sizeof (*dropped)); - vars = xcalloc (covariance_dim (cov), sizeof (*vars)); - covariance_get_var_indices (cov, vars); + size_t n_dropped_model = 0; + size_t n_dropped_submodel = 0; - for (k = 0; k < cmd->n_design_vars; k++) + for (i = cmd->n_dep_vars; i < covariance_dim (cov); i++) { - n_dropped = 0; - for (i = 1; i < covariance_dim (cov); i++) + n_dropped_model++; + n_dropped_submodel++; + model_dropped[i] = true; + submodel_dropped[i] = true; + } + + for (k = 0; k < cmd->n_interactions; k++) + { + gsl_matrix *model_cov = NULL; + gsl_matrix *submodel_cov = NULL; + + n_dropped_submodel = n_dropped_model; + for (i = cmd->n_dep_vars; i < covariance_dim (cov); i++) + { + submodel_dropped[i] = model_dropped[i]; + } + + for (i = cmd->n_dep_vars; i < covariance_dim (cov); i++) { - if (vars[i] == cmd->design_vars[k]) + const struct interaction * x = + categoricals_get_interaction_by_subscript (cats, i - cmd->n_dep_vars); + + if ( x == cmd->interactions [k]) { - dropped[n_dropped++] = i; + model_dropped[i] = false; + n_dropped_model--; } } - small_cov = - gsl_matrix_alloc (cm->size1 - n_dropped, cm->size2 - n_dropped); - gsl_matrix_set (small_cov, 0, 0, gsl_matrix_get (cm, 0, 0)); - n = 0; - m = 0; - for (i = 0; i < cm->size1; i++) + + model_cov = gsl_matrix_alloc (cm->size1 - n_dropped_model, cm->size2 - n_dropped_model); + submodel_cov = gsl_matrix_alloc (cm->size1 - n_dropped_submodel, cm->size2 - n_dropped_submodel); + + fill_submatrix (cm, model_cov, model_dropped); + fill_submatrix (cm, submodel_cov, submodel_dropped); + + reg_sweep (model_cov, 0); + reg_sweep (submodel_cov, 0); + + gsl_vector_set (ssq, k + 1, + gsl_matrix_get (submodel_cov, 0, 0) - gsl_matrix_get (model_cov, 0, 0) + ); + + gsl_matrix_free (model_cov); + gsl_matrix_free (submodel_cov); + } + + free (model_dropped); + free (submodel_dropped); +} + +/* + Type 2 sums of squares. + Populate SSQ with the Type 2 sums of squares according to COV + */ +static void +ssq_type2 (struct covariance *cov, gsl_vector *ssq, const struct glm_spec *cmd) +{ + const gsl_matrix *cm = covariance_calculate_unnormalized (cov); + size_t i; + size_t k; + bool *model_dropped = xcalloc (covariance_dim (cov), sizeof (*model_dropped)); + bool *submodel_dropped = xcalloc (covariance_dim (cov), sizeof (*submodel_dropped)); + const struct categoricals *cats = covariance_get_categoricals (cov); + + for (k = 0; k < cmd->n_interactions; k++) + { + gsl_matrix *model_cov = NULL; + gsl_matrix *submodel_cov = NULL; + size_t n_dropped_model = 0; + size_t n_dropped_submodel = 0; + for (i = cmd->n_dep_vars; i < covariance_dim (cov); i++) { - if (not_dropped (i, dropped, n_dropped)) + const struct interaction * x = + categoricals_get_interaction_by_subscript (cats, i - cmd->n_dep_vars); + + model_dropped[i] = false; + submodel_dropped[i] = false; + if (interaction_is_subset (cmd->interactions [k], x)) { - m = 0; - for (j = 0; j < cm->size2; j++) + assert (n_dropped_submodel < covariance_dim (cov)); + n_dropped_submodel++; + submodel_dropped[i] = true; + + if ( cmd->interactions [k]->n_vars < x->n_vars) { - if (not_dropped (j, dropped, n_dropped)) - { - gsl_matrix_set (small_cov, n, m, - gsl_matrix_get (cm, i, j)); - m++; - } + assert (n_dropped_model < covariance_dim (cov)); + n_dropped_model++; + model_dropped[i] = true; } - n++; } } - reg_sweep (small_cov, 0); + + model_cov = gsl_matrix_alloc (cm->size1 - n_dropped_model, cm->size2 - n_dropped_model); + submodel_cov = gsl_matrix_alloc (cm->size1 - n_dropped_submodel, cm->size2 - n_dropped_submodel); + + fill_submatrix (cm, model_cov, model_dropped); + fill_submatrix (cm, submodel_cov, submodel_dropped); + + reg_sweep (model_cov, 0); + reg_sweep (submodel_cov, 0); + gsl_vector_set (ssq, k + 1, - gsl_matrix_get (small_cov, 0, 0) - - gsl_vector_get (ssq, 0)); - gsl_matrix_free (small_cov); + gsl_matrix_get (submodel_cov, 0, 0) - gsl_matrix_get (model_cov, 0, 0) + ); + + gsl_matrix_free (model_cov); + gsl_matrix_free (submodel_cov); } - free (dropped); - free (vars); - gsl_matrix_free (cm); + free (model_dropped); + free (submodel_dropped); +} + +/* + Type 3 sums of squares. + Populate SSQ with the Type 2 sums of squares according to COV + */ +static void +ssq_type3 (struct covariance *cov, gsl_vector *ssq, const struct glm_spec *cmd) +{ + const gsl_matrix *cm = covariance_calculate_unnormalized (cov); + size_t i; + size_t k; + bool *model_dropped = xcalloc (covariance_dim (cov), sizeof (*model_dropped)); + bool *submodel_dropped = xcalloc (covariance_dim (cov), sizeof (*submodel_dropped)); + const struct categoricals *cats = covariance_get_categoricals (cov); + + double ss0; + gsl_matrix *submodel_cov = gsl_matrix_alloc (cm->size1, cm->size2); + fill_submatrix (cm, submodel_cov, submodel_dropped); + reg_sweep (submodel_cov, 0); + ss0 = gsl_matrix_get (submodel_cov, 0, 0); + gsl_matrix_free (submodel_cov); + free (submodel_dropped); + + for (k = 0; k < cmd->n_interactions; k++) + { + gsl_matrix *model_cov = NULL; + size_t n_dropped_model = 0; + + for (i = cmd->n_dep_vars; i < covariance_dim (cov); i++) + { + const struct interaction * x = + categoricals_get_interaction_by_subscript (cats, i - cmd->n_dep_vars); + + model_dropped[i] = false; + + if ( cmd->interactions [k] == x) + { + assert (n_dropped_model < covariance_dim (cov)); + n_dropped_model++; + model_dropped[i] = true; + } + } + + model_cov = gsl_matrix_alloc (cm->size1 - n_dropped_model, cm->size2 - n_dropped_model); + + fill_submatrix (cm, model_cov, model_dropped); + + reg_sweep (model_cov, 0); + + gsl_vector_set (ssq, k + 1, + gsl_matrix_get (model_cov, 0, 0) - ss0); + + gsl_matrix_free (model_cov); + } + free (model_dropped); } + + //static void dump_matrix (const gsl_matrix *m); static void @@ -396,9 +585,9 @@ run_glm (struct glm_spec *cmd, struct casereader *input, struct glm_workspace ws; struct covariance *cov; - ws.cats = categoricals_create (cmd->design_vars, cmd->n_design_vars, - cmd->wv, cmd->exclude, - NULL, NULL, NULL, NULL); + + ws.cats = categoricals_create (cmd->interactions, cmd->n_interactions, + cmd->wv, cmd->exclude, MV_ANY); cov = covariance_2pass_create (cmd->n_dep_vars, cmd->dep_vars, ws.cats, cmd->wv, cmd->exclude); @@ -430,9 +619,12 @@ run_glm (struct glm_spec *cmd, struct casereader *input, } casereader_destroy (reader); - categoricals_done (ws.cats); + if (cmd->dump_coding) + reader = casereader_clone (input); + else + reader = input; - for (reader = input; + for (; (c = casereader_read (reader)) != NULL; case_unref (c)) { double weight = dict_get_case_weight (dict, c, &warn_bad_weight); @@ -445,8 +637,25 @@ run_glm (struct glm_spec *cmd, struct casereader *input, } casereader_destroy (reader); + + if (cmd->dump_coding) + { + struct tab_table *t = + covariance_dump_enc_header (cov, + 1 + casereader_count_cases (input)); + for (reader = input; + (c = casereader_read (reader)) != NULL; case_unref (c)) + { + covariance_dump_enc (cov, c, t); + } + casereader_destroy (reader); + tab_submit (t); + } + { - gsl_matrix *cm = covariance_calculate_unnormalized (cov); + const gsl_matrix *ucm = covariance_calculate_unnormalized (cov); + gsl_matrix *cm = gsl_matrix_alloc (ucm->size1, ucm->size2); + gsl_matrix_memcpy (cm, ucm); // dump_matrix (cm); @@ -455,13 +664,26 @@ run_glm (struct glm_spec *cmd, struct casereader *input, reg_sweep (cm, 0); /* - Store the overall SSE. - */ + Store the overall SSE. + */ ws.ssq = gsl_vector_alloc (cm->size1); gsl_vector_set (ws.ssq, 0, gsl_matrix_get (cm, 0, 0)); - get_ssq (cov, ws.ssq, cmd); + switch (cmd->ss_type) + { + case 1: + ssq_type1 (cov, ws.ssq, cmd); + break; + case 2: + ssq_type2 (cov, ws.ssq, cmd); + break; + case 3: + ssq_type3 (cov, ws.ssq, cmd); + break; + default: + NOT_REACHED (); + break; + } // dump_matrix (cm); - gsl_matrix_free (cm); } @@ -476,14 +698,25 @@ run_glm (struct glm_spec *cmd, struct casereader *input, taint_destroy (taint); } +static const char *roman[] = + { + "", /* The Romans had no concept of zero */ + "I", + "II", + "III", + "IV" + }; + static void output_glm (const struct glm_spec *cmd, const struct glm_workspace *ws) { const struct fmt_spec *wfmt = cmd->wv ? var_get_print_format (cmd->wv) : &F_8_0; + double intercept_ssq; + double ssq_effects; double n_total, mean; - double df_corr = 0.0; + double df_corr = 1.0; double mse = 0; int f; @@ -493,11 +726,13 @@ output_glm (const struct glm_spec *cmd, const struct glm_workspace *ws) struct tab_table *t; const int nc = 6; - int nr = heading_rows + 4 + cmd->n_design_vars; + int nr = heading_rows + 3 + cmd->n_interactions; if (cmd->intercept) - nr++; + nr += 2; + msg (MW, "GLM is experimental. Do not rely on these results."); t = tab_create (nc, nr); + tab_set_format (t, RC_WEIGHT, wfmt); tab_title (t, _("Tests of Between-Subjects Effects")); tab_headers (t, heading_columns, 0, heading_rows, 0); @@ -511,7 +746,8 @@ output_glm (const struct glm_spec *cmd, const struct glm_workspace *ws) /* TRANSLATORS: The parameter is a roman numeral */ tab_text_format (t, 1, 0, TAB_CENTER | TAT_TITLE, - _("Type %s Sum of Squares"), "III"); + _("Type %s Sum of Squares"), + roman[cmd->ss_type]); tab_text (t, 2, 0, TAB_CENTER | TAT_TITLE, _("df")); tab_text (t, 3, 0, TAB_CENTER | TAT_TITLE, _("Mean Square")); tab_text (t, 4, 0, TAB_CENTER | TAT_TITLE, _("F")); @@ -519,66 +755,85 @@ output_glm (const struct glm_spec *cmd, const struct glm_workspace *ws) moments_calculate (ws->totals, &n_total, &mean, NULL, NULL, NULL); + df_corr += categoricals_df_total (ws->cats); + + r = heading_rows; if (cmd->intercept) - df_corr += 1.0; + tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Corrected Model")); + else + tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Model")); - for (f = 0; f < cmd->n_design_vars; ++f) - df_corr += categoricals_n_count (ws->cats, f) - 1.0; + r++; mse = gsl_vector_get (ws->ssq, 0) / (n_total - df_corr); - r = heading_rows; - tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Corrected Model")); - - r++; + intercept_ssq = pow2 (mean * n_total) / n_total; + ssq_effects = 0.0; if (cmd->intercept) { - const double intercept = pow2 (mean * n_total) / n_total; const double df = 1.0; - const double F = intercept / df / mse; + const double F = intercept_ssq / df / mse; tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Intercept")); - tab_double (t, 1, r, 0, intercept, NULL); - tab_double (t, 2, r, 0, 1.00, wfmt); - tab_double (t, 3, r, 0, intercept / df, NULL); - tab_double (t, 4, r, 0, F, NULL); + tab_double (t, 1, r, 0, intercept_ssq, NULL, RC_OTHER); + tab_double (t, 2, r, 0, 1.00, NULL, RC_WEIGHT); + tab_double (t, 3, r, 0, intercept_ssq / df, NULL, RC_OTHER); + tab_double (t, 4, r, 0, F, NULL, RC_OTHER); tab_double (t, 5, r, 0, gsl_cdf_fdist_Q (F, df, n_total - df_corr), - NULL); + NULL, RC_PVALUE); r++; } - for (f = 0; f < cmd->n_design_vars; ++f) + for (f = 0; f < cmd->n_interactions; ++f) { - const double df = categoricals_n_count (ws->cats, f) - 1.0; - const double ssq = gsl_vector_get (ws->ssq, f + 1); - const double F = ssq / df / mse; - tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, - var_to_string (cmd->design_vars[f])); + struct string str = DS_EMPTY_INITIALIZER; + double df = categoricals_df (ws->cats, f); - tab_double (t, 1, r, 0, ssq, NULL); - tab_double (t, 2, r, 0, df, wfmt); - tab_double (t, 3, r, 0, ssq / df, NULL); - tab_double (t, 4, r, 0, F, NULL); + double ssq = gsl_vector_get (ws->ssq, f + 1); + double F; - tab_double (t, 5, r, 0, gsl_cdf_fdist_Q (F, df, n_total - df_corr), - NULL); + ssq_effects += ssq; + if (! cmd->intercept) + { + df++; + ssq += intercept_ssq; + } + F = ssq / df / mse; + interaction_to_string (cmd->interactions[f], &str); + tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, ds_cstr (&str)); + ds_destroy (&str); + + tab_double (t, 1, r, 0, ssq, NULL, RC_OTHER); + tab_double (t, 2, r, 0, df, NULL, RC_WEIGHT); + tab_double (t, 3, r, 0, ssq / df, NULL, RC_OTHER); + tab_double (t, 4, r, 0, F, NULL, RC_OTHER); + + tab_double (t, 5, r, 0, gsl_cdf_fdist_Q (F, df, n_total - df_corr), + NULL, RC_PVALUE); r++; } { - /* Corrected Model */ - const double df = df_corr - 1.0; - const double ssq = ws->total_ssq - gsl_vector_get (ws->ssq, 0); - const double F = ssq / df / mse; - tab_double (t, 1, heading_rows, 0, ssq, NULL); - tab_double (t, 2, heading_rows, 0, df, wfmt); - tab_double (t, 3, heading_rows, 0, ssq / df, NULL); - tab_double (t, 4, heading_rows, 0, F, NULL); + /* Model / Corrected Model */ + double df = df_corr; + double ssq = ws->total_ssq - gsl_vector_get (ws->ssq, 0); + double F; + + if ( cmd->intercept ) + df --; + else + ssq += intercept_ssq; + + F = ssq / df / mse; + tab_double (t, 1, heading_rows, 0, ssq, NULL, RC_OTHER); + tab_double (t, 2, heading_rows, 0, df, NULL, RC_WEIGHT); + tab_double (t, 3, heading_rows, 0, ssq / df, NULL, RC_OTHER); + tab_double (t, 4, heading_rows, 0, F, NULL, RC_OTHER); tab_double (t, 5, heading_rows, 0, - gsl_cdf_fdist_Q (F, df, n_total - df_corr), NULL); + gsl_cdf_fdist_Q (F, df, n_total - df_corr), NULL, RC_PVALUE); } { @@ -586,29 +841,26 @@ output_glm (const struct glm_spec *cmd, const struct glm_workspace *ws) const double ssq = gsl_vector_get (ws->ssq, 0); const double mse = ssq / df; tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Error")); - tab_double (t, 1, r, 0, ssq, NULL); - tab_double (t, 2, r, 0, df, wfmt); - tab_double (t, 3, r++, 0, mse, NULL); + tab_double (t, 1, r, 0, ssq, NULL, RC_OTHER); + tab_double (t, 2, r, 0, df, NULL, RC_WEIGHT); + tab_double (t, 3, r++, 0, mse, NULL, RC_OTHER); + } + + { + tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Total")); + tab_double (t, 1, r, 0, ws->total_ssq + intercept_ssq, NULL, RC_OTHER); + tab_double (t, 2, r, 0, n_total, NULL, RC_WEIGHT); + + r++; } if (cmd->intercept) { - const double intercept = pow2 (mean * n_total) / n_total; - const double ssq = intercept + ws->total_ssq; - - tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Total")); - tab_double (t, 1, r, 0, ssq, NULL); - tab_double (t, 2, r, 0, n_total, wfmt); - - r++; + tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Corrected Total")); + tab_double (t, 1, r, 0, ws->total_ssq, NULL, RC_OTHER); + tab_double (t, 2, r, 0, n_total - 1.0, NULL, RC_WEIGHT); } - tab_text (t, 0, r, TAB_LEFT | TAT_TITLE, _("Corrected Total")); - - - tab_double (t, 1, r, 0, ws->total_ssq, NULL); - tab_double (t, 2, r, 0, n_total - 1.0, wfmt); - tab_submit (t); } @@ -632,58 +884,42 @@ dump_matrix (const gsl_matrix * m) - -/* Match a variable. - If the match succeeds, the variable will be placed in VAR. - Returns true if successful */ static bool -lex_match_variable (struct lexer *lexer, const struct glm_spec *glm, const struct variable **var) -{ - if (lex_token (lexer) != T_ID) - return false; - - *var = parse_variable_const (lexer, glm->dict); - - if ( *var == NULL) - return false; - return true; -} - -/* An interaction is a variable followed by {*, BY} followed by an interaction */ -static bool -parse_design_interaction (struct lexer *lexer, struct glm_spec *glm) +parse_nested_variable (struct lexer *lexer, struct glm_spec *glm) { const struct variable *v = NULL; - if (! lex_match_variable (lexer, glm, &v)) + if ( ! lex_match_variable (lexer, glm->dict, &v)) return false; - if ( lex_match (lexer, T_ASTERISK) || lex_match (lexer, T_BY)) + if (lex_match (lexer, T_LPAREN)) { - lex_error (lexer, "Interactions are not yet implemented"); return false; - return parse_design_interaction (lexer, glm); - } + if ( ! parse_nested_variable (lexer, glm)) + return false; - glm->n_design_vars++; - glm->design_vars = xrealloc (glm->design_vars, sizeof (*glm->design_vars) * glm->n_design_vars); - glm->design_vars[glm->n_design_vars - 1] = v; + if ( ! lex_force_match (lexer, T_RPAREN)) + return false; + } + lex_error (lexer, "Nested variables are not yet implemented"); return false; return true; } -/* A design term is a varible OR an interaction */ +/* A design term is an interaction OR a nested variable */ static bool parse_design_term (struct lexer *lexer, struct glm_spec *glm) { - const struct variable *v = NULL; - if (parse_design_interaction (lexer, glm)) - return true; - - /* FIXME: This should accept nexted variables */ - if ( lex_match_variable (lexer, glm, &v)) + struct interaction *iact = NULL; + if (parse_design_interaction (lexer, glm->dict, &iact)) { + /* Interaction parsing successful. Add to list of interactions */ + glm->interactions = xrealloc (glm->interactions, sizeof *glm->interactions * ++glm->n_interactions); + glm->interactions[glm->n_interactions - 1] = iact; return true; } + if ( parse_nested_variable (lexer, glm)) + return true; + return false; } @@ -696,7 +932,6 @@ parse_design_term (struct lexer *lexer, struct glm_spec *glm) static bool parse_design_spec (struct lexer *lexer, struct glm_spec *glm) { - /* Kludge: Return success if end of design spec */ if (lex_token (lexer) == T_ENDCMD || lex_token (lexer) == T_SLASH) return true;