#include <language/command.h>
#include <language/lexer/lexer.h>
#include <language/lexer/variable-parser.h>
+#include <language/lexer/value-parser.h>
#include <language/stats/binomial.h>
#include <language/stats/chisquare.h>
#include <language/stats/wilcoxon.h>
#include "gettext.h"
#define _(msgid) gettext (msgid)
-struct dataset;
/* Settings for subcommand specifiers. */
-enum
- {
- NPAR_ANALYSIS,
- NPAR_LISTWISE,
- };
-
-enum
+enum missing_type
{
- NPAR_INCLUDE,
- NPAR_EXCLUDE
+ MISS_ANALYSIS,
+ MISS_LISTWISE,
};
/* Array indices for STATISTICS subcommand. */
/* NPAR TESTS structure. */
struct cmd_npar_tests
{
- /* CHISQUARE subcommand. */
+ /* Count variables indicating how many
+ of the subcommands have been given. */
int chisquare;
-
- /* BINOMIAL subcommand. */
int binomial;
-
- /* WILCOXON subcommand. */
int wilcoxon;
-
- /* SIGN subcommand. */
int sign;
-
- /* MISSING subcommand. */
+ int kruskal_wallis;
int missing;
- long miss;
- long incl;
-
- /* METHOD subcommand. */
int method;
-
- /* STATISTICS subcommand. */
int statistics;
+
+ /* How missing values should be treated */
+ long miss;
+
+ /* Which statistics have been requested */
int a_statistics[NPAR_ST_count];
};
static int npar_binomial (struct lexer *, struct dataset *, struct npar_specs *);
static int npar_wilcoxon (struct lexer *, struct dataset *, struct npar_specs *);
static int npar_sign (struct lexer *, struct dataset *, struct npar_specs *);
+static int npar_kruskal_wallis (struct lexer *, struct dataset *, struct npar_specs *);
static int npar_method (struct lexer *, struct npar_specs *);
/* Command parsing functions. */
npt->wilcoxon = 0;
npt->sign = 0;
npt->missing = 0;
- npt->miss = NPAR_ANALYSIS;
- npt->incl = NPAR_EXCLUDE;
+ npt->miss = MISS_ANALYSIS;
npt->method = 0;
npt->statistics = 0;
memset (npt->a_statistics, 0, sizeof npt->a_statistics);
NOT_REACHED ();
}
}
+ else if (lex_match_hyphenated_word (lexer, "K-S") ||
+ lex_match_hyphenated_word (lexer, "KRUSKAL-WALLIS"))
+ {
+ lex_match (lexer, '=');
+ npt->kruskal_wallis++;
+ switch (npar_kruskal_wallis (lexer, ds, nps))
+ {
+ case 0:
+ goto lossage;
+ case 1:
+ break;
+ case 2:
+ lex_error (lexer, NULL);
+ goto lossage;
+ default:
+ NOT_REACHED ();
+ }
+ }
else if (lex_match_hyphenated_word (lexer, "WILCOXON"))
{
lex_match (lexer, '=');
npt->missing++;
if (npt->missing > 1)
{
- msg (SE, _ ("MISSING subcommand may be given only once."));
+ msg (SE, _ ("The %s subcommand may be given only once."), "MISSING");
goto lossage;
}
while (lex_token (lexer) != '/' && lex_token (lexer) != '.')
{
if (lex_match_hyphenated_word (lexer, "ANALYSIS"))
- npt->miss = NPAR_ANALYSIS;
+ npt->miss = MISS_ANALYSIS;
else if (lex_match_hyphenated_word (lexer, "LISTWISE"))
- npt->miss = NPAR_LISTWISE;
+ npt->miss = MISS_LISTWISE;
else if (lex_match_hyphenated_word (lexer, "INCLUDE"))
- npt->incl = NPAR_INCLUDE;
+ nps->filter = MV_SYSTEM;
else if (lex_match_hyphenated_word (lexer, "EXCLUDE"))
- npt->incl = NPAR_EXCLUDE;
+ nps->filter = MV_ANY;
else
{
lex_error (lexer, NULL);
npt->method++;
if (npt->method > 1)
{
- msg (SE, _ ("METHOD subcommand may be given only once."));
+ msg (SE, _ ("The %s subcommand may be given only once."), "METHOD");
goto lossage;
}
switch (npar_method (lexer, nps))
struct const_hsh_table *variables);
+static void n_sample_insert_variables (const struct npar_test *test,
+ struct const_hsh_table *variables);
+
+
+
static void
npar_execute (struct casereader *input,
const struct npar_specs *specs,
struct casereader *input, *group;
npar_specs.pool = pool_create ();
+ npar_specs.filter = MV_ANY;
var_hash = const_hsh_create_pool (npar_specs.pool, 0,
compare_vars_by_name, hash_var_by_name,
}
}
- npar_specs.filter = cmd.incl == NPAR_EXCLUDE ? MV_ANY : MV_SYSTEM;
-
input = proc_open (ds);
- if ( cmd.miss == NPAR_LISTWISE )
+ if ( cmd.miss == MISS_LISTWISE )
{
input = casereader_create_filter_missing (input,
npar_specs.vv,
return true;
}
+
+static bool
+parse_n_sample_related_test (struct lexer *lexer,
+ const struct dictionary *dict,
+ struct n_sample_test *nst,
+ struct pool *pool
+ )
+{
+ union value val1, val2;
+
+ if (!parse_variables_const_pool (lexer, pool,
+ dict,
+ &nst->vars, &nst->n_vars,
+ PV_NUMERIC | PV_NO_SCRATCH | PV_NO_DUPLICATE) )
+ return false;
+
+ if ( ! lex_force_match (lexer, T_BY))
+ return false;
+
+ nst->indep_var = parse_variable_const (lexer, dict);
+
+ if ( ! lex_force_match (lexer, '('))
+ return false;
+
+ value_init (&val1, var_get_width (nst->indep_var));
+ if ( ! parse_value (lexer, &val1, var_get_width (nst->indep_var)))
+ {
+ value_destroy (&val1, var_get_width (nst->indep_var));
+ return false;
+ }
+
+ if ( ! lex_force_match (lexer, ','))
+ return false;
+
+ value_init (&val2, var_get_width (nst->indep_var));
+ if ( ! parse_value (lexer, &val2, var_get_width (nst->indep_var)))
+ {
+ value_destroy (&val2, var_get_width (nst->indep_var));
+ return false;
+ }
+
+ if ( ! lex_force_match (lexer, ')'))
+ return false;
+
+ return true;
+}
+
static int
npar_wilcoxon (struct lexer *lexer,
struct dataset *ds,
return 1;
}
+static int
+npar_kruskal_wallis (struct lexer *lexer, struct dataset *ds,
+ struct npar_specs *specs)
+{
+ struct n_sample_test *tp = pool_alloc (specs->pool, sizeof (*tp));
+ struct npar_test *nt = &tp->parent;
+
+ nt->insert_variables = n_sample_insert_variables;
+
+ // nt->execute = kruskall_wallis_execute;
+
+ if (!parse_n_sample_related_test (lexer, dataset_dict (ds),
+ tp, specs->pool) )
+ return 0;
+
+ specs->n_tests++;
+ specs->test = pool_realloc (specs->pool,
+ specs->test,
+ sizeof (*specs->test) * specs->n_tests);
+ specs->test[specs->n_tests - 1] = nt;
+
+ return 1;
+}
+
/* Insert the variables for TEST into VAR_HASH */
static void
one_sample_insert_variables (const struct npar_test *test,
struct const_hsh_table *var_hash)
{
int i;
- struct one_sample_test *ost = UP_CAST (test, struct one_sample_test, parent);
+ const struct one_sample_test *ost = UP_CAST (test, const struct one_sample_test, parent);
for ( i = 0 ; i < ost->n_vars ; ++i )
const_hsh_insert (var_hash, ost->vars[i]);
}
+
static void
two_sample_insert_variables (const struct npar_test *test,
struct const_hsh_table *var_hash)
{
int i;
- const struct two_sample_test *tst = (const struct two_sample_test *) test;
+ const struct two_sample_test *tst = UP_CAST (test, const struct two_sample_test, parent);
for ( i = 0 ; i < tst->n_pairs ; ++i )
{
}
}
+static void
+n_sample_insert_variables (const struct npar_test *test,
+ struct const_hsh_table *var_hash)
+{
+ int i;
+ const struct n_sample_test *tst = UP_CAST (test, const struct n_sample_test, parent);
+
+ for ( i = 0 ; i < tst->n_vars ; ++i )
+ const_hsh_insert (var_hash, tst->vars[i]);
+
+ const_hsh_insert (var_hash, tst->indep_var);
+}
+
static int
npar_method (struct lexer *lexer, struct npar_specs *specs)
{