--- /dev/null
+/*
+ PSPP - a program for statistical analysis.
+ Copyright (C) 2012, 2013, 2016, 2019 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <config.h>
+
+#include <math.h>
+#include <gsl/gsl_cdf.h>
+
+#include "data/casegrouper.h"
+#include "data/caseproto.h"
+#include "data/casereader.h"
+#include "data/casewriter.h"
+#include "data/dataset.h"
+#include "data/dictionary.h"
+#include "data/format.h"
+#include "data/subcase.h"
+#include "language/command.h"
+#include "language/lexer/lexer.h"
+#include "language/lexer/value-parser.h"
+#include "language/lexer/variable-parser.h"
+#include "libpspp/assertion.h"
+#include "libpspp/message.h"
+#include "libpspp/pool.h"
+#include "math/box-whisker.h"
+#include "math/categoricals.h"
+#include "math/chart-geometry.h"
+#include "math/histogram.h"
+#include "math/interaction.h"
+#include "math/moments.h"
+#include "math/np.h"
+#include "math/order-stats.h"
+#include "math/percentiles.h"
+#include "math/shapiro-wilk.h"
+#include "math/sort.h"
+#include "math/trimmed-mean.h"
+#include "math/tukey-hinges.h"
+#include "output/charts/boxplot.h"
+#include "output/charts/np-plot.h"
+#include "output/charts/plot-hist.h"
+#include "output/charts/spreadlevel-plot.h"
+#include "output/pivot-table.h"
+
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+#define N_(msgid) msgid
+
+static void
+append_value_name (const struct variable *var, const union value *val, struct string *str)
+{
+ var_append_value_name (var, val, str);
+ if (var_is_value_missing (var, val))
+ ds_put_cstr (str, _(" (missing)"));
+}
+
+enum bp_mode
+ {
+ BP_GROUPS,
+ BP_VARIABLES
+ };
+
+/* Indices for the ex_proto member (below) */
+enum
+ {
+ EX_VAL, /* value */
+ EX_ID, /* identity */
+ EX_WT /* weight */
+ };
+
+
+struct examine
+{
+ struct pool *pool;
+
+ /* A caseproto used to contain the data subsets under examination,
+ see (enum above) */
+ struct caseproto *ex_proto;
+
+ size_t n_dep_vars;
+ const struct variable **dep_vars;
+
+ size_t n_iacts;
+ struct interaction **iacts;
+
+ enum mv_class dep_excl;
+ enum mv_class fctr_excl;
+
+ const struct dictionary *dict;
+
+ struct categoricals *cats;
+
+ /* how many extremities to display */
+ int disp_extremes;
+ int calc_extremes;
+ bool descriptives;
+
+ double conf;
+
+ bool missing_pw;
+
+ /* The case index of the ID value (or -1) if not applicable */
+ size_t id_idx;
+ int id_width;
+
+ enum pc_alg pc_alg;
+ double *ptiles;
+ size_t n_percentiles;
+
+ bool plot_histogram;
+ bool plot_boxplot;
+ bool plot_npplot;
+ bool plot_spreadlevel;
+ float sl_power;
+
+ enum bp_mode boxplot_mode;
+
+ const struct variable *id_var;
+
+ const struct variable *wv;
+};
+
+struct extremity
+{
+ /* The value of this extremity */
+ double val;
+
+ /* Either the casenumber or the value of the variable specified
+ by the /ID subcommand which corresponds to this extremity */
+ union value identity;
+};
+
+struct exploratory_stats
+{
+ double missing;
+ double non_missing;
+
+ struct moments *mom;
+
+ /* Most operations need a sorted reader/writer */
+ struct casewriter *sorted_writer;
+ struct casereader *sorted_reader;
+
+ struct extremity *minima;
+ struct extremity *maxima;
+
+ /*
+ Minimum should alway equal mimima[0].val.
+ Likewise, maximum should alway equal maxima[0].val.
+ This redundancy exists as an optimisation effort.
+ Some statistics (eg histogram) require early calculation
+ of the min and max
+ */
+ double minimum;
+ double maximum;
+
+ struct trimmed_mean *trimmed_mean;
+ struct percentile *quartiles[3];
+ struct percentile **percentiles;
+ struct shapiro_wilk *shapiro_wilk;
+
+ struct tukey_hinges *hinges;
+
+ /* The data for the NP Plots */
+ struct np *np;
+
+ struct histogram *histogram;
+
+ /* The data for the box plots */
+ struct box_whisker *box_whisker;
+
+ /* Total weight */
+ double cc;
+
+ /* The minimum weight */
+ double cmin;
+};
+
+static void
+show_boxplot_grouped (const struct examine *cmd, int iact_idx)
+{
+ int v;
+
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ const size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ double y_min = DBL_MAX;
+ double y_max = -DBL_MAX;
+ int grp;
+ struct boxplot *boxplot;
+ struct string title;
+ ds_init_empty (&title);
+
+ if (iact->n_vars > 0)
+ {
+ struct string istr;
+ ds_init_empty (&istr);
+ interaction_to_string (iact, &istr);
+ ds_put_format (&title, _("Boxplot of %s vs. %s"),
+ var_to_string (cmd->dep_vars[v]),
+ ds_cstr (&istr));
+ ds_destroy (&istr);
+ }
+ else
+ ds_put_format (&title, _("Boxplot of %s"), var_to_string (cmd->dep_vars[v]));
+
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ const struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ if (y_min > es[v].minimum)
+ y_min = es[v].minimum;
+
+ if (y_max < es[v].maximum)
+ y_max = es[v].maximum;
+ }
+
+ boxplot = boxplot_create (y_min, y_max, ds_cstr (&title));
+
+ ds_destroy (&title);
+
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ int ivar_idx;
+ struct string label;
+
+ const struct ccase *c =
+ categoricals_get_case_by_category_real (cmd->cats, iact_idx, grp);
+
+ struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ ds_init_empty (&label);
+ for (ivar_idx = 0; ivar_idx < iact->n_vars; ++ivar_idx)
+ {
+ struct string l;
+ const struct variable *ivar = iact->vars[ivar_idx];
+ const union value *val = case_data (c, ivar);
+ ds_init_empty (&l);
+
+ append_value_name (ivar, val, &l);
+ ds_ltrim (&l, ss_cstr (" "));
+
+ ds_put_substring (&label, l.ss);
+ if (ivar_idx < iact->n_vars - 1)
+ ds_put_cstr (&label, "; ");
+
+ ds_destroy (&l);
+ }
+
+ boxplot_add_box (boxplot, es[v].box_whisker, ds_cstr (&label));
+ es[v].box_whisker = NULL;
+
+ ds_destroy (&label);
+ }
+
+ boxplot_submit (boxplot);
+ }
+}
+
+static void
+show_boxplot_variabled (const struct examine *cmd, int iact_idx)
+{
+ int grp;
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ const size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ struct boxplot *boxplot;
+ int v;
+ double y_min = DBL_MAX;
+ double y_max = -DBL_MAX;
+
+ const struct ccase *c =
+ categoricals_get_case_by_category_real (cmd->cats, iact_idx, grp);
+
+ struct string title;
+ ds_init_empty (&title);
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ const struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ if (y_min > es[v].minimum)
+ y_min = es[v].minimum;
+
+ if (y_max < es[v].maximum)
+ y_max = es[v].maximum;
+ }
+
+ if (iact->n_vars == 0)
+ ds_put_format (&title, _("Boxplot"));
+ else
+ {
+ int ivar_idx;
+ struct string label;
+ ds_init_empty (&label);
+ for (ivar_idx = 0; ivar_idx < iact->n_vars; ++ivar_idx)
+ {
+ const struct variable *ivar = iact->vars[ivar_idx];
+ const union value *val = case_data (c, ivar);
+
+ ds_put_cstr (&label, var_to_string (ivar));
+ ds_put_cstr (&label, " = ");
+ append_value_name (ivar, val, &label);
+ ds_put_cstr (&label, "; ");
+ }
+
+ ds_put_format (&title, _("Boxplot of %s"),
+ ds_cstr (&label));
+
+ ds_destroy (&label);
+ }
+
+ boxplot = boxplot_create (y_min, y_max, ds_cstr (&title));
+
+ ds_destroy (&title);
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ boxplot_add_box (boxplot, es[v].box_whisker,
+ var_to_string (cmd->dep_vars[v]));
+ es[v].box_whisker = NULL;
+ }
+
+ boxplot_submit (boxplot);
+ }
+}
+
+
+static void
+show_npplot (const struct examine *cmd, int iact_idx)
+{
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ const size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+
+ int v;
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ int grp;
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ struct chart *npp, *dnpp;
+ struct casereader *reader;
+ struct np *np;
+
+ int ivar_idx;
+ const struct ccase *c =
+ categoricals_get_case_by_category_real (cmd->cats,
+ iact_idx, grp);
+
+ const struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ struct string label;
+ ds_init_cstr (&label,
+ var_to_string (cmd->dep_vars[v]));
+
+ if (iact->n_vars > 0)
+ {
+ ds_put_cstr (&label, " (");
+ for (ivar_idx = 0; ivar_idx < iact->n_vars; ++ivar_idx)
+ {
+ const struct variable *ivar = iact->vars[ivar_idx];
+ const union value *val = case_data (c, ivar);
+
+ ds_put_cstr (&label, var_to_string (ivar));
+ ds_put_cstr (&label, " = ");
+ append_value_name (ivar, val, &label);
+ ds_put_cstr (&label, "; ");
+
+ }
+ ds_put_cstr (&label, ")");
+ }
+
+ np = es[v].np;
+ reader = casewriter_make_reader (np->writer);
+ np->writer = NULL;
+
+ npp = np_plot_create (np, reader, ds_cstr (&label));
+ dnpp = dnp_plot_create (np, reader, ds_cstr (&label));
+
+ if (npp == NULL || dnpp == NULL)
+ {
+ msg (MW, _("Not creating NP plot because data set is empty."));
+ chart_unref (npp);
+ chart_unref (dnpp);
+ }
+ else
+ {
+ chart_submit (npp);
+ chart_submit (dnpp);
+ }
+ casereader_destroy (reader);
+
+ ds_destroy (&label);
+ }
+ }
+}
+
+static void
+show_spreadlevel (const struct examine *cmd, int iact_idx)
+{
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ const size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+
+ int v;
+
+ /* Spreadlevel when there are no levels is not useful */
+ if (iact->n_vars == 0)
+ return;
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ int grp;
+ struct chart *sl;
+
+ struct string label;
+ ds_init_cstr (&label,
+ var_to_string (cmd->dep_vars[v]));
+
+ if (iact->n_vars > 0)
+ {
+ ds_put_cstr (&label, " (");
+ interaction_to_string (iact, &label);
+ ds_put_cstr (&label, ")");
+ }
+
+ sl = spreadlevel_plot_create (ds_cstr (&label), cmd->sl_power);
+
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ const struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ double median = percentile_calculate (es[v].quartiles[1], cmd->pc_alg);
+
+ double iqr = percentile_calculate (es[v].quartiles[2], cmd->pc_alg) -
+ percentile_calculate (es[v].quartiles[0], cmd->pc_alg);
+
+ spreadlevel_plot_add (sl, iqr, median);
+ }
+
+ if (sl == NULL)
+ msg (MW, _("Not creating spreadlevel chart for %s"), ds_cstr (&label));
+ else
+ chart_submit (sl);
+
+ ds_destroy (&label);
+ }
+}
+
+
+static void
+show_histogram (const struct examine *cmd, int iact_idx)
+{
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ const size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+
+ int v;
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ int grp;
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ double n, mean, var;
+ int ivar_idx;
+ const struct ccase *c =
+ categoricals_get_case_by_category_real (cmd->cats,
+ iact_idx, grp);
+
+ const struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, iact_idx, grp);
+
+ struct string label;
+
+ if (es[v].histogram == NULL)
+ continue;
+
+ ds_init_cstr (&label,
+ var_to_string (cmd->dep_vars[v]));
+
+ if (iact->n_vars > 0)
+ {
+ ds_put_cstr (&label, " (");
+ for (ivar_idx = 0; ivar_idx < iact->n_vars; ++ivar_idx)
+ {
+ const struct variable *ivar = iact->vars[ivar_idx];
+ const union value *val = case_data (c, ivar);
+
+ ds_put_cstr (&label, var_to_string (ivar));
+ ds_put_cstr (&label, " = ");
+ append_value_name (ivar, val, &label);
+ ds_put_cstr (&label, "; ");
+
+ }
+ ds_put_cstr (&label, ")");
+ }
+
+
+ moments_calculate (es[v].mom, &n, &mean, &var, NULL, NULL);
+
+ chart_submit
+ (histogram_chart_create (es[v].histogram->gsl_hist,
+ ds_cstr (&label), n, mean,
+ sqrt (var), false));
+
+
+ ds_destroy (&label);
+ }
+ }
+}
+
+static struct pivot_value *
+new_value_with_missing_footnote (const struct variable *var,
+ const union value *value,
+ struct pivot_footnote *missing_footnote)
+{
+ struct pivot_value *pv = pivot_value_new_var_value (var, value);
+ if (var_is_value_missing (var, value) == MV_USER)
+ pivot_value_add_footnote (pv, missing_footnote);
+ return pv;
+}
+
+static void
+create_interaction_dimensions (struct pivot_table *table,
+ const struct categoricals *cats,
+ const struct interaction *iact,
+ struct pivot_footnote *missing_footnote)
+{
+ for (size_t i = iact->n_vars; i-- > 0;)
+ {
+ const struct variable *var = iact->vars[i];
+ struct pivot_dimension *d = pivot_dimension_create__ (
+ table, PIVOT_AXIS_ROW, pivot_value_new_variable (var));
+ d->root->show_label = true;
+
+ size_t n;
+ union value *values = categoricals_get_var_values (cats, var, &n);
+ for (size_t j = 0; j < n; j++)
+ pivot_category_create_leaf (
+ d->root, new_value_with_missing_footnote (var, &values[j],
+ missing_footnote));
+ }
+}
+
+static struct pivot_footnote *
+create_missing_footnote (struct pivot_table *table)
+{
+ return pivot_table_create_footnote (
+ table, pivot_value_new_text (N_("User-missing value.")));
+}
+
+static void
+percentiles_report (const struct examine *cmd, int iact_idx)
+{
+ struct pivot_table *table = pivot_table_create (N_("Percentiles"));
+
+ struct pivot_dimension *percentiles = pivot_dimension_create (
+ table, PIVOT_AXIS_COLUMN, N_("Percentiles"));
+ percentiles->root->show_label = true;
+ for (int i = 0; i < cmd->n_percentiles; ++i)
+ pivot_category_create_leaf (
+ percentiles->root,
+ pivot_value_new_user_text_nocopy (xasprintf ("%g", cmd->ptiles[i])));
+
+ pivot_dimension_create (table, PIVOT_AXIS_ROW, N_("Statistics"),
+ N_("Weighted Average"), N_("Tukey's Hinges"));
+
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ struct pivot_footnote *missing_footnote = create_missing_footnote (table);
+ create_interaction_dimensions (table, cmd->cats, iact, missing_footnote);
+
+ struct pivot_dimension *dep_dim = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Dependent Variables"));
+
+ size_t *indexes = xnmalloc (table->n_dimensions, sizeof *indexes);
+
+ size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+ for (size_t v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ indexes[table->n_dimensions - 1] = pivot_category_create_leaf (
+ dep_dim->root, pivot_value_new_variable (cmd->dep_vars[v]));
+
+ for (size_t i = 0; i < n_cats; ++i)
+ {
+ for (size_t j = 0; j < iact->n_vars; j++)
+ {
+ int idx = categoricals_get_value_index_by_category_real (
+ cmd->cats, iact_idx, i, j);
+ indexes[table->n_dimensions - 2 - j] = idx;
+ }
+
+ const struct exploratory_stats *ess
+ = categoricals_get_user_data_by_category_real (
+ cmd->cats, iact_idx, i);
+ const struct exploratory_stats *es = ess + v;
+
+ double hinges[3];
+ tukey_hinges_calculate (es->hinges, hinges);
+
+ for (size_t pc_idx = 0; pc_idx < cmd->n_percentiles; ++pc_idx)
+ {
+ indexes[0] = pc_idx;
+
+ indexes[1] = 0;
+ double value = percentile_calculate (es->percentiles[pc_idx],
+ cmd->pc_alg);
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (value));
+
+ double hinge = (cmd->ptiles[pc_idx] == 25.0 ? hinges[0]
+ : cmd->ptiles[pc_idx] == 50.0 ? hinges[1]
+ : cmd->ptiles[pc_idx] == 75.0 ? hinges[2]
+ : SYSMIS);
+ if (hinge != SYSMIS)
+ {
+ indexes[1] = 1;
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (hinge));
+ }
+ }
+ }
+
+ }
+ free (indexes);
+
+ pivot_table_submit (table);
+}
+
+static void
+normality_report (const struct examine *cmd, int iact_idx)
+{
+ struct pivot_table *table = pivot_table_create (N_("Tests of Normality"));
+
+ struct pivot_dimension *test =
+ pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Shapiro-Wilk"),
+ N_("Statistic"),
+ N_("df"), PIVOT_RC_COUNT,
+ N_("Sig."));
+
+ test->root->show_label = true;
+
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ struct pivot_footnote *missing_footnote = create_missing_footnote (table);
+ create_interaction_dimensions (table, cmd->cats, iact, missing_footnote);
+
+ struct pivot_dimension *dep_dim = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Dependent Variables"));
+
+ size_t *indexes = xnmalloc (table->n_dimensions, sizeof *indexes);
+
+ size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+ for (size_t v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ indexes[table->n_dimensions - 1] =
+ pivot_category_create_leaf (dep_dim->root, pivot_value_new_variable (cmd->dep_vars[v]));
+
+ for (size_t i = 0; i < n_cats; ++i)
+ {
+ indexes[1] = i;
+
+ const struct exploratory_stats *es
+ = categoricals_get_user_data_by_category_real (
+ cmd->cats, iact_idx, i);
+
+ struct shapiro_wilk *sw = es[v].shapiro_wilk;
+
+ if (sw == NULL)
+ continue;
+
+ double w = shapiro_wilk_calculate (sw);
+
+ int j = 0;
+ indexes[0] = j;
+
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (w));
+
+ indexes[0] = ++j;
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (sw->n));
+
+ indexes[0] = ++j;
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (shapiro_wilk_significance (sw->n, w)));
+ }
+ }
+
+ free (indexes);
+
+ pivot_table_submit (table);
+}
+
+
+static void
+descriptives_report (const struct examine *cmd, int iact_idx)
+{
+ struct pivot_table *table = pivot_table_create (N_("Descriptives"));
+
+ pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Aspect"),
+ N_("Statistic"), N_("Std. Error"));
+
+ struct pivot_dimension *statistics = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Statistics"), N_("Mean"));
+ struct pivot_category *interval = pivot_category_create_group__ (
+ statistics->root,
+ pivot_value_new_text_format (N_("%g%% Confidence Interval for Mean"),
+ cmd->conf * 100.0));
+ pivot_category_create_leaves (interval, N_("Lower Bound"),
+ N_("Upper Bound"));
+ pivot_category_create_leaves (
+ statistics->root, N_("5% Trimmed Mean"), N_("Median"), N_("Variance"),
+ N_("Std. Deviation"), N_("Minimum"), N_("Maximum"), N_("Range"),
+ N_("Interquartile Range"), N_("Skewness"), N_("Kurtosis"));
+
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ struct pivot_footnote *missing_footnote = create_missing_footnote (table);
+ create_interaction_dimensions (table, cmd->cats, iact, missing_footnote);
+
+ struct pivot_dimension *dep_dim = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Dependent Variables"));
+
+ size_t *indexes = xnmalloc (table->n_dimensions, sizeof *indexes);
+
+ size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+ for (size_t v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ indexes[table->n_dimensions - 1] = pivot_category_create_leaf (
+ dep_dim->root, pivot_value_new_variable (cmd->dep_vars[v]));
+
+ for (size_t i = 0; i < n_cats; ++i)
+ {
+ for (size_t j = 0; j < iact->n_vars; j++)
+ {
+ int idx = categoricals_get_value_index_by_category_real (
+ cmd->cats, iact_idx, i, j);
+ indexes[table->n_dimensions - 2 - j] = idx;
+ }
+
+ const struct exploratory_stats *ess
+ = categoricals_get_user_data_by_category_real (cmd->cats,
+ iact_idx, i);
+ const struct exploratory_stats *es = ess + v;
+
+ double m0, m1, m2, m3, m4;
+ moments_calculate (es->mom, &m0, &m1, &m2, &m3, &m4);
+ double tval = gsl_cdf_tdist_Qinv ((1.0 - cmd->conf) / 2.0, m0 - 1.0);
+
+ struct entry
+ {
+ int stat_idx;
+ int aspect_idx;
+ double x;
+ }
+ entries[] = {
+ { 0, 0, m1 },
+ { 0, 1, calc_semean (m2, m0) },
+ { 1, 0, m1 - tval * calc_semean (m2, m0) },
+ { 2, 0, m1 + tval * calc_semean (m2, m0) },
+ { 3, 0, trimmed_mean_calculate (es->trimmed_mean) },
+ { 4, 0, percentile_calculate (es->quartiles[1], cmd->pc_alg) },
+ { 5, 0, m2 },
+ { 6, 0, sqrt (m2) },
+ { 7, 0, es->minima[0].val },
+ { 8, 0, es->maxima[0].val },
+ { 9, 0, es->maxima[0].val - es->minima[0].val },
+ { 10, 0, (percentile_calculate (es->quartiles[2], cmd->pc_alg) -
+ percentile_calculate (es->quartiles[0], cmd->pc_alg)) },
+ { 11, 0, m3 },
+ { 11, 1, calc_seskew (m0) },
+ { 12, 0, m4 },
+ { 12, 1, calc_sekurt (m0) },
+ };
+ for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
+ {
+ const struct entry *e = &entries[j];
+ indexes[0] = e->aspect_idx;
+ indexes[1] = e->stat_idx;
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (e->x));
+ }
+ }
+ }
+
+ free (indexes);
+
+ pivot_table_submit (table);
+}
+
+
+static void
+extremes_report (const struct examine *cmd, int iact_idx)
+{
+ struct pivot_table *table = pivot_table_create (N_("Extreme Values"));
+
+ struct pivot_dimension *statistics = pivot_dimension_create (
+ table, PIVOT_AXIS_COLUMN, N_("Statistics"));
+ pivot_category_create_leaf (statistics->root,
+ (cmd->id_var
+ ? pivot_value_new_variable (cmd->id_var)
+ : pivot_value_new_text (N_("Case Number"))));
+ pivot_category_create_leaves (statistics->root, N_("Value"));
+
+ struct pivot_dimension *order = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Order"));
+ for (size_t i = 0; i < cmd->disp_extremes; i++)
+ pivot_category_create_leaf (order->root, pivot_value_new_integer (i + 1));
+
+ pivot_dimension_create (table, PIVOT_AXIS_ROW,
+ /* TRANSLATORS: This is a noun, not an adjective. */
+ N_("Extreme"),
+ N_("Highest"), N_("Lowest"));
+
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ struct pivot_footnote *missing_footnote = create_missing_footnote (table);
+ create_interaction_dimensions (table, cmd->cats, iact, missing_footnote);
+
+ struct pivot_dimension *dep_dim = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Dependent Variables"));
+
+ size_t *indexes = xnmalloc (table->n_dimensions, sizeof *indexes);
+
+ size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+ for (size_t v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ indexes[table->n_dimensions - 1] = pivot_category_create_leaf (
+ dep_dim->root, pivot_value_new_variable (cmd->dep_vars[v]));
+
+ for (size_t i = 0; i < n_cats; ++i)
+ {
+ for (size_t j = 0; j < iact->n_vars; j++)
+ {
+ int idx = categoricals_get_value_index_by_category_real (
+ cmd->cats, iact_idx, i, j);
+ indexes[table->n_dimensions - 2 - j] = idx;
+ }
+
+ const struct exploratory_stats *ess
+ = categoricals_get_user_data_by_category_real (cmd->cats,
+ iact_idx, i);
+ const struct exploratory_stats *es = ess + v;
+
+ for (int e = 0; e < cmd->disp_extremes; ++e)
+ {
+ indexes[1] = e;
+
+ for (size_t j = 0; j < 2; j++)
+ {
+ const struct extremity *extremity
+ = j ? &es->minima[e] : &es->maxima[e];
+ indexes[2] = j;
+
+ indexes[0] = 0;
+ pivot_table_put (
+ table, indexes, table->n_dimensions,
+ (cmd->id_var
+ ? new_value_with_missing_footnote (cmd->id_var,
+ &extremity->identity,
+ missing_footnote)
+ : pivot_value_new_integer (extremity->identity.f)));
+
+ indexes[0] = 1;
+ union value val = { .f = extremity->val };
+ pivot_table_put (
+ table, indexes, table->n_dimensions,
+ new_value_with_missing_footnote (cmd->dep_vars[v], &val,
+ missing_footnote));
+ }
+ }
+ }
+ }
+ free (indexes);
+
+ pivot_table_submit (table);
+}
+
+
+static void
+summary_report (const struct examine *cmd, int iact_idx)
+{
+ struct pivot_table *table = pivot_table_create (
+ N_("Case Processing Summary"));
+ pivot_table_set_weight_var (table, dict_get_weight (cmd->dict));
+
+ pivot_dimension_create (table, PIVOT_AXIS_COLUMN, N_("Statistics"),
+ N_("N"), PIVOT_RC_COUNT,
+ N_("Percent"), PIVOT_RC_PERCENT);
+ struct pivot_dimension *cases = pivot_dimension_create (
+ table, PIVOT_AXIS_COLUMN, N_("Cases"), N_("Valid"), N_("Missing"),
+ N_("Total"));
+ cases->root->show_label = true;
+
+ const struct interaction *iact = cmd->iacts[iact_idx];
+ struct pivot_footnote *missing_footnote = create_missing_footnote (table);
+ create_interaction_dimensions (table, cmd->cats, iact, missing_footnote);
+
+ struct pivot_dimension *dep_dim = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Dependent Variables"));
+
+ size_t *indexes = xnmalloc (table->n_dimensions, sizeof *indexes);
+
+ size_t n_cats = categoricals_n_count (cmd->cats, iact_idx);
+ for (size_t v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ indexes[table->n_dimensions - 1] = pivot_category_create_leaf (
+ dep_dim->root, pivot_value_new_variable (cmd->dep_vars[v]));
+
+ for (size_t i = 0; i < n_cats; ++i)
+ {
+ for (size_t j = 0; j < iact->n_vars; j++)
+ {
+ int idx = categoricals_get_value_index_by_category_real (
+ cmd->cats, iact_idx, i, j);
+ indexes[table->n_dimensions - 2 - j] = idx;
+ }
+
+ const struct exploratory_stats *es
+ = categoricals_get_user_data_by_category_real (
+ cmd->cats, iact_idx, i);
+
+ double total = es[v].missing + es[v].non_missing;
+ struct entry
+ {
+ int stat_idx;
+ int case_idx;
+ double x;
+ }
+ entries[] = {
+ { 0, 0, es[v].non_missing },
+ { 1, 0, 100.0 * es[v].non_missing / total },
+ { 0, 1, es[v].missing },
+ { 1, 1, 100.0 * es[v].missing / total },
+ { 0, 2, total },
+ { 1, 2, 100.0 },
+ };
+ for (size_t j = 0; j < sizeof entries / sizeof *entries; j++)
+ {
+ const struct entry *e = &entries[j];
+ indexes[0] = e->stat_idx;
+ indexes[1] = e->case_idx;
+ pivot_table_put (table, indexes, table->n_dimensions,
+ pivot_value_new_number (e->x));
+ }
+ }
+ }
+
+ free (indexes);
+
+ pivot_table_submit (table);
+}
+
+/* Attempt to parse an interaction from LEXER */
+static struct interaction *
+parse_interaction (struct lexer *lexer, struct examine *ex)
+{
+ const struct variable *v;
+ if (!lex_match_variable (lexer, ex->dict, &v))
+ return NULL;
+
+ struct interaction *iact = interaction_create (v);
+ while (lex_match (lexer, T_BY))
+ {
+ if (!lex_match_variable (lexer, ex->dict, &v))
+ {
+ interaction_destroy (iact);
+ return NULL;
+ }
+ interaction_add_variable (iact, v);
+ }
+ lex_match (lexer, T_COMMA);
+ return iact;
+}
+
+
+static void *
+create_n (const void *aux1, void *aux2 UNUSED)
+{
+ int v;
+
+ const struct examine *examine = aux1;
+ struct exploratory_stats *es = pool_calloc (examine->pool, examine->n_dep_vars, sizeof (*es));
+ struct subcase ordering;
+ subcase_init (&ordering, 0, 0, SC_ASCEND);
+
+ for (v = 0; v < examine->n_dep_vars; v++)
+ {
+ es[v].sorted_writer = sort_create_writer (&ordering, examine->ex_proto);
+ es[v].sorted_reader = NULL;
+
+ es[v].mom = moments_create (MOMENT_KURTOSIS);
+ es[v].cmin = DBL_MAX;
+
+ es[v].maximum = -DBL_MAX;
+ es[v].minimum = DBL_MAX;
+ }
+
+ subcase_uninit (&ordering);
+ return es;
+}
+
+static void
+update_n (const void *aux1, void *aux2 UNUSED, void *user_data,
+ const struct ccase *c, double weight)
+{
+ int v;
+ const struct examine *examine = aux1;
+ struct exploratory_stats *es = user_data;
+
+ bool this_case_is_missing = false;
+ /* LISTWISE missing must be dealt with here */
+ if (!examine->missing_pw)
+ {
+ for (v = 0; v < examine->n_dep_vars; v++)
+ {
+ const struct variable *var = examine->dep_vars[v];
+
+ if (var_is_value_missing (var, case_data (c, var))
+ & examine->dep_excl)
+ {
+ es[v].missing += weight;
+ this_case_is_missing = true;
+ }
+ }
+ }
+
+ if (this_case_is_missing)
+ return;
+
+ for (v = 0; v < examine->n_dep_vars; v++)
+ {
+ struct ccase *outcase;
+ const struct variable *var = examine->dep_vars[v];
+ const double x = case_num (c, var);
+
+ if (var_is_value_missing (var, case_data (c, var)) & examine->dep_excl)
+ {
+ es[v].missing += weight;
+ continue;
+ }
+
+ outcase = case_create (examine->ex_proto);
+
+ if (x > es[v].maximum)
+ es[v].maximum = x;
+
+ if (x < es[v].minimum)
+ es[v].minimum = x;
+
+ es[v].non_missing += weight;
+
+ moments_pass_one (es[v].mom, x, weight);
+
+ /* Save the value and the ID to the writer */
+ assert (examine->id_idx != -1);
+ *case_num_rw_idx (outcase, EX_VAL) = x;
+ value_copy (case_data_rw_idx (outcase, EX_ID),
+ case_data_idx (c, examine->id_idx), examine->id_width);
+
+ *case_num_rw_idx (outcase, EX_WT) = weight;
+
+ es[v].cc += weight;
+
+ if (es[v].cmin > weight)
+ es[v].cmin = weight;
+
+ casewriter_write (es[v].sorted_writer, outcase);
+ }
+}
+
+static void
+calculate_n (const void *aux1, void *aux2 UNUSED, void *user_data)
+{
+ int v;
+ const struct examine *examine = aux1;
+ struct exploratory_stats *es = user_data;
+
+ for (v = 0; v < examine->n_dep_vars; v++)
+ {
+ int i;
+ casenumber imin = 0;
+ casenumber imax;
+ struct casereader *reader;
+ struct ccase *c;
+
+ if (examine->plot_histogram && es[v].non_missing > 0)
+ {
+ /* Sturges Rule */
+ double bin_width = fabs (es[v].minimum - es[v].maximum)
+ / (1 + log2 (es[v].cc));
+
+ es[v].histogram =
+ histogram_create (bin_width, es[v].minimum, es[v].maximum);
+ }
+
+ es[v].sorted_reader = casewriter_make_reader (es[v].sorted_writer);
+ es[v].sorted_writer = NULL;
+
+ imax = casereader_get_n_cases (es[v].sorted_reader);
+
+ es[v].maxima = pool_calloc (examine->pool, examine->calc_extremes, sizeof (*es[v].maxima));
+ es[v].minima = pool_calloc (examine->pool, examine->calc_extremes, sizeof (*es[v].minima));
+ for (i = 0; i < examine->calc_extremes; ++i)
+ {
+ value_init_pool (examine->pool, &es[v].maxima[i].identity, examine->id_width);
+ value_init_pool (examine->pool, &es[v].minima[i].identity, examine->id_width);
+ }
+
+ bool warn = true;
+ for (reader = casereader_clone (es[v].sorted_reader);
+ (c = casereader_read (reader)) != NULL; case_unref (c))
+ {
+ const double val = case_num_idx (c, EX_VAL);
+ double wt = case_num_idx (c, EX_WT);
+ wt = var_force_valid_weight (examine->wv, wt, &warn);
+
+ moments_pass_two (es[v].mom, val, wt);
+
+ if (es[v].histogram)
+ histogram_add (es[v].histogram, val, wt);
+
+ if (imin < examine->calc_extremes)
+ {
+ int x;
+ for (x = imin; x < examine->calc_extremes; ++x)
+ {
+ struct extremity *min = &es[v].minima[x];
+ min->val = val;
+ value_copy (&min->identity, case_data_idx (c, EX_ID), examine->id_width);
+ }
+ imin ++;
+ }
+
+ imax --;
+ if (imax < examine->calc_extremes)
+ {
+ int x;
+
+ for (x = imax; x < imax + 1; ++x)
+ {
+ struct extremity *max;
+
+ if (x >= examine->calc_extremes)
+ break;
+
+ max = &es[v].maxima[x];
+ max->val = val;
+ value_copy (&max->identity, case_data_idx (c, EX_ID), examine->id_width);
+ }
+ }
+ }
+ casereader_destroy (reader);
+
+ if (examine->calc_extremes > 0 && es[v].non_missing > 0)
+ {
+ assert (es[v].minima[0].val == es[v].minimum);
+ assert (es[v].maxima[0].val == es[v].maximum);
+ }
+
+ {
+ const int n_os = 5 + examine->n_percentiles;
+ es[v].percentiles = pool_calloc (examine->pool, examine->n_percentiles, sizeof (*es[v].percentiles));
+
+ es[v].trimmed_mean = trimmed_mean_create (es[v].cc, 0.05);
+ es[v].shapiro_wilk = NULL;
+
+ struct order_stats **os = XCALLOC (n_os, struct order_stats *);
+ os[0] = &es[v].trimmed_mean->parent;
+
+ es[v].quartiles[0] = percentile_create (0.25, es[v].cc);
+ es[v].quartiles[1] = percentile_create (0.5, es[v].cc);
+ es[v].quartiles[2] = percentile_create (0.75, es[v].cc);
+
+ os[1] = &es[v].quartiles[0]->parent;
+ os[2] = &es[v].quartiles[1]->parent;
+ os[3] = &es[v].quartiles[2]->parent;
+
+ es[v].hinges = tukey_hinges_create (es[v].cc, es[v].cmin);
+ os[4] = &es[v].hinges->parent;
+
+ for (i = 0; i < examine->n_percentiles; ++i)
+ {
+ es[v].percentiles[i] = percentile_create (examine->ptiles[i] / 100.00, es[v].cc);
+ os[5 + i] = &es[v].percentiles[i]->parent;
+ }
+
+ order_stats_accumulate_idx (os, n_os,
+ casereader_clone (es[v].sorted_reader),
+ EX_WT, EX_VAL);
+
+ free (os);
+ }
+
+ if (examine->plot_boxplot)
+ {
+ struct order_stats *os;
+
+ es[v].box_whisker = box_whisker_create (es[v].hinges,
+ EX_ID, examine->id_var);
+
+ os = &es[v].box_whisker->parent;
+ order_stats_accumulate_idx (&os, 1,
+ casereader_clone (es[v].sorted_reader),
+ EX_WT, EX_VAL);
+ }
+
+ if (examine->plot_boxplot || examine->plot_histogram
+ || examine->plot_npplot || examine->plot_spreadlevel)
+ {
+ double mean;
+
+ moments_calculate (es[v].mom, NULL, &mean, NULL, NULL, NULL);
+
+ es[v].shapiro_wilk = shapiro_wilk_create (es[v].non_missing, mean);
+
+ if (es[v].shapiro_wilk)
+ {
+ struct order_stats *os = &es[v].shapiro_wilk->parent;
+ order_stats_accumulate_idx (&os, 1,
+ casereader_clone (es[v].sorted_reader),
+ EX_WT, EX_VAL);
+ }
+ }
+
+ if (examine->plot_npplot)
+ {
+ double n, mean, var;
+ struct order_stats *os;
+
+ moments_calculate (es[v].mom, &n, &mean, &var, NULL, NULL);
+
+ es[v].np = np_create (n, mean, var);
+
+ os = &es[v].np->parent;
+
+ order_stats_accumulate_idx (&os, 1,
+ casereader_clone (es[v].sorted_reader),
+ EX_WT, EX_VAL);
+ }
+
+ }
+}
+
+static void
+cleanup_exploratory_stats (struct examine *cmd)
+{
+ int i;
+ for (i = 0; i < cmd->n_iacts; ++i)
+ {
+ int v;
+ const size_t n_cats = categoricals_n_count (cmd->cats, i);
+
+ for (v = 0; v < cmd->n_dep_vars; ++v)
+ {
+ int grp;
+ for (grp = 0; grp < n_cats; ++grp)
+ {
+ int q;
+ const struct exploratory_stats *es =
+ categoricals_get_user_data_by_category_real (cmd->cats, i, grp);
+
+ struct order_stats *os = &es[v].hinges->parent;
+ struct statistic *stat = &os->parent;
+ stat->destroy (stat);
+
+ for (q = 0; q < 3; q++)
+ {
+ os = &es[v].quartiles[q]->parent;
+ stat = &os->parent;
+ stat->destroy (stat);
+ }
+
+ for (q = 0; q < cmd->n_percentiles; q++)
+ {
+ os = &es[v].percentiles[q]->parent;
+ stat = &os->parent;
+ stat->destroy (stat);
+ }
+
+ if (es[v].shapiro_wilk)
+ {
+ stat = &es[v].shapiro_wilk->parent.parent;
+ stat->destroy (stat);
+ }
+
+ os = &es[v].trimmed_mean->parent;
+ stat = &os->parent;
+ stat->destroy (stat);
+
+ os = &es[v].np->parent;
+ if (os)
+ {
+ stat = &os->parent;
+ stat->destroy (stat);
+ }
+
+ statistic_destroy (&es[v].histogram->parent);
+ moments_destroy (es[v].mom);
+
+ if (es[v].box_whisker)
+ {
+ stat = &es[v].box_whisker->parent.parent;
+ stat->destroy (stat);
+ }
+
+ casereader_destroy (es[v].sorted_reader);
+ }
+ }
+ }
+}
+
+
+static void
+run_examine (struct examine *cmd, struct casereader *input)
+{
+ int i;
+ struct ccase *c;
+ struct casereader *reader;
+
+ struct payload payload;
+ payload.create = create_n;
+ payload.update = update_n;
+ payload.calculate = calculate_n;
+ payload.destroy = NULL;
+
+ cmd->wv = dict_get_weight (cmd->dict);
+
+ cmd->cats
+ = categoricals_create (cmd->iacts, cmd->n_iacts, cmd->wv, cmd->fctr_excl);
+
+ categoricals_set_payload (cmd->cats, &payload, cmd, NULL);
+
+ if (cmd->id_var == NULL)
+ {
+ struct ccase *c = casereader_peek (input, 0);
+
+ cmd->id_idx = case_get_n_values (c);
+ input = casereader_create_arithmetic_sequence (input, 1.0, 1.0);
+
+ case_unref (c);
+ }
+
+ for (reader = input;
+ (c = casereader_read (reader)) != NULL; case_unref (c))
+ {
+ categoricals_update (cmd->cats, c);
+ }
+ casereader_destroy (reader);
+ categoricals_done (cmd->cats);
+
+ for (i = 0; i < cmd->n_iacts; ++i)
+ {
+ summary_report (cmd, i);
+
+ const size_t n_cats = categoricals_n_count (cmd->cats, i);
+ if (n_cats == 0)
+ continue;
+
+ if (cmd->disp_extremes > 0)
+ extremes_report (cmd, i);
+
+ if (cmd->n_percentiles > 0)
+ percentiles_report (cmd, i);
+
+ if (cmd->plot_boxplot)
+ {
+ switch (cmd->boxplot_mode)
+ {
+ case BP_GROUPS:
+ show_boxplot_grouped (cmd, i);
+ break;
+ case BP_VARIABLES:
+ show_boxplot_variabled (cmd, i);
+ break;
+ default:
+ NOT_REACHED ();
+ break;
+ }
+ }
+
+ if (cmd->plot_histogram)
+ show_histogram (cmd, i);
+
+ if (cmd->plot_npplot)
+ show_npplot (cmd, i);
+
+ if (cmd->plot_spreadlevel)
+ show_spreadlevel (cmd, i);
+
+ if (cmd->descriptives)
+ descriptives_report (cmd, i);
+
+ if (cmd->plot_histogram || cmd->plot_npplot
+ || cmd->plot_spreadlevel || cmd->plot_boxplot)
+ normality_report (cmd, i);
+ }
+
+ cleanup_exploratory_stats (cmd);
+ categoricals_destroy (cmd->cats);
+}
+
+static void
+add_interaction (struct examine *examine, struct interaction *iact,
+ size_t *allocated_iacts)
+{
+ if (examine->n_iacts >= *allocated_iacts)
+ examine->iacts = pool_2nrealloc (examine->pool, examine->iacts,
+ allocated_iacts, sizeof *examine->iacts);
+ examine->iacts[examine->n_iacts++] = iact;
+}
+
+int
+cmd_examine (struct lexer *lexer, struct dataset *ds)
+{
+ bool nototals_seen = false;
+ bool totals_seen = false;
+
+ bool percentiles_seen = false;
+
+ size_t allocated_iacts = 0;
+ struct examine examine = {
+ .pool = pool_create (),
+ .dict = dataset_dict (ds),
+
+ .conf = 0.95,
+ .pc_alg = PC_HAVERAGE,
+ .id_idx = -1,
+ .boxplot_mode = BP_GROUPS,
+
+ .ex_proto = caseproto_create (),
+
+ .dep_excl = MV_ANY,
+ .fctr_excl = MV_ANY,
+ };
+
+ /* Allocate space for the first interaction.
+ This is interaction is an empty one (for the totals).
+ If no totals are requested, we will simply ignore this
+ interaction.
+ */
+ add_interaction (&examine, interaction_create (NULL), &allocated_iacts);
+
+ /* Accept an optional, completely pointless "/VARIABLES=" */
+ lex_match (lexer, T_SLASH);
+ if (lex_match_id (lexer, "VARIABLES") && !lex_force_match (lexer, T_EQUALS))
+ goto error;
+
+ if (!parse_variables_const (lexer, examine.dict,
+ &examine.dep_vars, &examine.n_dep_vars,
+ PV_NO_DUPLICATE | PV_NUMERIC))
+ goto error;
+
+ if (lex_match (lexer, T_BY))
+ {
+ for (;;)
+ {
+ struct interaction *iact = parse_interaction (lexer, &examine);
+ if (!iact)
+ break;
+
+ add_interaction (&examine, iact, &allocated_iacts);
+ }
+ }
+
+ int nototals_ofs = 0;
+ while (lex_token (lexer) != T_ENDCMD)
+ {
+ lex_match (lexer, T_SLASH);
+
+ if (lex_match_id (lexer, "STATISTICS"))
+ {
+ lex_match (lexer, T_EQUALS);
+
+ while (lex_token (lexer) != T_ENDCMD
+ && lex_token (lexer) != T_SLASH)
+ {
+ if (lex_match_id (lexer, "DESCRIPTIVES"))
+ examine.descriptives = true;
+ else if (lex_match_id (lexer, "EXTREME"))
+ {
+ int extr = 5;
+ if (lex_match (lexer, T_LPAREN))
+ {
+ if (!lex_force_int_range (lexer, "EXTREME", 0, INT_MAX))
+ goto error;
+ extr = lex_integer (lexer);
+
+ lex_get (lexer);
+ if (!lex_force_match (lexer, T_RPAREN))
+ goto error;
+ }
+ examine.disp_extremes = extr;
+ }
+ else if (lex_match_id (lexer, "NONE"))
+ {
+ }
+ else if (lex_match (lexer, T_ALL))
+ {
+ if (examine.disp_extremes == 0)
+ examine.disp_extremes = 5;
+ }
+ else
+ {
+ lex_error_expecting (lexer, "DESCRIPTIVES", "EXTREME",
+ "NONE", "ALL");
+ goto error;
+ }
+ }
+ }
+ else if (lex_match_id (lexer, "PERCENTILES"))
+ {
+ percentiles_seen = true;
+ if (lex_match (lexer, T_LPAREN))
+ {
+ size_t allocated_percentiles = examine.n_percentiles;
+ while (lex_is_number (lexer))
+ {
+ if (!lex_force_num_range_open (lexer, "PERCENTILES", 0, 100))
+ goto error;
+ double p = lex_number (lexer);
+
+ if (examine.n_percentiles >= allocated_percentiles)
+ examine.ptiles = x2nrealloc (examine.ptiles,
+ &allocated_percentiles,
+ sizeof *examine.ptiles);
+ examine.ptiles[examine.n_percentiles++] = p;
+
+ lex_get (lexer);
+ lex_match (lexer, T_COMMA);
+ }
+ if (!lex_force_match (lexer, T_RPAREN))
+ goto error;
+ }
+
+ lex_match (lexer, T_EQUALS);
+
+ while (lex_token (lexer) != T_ENDCMD
+ && lex_token (lexer) != T_SLASH)
+ {
+ if (lex_match_id (lexer, "HAVERAGE"))
+ examine.pc_alg = PC_HAVERAGE;
+ else if (lex_match_id (lexer, "WAVERAGE"))
+ examine.pc_alg = PC_WAVERAGE;
+ else if (lex_match_id (lexer, "ROUND"))
+ examine.pc_alg = PC_ROUND;
+ else if (lex_match_id (lexer, "EMPIRICAL"))
+ examine.pc_alg = PC_EMPIRICAL;
+ else if (lex_match_id (lexer, "AEMPIRICAL"))
+ examine.pc_alg = PC_AEMPIRICAL;
+ else if (lex_match_id (lexer, "NONE"))
+ examine.pc_alg = PC_NONE;
+ else
+ {
+ lex_error_expecting (lexer, "HAVERAGE", "WAVERAGE",
+ "ROUND", "EMPIRICAL", "AEMPIRICAL",
+ "NONE");
+ goto error;
+ }
+ }
+ }
+ else if (lex_match_id (lexer, "TOTAL"))
+ totals_seen = true;
+ else if (lex_match_id (lexer, "NOTOTAL"))
+ {
+ nototals_seen = true;
+ nototals_ofs = lex_ofs (lexer) - 1;
+ }
+ else if (lex_match_id (lexer, "MISSING"))
+ {
+ lex_match (lexer, T_EQUALS);
+
+ while (lex_token (lexer) != T_ENDCMD
+ && lex_token (lexer) != T_SLASH)
+ {
+ if (lex_match_id (lexer, "LISTWISE"))
+ examine.missing_pw = false;
+ else if (lex_match_id (lexer, "PAIRWISE"))
+ examine.missing_pw = true;
+ else if (lex_match_id (lexer, "EXCLUDE"))
+ examine.dep_excl = MV_ANY;
+ else if (lex_match_id (lexer, "INCLUDE"))
+ examine.dep_excl = MV_SYSTEM;
+ else if (lex_match_id (lexer, "REPORT"))
+ examine.fctr_excl = 0;
+ else if (lex_match_id (lexer, "NOREPORT"))
+ examine.fctr_excl = MV_ANY;
+ else
+ {
+ lex_error_expecting (lexer, "LISTWISE", "PAIRWISE",
+ "EXCLUDE", "INCLUDE", "REPORT",
+ "NOREPORT");
+ goto error;
+ }
+ }
+ }
+ else if (lex_match_id (lexer, "COMPARE"))
+ {
+ lex_match (lexer, T_EQUALS);
+ if (lex_match_id (lexer, "VARIABLES"))
+ examine.boxplot_mode = BP_VARIABLES;
+ else if (lex_match_id (lexer, "GROUPS"))
+ examine.boxplot_mode = BP_GROUPS;
+ else
+ {
+ lex_error_expecting (lexer, "VARIABLES", "GROUPS");
+ goto error;
+ }
+ }
+ else if (lex_match_id (lexer, "PLOT"))
+ {
+ lex_match (lexer, T_EQUALS);
+
+ while (lex_token (lexer) != T_ENDCMD
+ && lex_token (lexer) != T_SLASH)
+ {
+ if (lex_match_id (lexer, "BOXPLOT"))
+ examine.plot_boxplot = true;
+ else if (lex_match_id (lexer, "NPPLOT"))
+ examine.plot_npplot = true;
+ else if (lex_match_id (lexer, "HISTOGRAM"))
+ examine.plot_histogram = true;
+ else if (lex_match_id (lexer, "SPREADLEVEL"))
+ {
+ examine.plot_spreadlevel = true;
+ examine.sl_power = 0;
+ if (lex_match (lexer, T_LPAREN) && lex_force_num (lexer))
+ {
+ examine.sl_power = lex_number (lexer);
+
+ lex_get (lexer);
+ if (!lex_force_match (lexer, T_RPAREN))
+ goto error;
+ }
+ }
+ else if (lex_match_id (lexer, "NONE"))
+ examine.plot_boxplot = examine.plot_npplot
+ = examine.plot_histogram = examine.plot_spreadlevel = false;
+ else if (lex_match (lexer, T_ALL))
+ examine.plot_boxplot = examine.plot_npplot
+ = examine.plot_histogram = examine.plot_spreadlevel = true;
+ else
+ {
+ lex_error_expecting (lexer, "BOXPLOT", "NPPLOT",
+ "HISTOGRAM", "SPREADLEVEL",
+ "NONE", "ALL");
+ goto error;
+ }
+ lex_match (lexer, T_COMMA);
+ }
+ }
+ else if (lex_match_id (lexer, "CINTERVAL"))
+ {
+ if (!lex_force_num (lexer))
+ goto error;
+
+ examine.conf = lex_number (lexer);
+ lex_get (lexer);
+ }
+ else if (lex_match_id (lexer, "ID"))
+ {
+ lex_match (lexer, T_EQUALS);
+
+ examine.id_var = parse_variable_const (lexer, examine.dict);
+ if (!examine.id_var)
+ goto error;
+ }
+ else
+ {
+ lex_error_expecting (lexer, "STATISTICS", "PERCENTILES",
+ "TOTAL", "NOTOTAL", "MISSING", "COMPARE",
+ "PLOT", "CINTERVAL", "ID");
+ goto error;
+ }
+ }
+
+
+ if (totals_seen && nototals_seen)
+ {
+ lex_ofs_error (lexer, nototals_ofs, nototals_ofs,
+ _("%s and %s are mutually exclusive."),
+ "TOTAL", "NOTOTAL");
+ goto error;
+ }
+
+ /* If totals have been requested or if there are no factors
+ in this analysis, then the totals need to be included. */
+ if (nototals_seen && examine.n_iacts > 1)
+ {
+ interaction_destroy (examine.iacts[0]);
+ examine.iacts++;
+ examine.n_iacts--;
+ }
+
+ if (examine.id_var)
+ {
+ examine.id_idx = var_get_case_index (examine.id_var);
+ examine.id_width = var_get_width (examine.id_var);
+ }
+
+ examine.ex_proto = caseproto_add_width (examine.ex_proto, 0); /* value */
+ examine.ex_proto = caseproto_add_width (examine.ex_proto, examine.id_width); /* id */
+ examine.ex_proto = caseproto_add_width (examine.ex_proto, 0); /* weight */
+
+ if (examine.disp_extremes > 0)
+ examine.calc_extremes = examine.disp_extremes;
+
+ if (examine.descriptives && examine.calc_extremes == 0)
+ {
+ /* Descriptives always displays the max and min */
+ examine.calc_extremes = 1;
+ }
+
+ if (percentiles_seen && examine.n_percentiles == 0)
+ {
+ examine.n_percentiles = 7;
+ examine.ptiles = xmalloc (examine.n_percentiles * sizeof *examine.ptiles);
+
+ examine.ptiles[0] = 5;
+ examine.ptiles[1] = 10;
+ examine.ptiles[2] = 25;
+ examine.ptiles[3] = 50;
+ examine.ptiles[4] = 75;
+ examine.ptiles[5] = 90;
+ examine.ptiles[6] = 95;
+ }
+
+ assert (examine.calc_extremes >= examine.disp_extremes);
+
+ struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), examine.dict);
+ struct casereader *group;
+ while (casegrouper_get_next_group (grouper, &group))
+ run_examine (&examine, group);
+ bool ok = casegrouper_destroy (grouper);
+ ok = proc_commit (ds) && ok;
+
+ caseproto_unref (examine.ex_proto);
+
+ for (size_t i = 0; i < examine.n_iacts; ++i)
+ interaction_destroy (examine.iacts[i]);
+ free (examine.ptiles);
+ free (examine.dep_vars);
+ pool_destroy (examine.pool);
+
+ return CMD_SUCCESS;
+
+ error:
+ caseproto_unref (examine.ex_proto);
+ for (size_t i = 0; i < examine.n_iacts; ++i)
+ interaction_destroy (examine.iacts[i]);
+ free (examine.dep_vars);
+ free (examine.ptiles);
+ pool_destroy (examine.pool);
+
+ return CMD_FAILURE;
+}
projects / pspp / blobdiff