1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2008, 2009 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include <data/any-writer.h>
22 #include <data/case.h>
23 #include <data/casegrouper.h>
24 #include <data/casereader.h>
25 #include <data/casewriter.h>
26 #include <data/dictionary.h>
27 #include <data/file-handle-def.h>
28 #include <data/format.h>
29 #include <data/procedure.h>
30 #include <data/settings.h>
31 #include <data/subcase.h>
32 #include <data/sys-file-writer.h>
33 #include <data/variable.h>
34 #include <language/command.h>
35 #include <language/data-io/file-handle.h>
36 #include <language/lexer/lexer.h>
37 #include <language/lexer/variable-parser.h>
38 #include <language/stats/sort-criteria.h>
39 #include <libpspp/assertion.h>
40 #include <libpspp/message.h>
41 #include <libpspp/misc.h>
42 #include <libpspp/pool.h>
43 #include <libpspp/str.h>
44 #include <math/moments.h>
45 #include <math/sort.h>
46 #include <math/statistic.h>
47 #include <math/percentiles.h>
53 #define _(msgid) gettext (msgid)
55 /* Argument for AGGREGATE function. */
58 double f; /* Numeric. */
59 char *c; /* Short or long string. */
62 /* Specifies how to make an aggregate variable. */
65 struct agr_var *next; /* Next in list. */
67 /* Collected during parsing. */
68 const struct variable *src; /* Source variable. */
69 struct variable *dest; /* Target variable. */
70 int function; /* Function. */
71 enum mv_class exclude; /* Classes of missing values to exclude. */
72 union agr_argument arg[2]; /* Arguments. */
74 /* Accumulated during AGGREGATE execution. */
79 struct moments1 *moments;
82 struct variable *subject;
83 struct variable *weight;
84 struct casewriter *writer;
87 /* Aggregation functions. */
90 NONE, SUM, MEAN, MEDIAN, SD, MAX, MIN, PGT, PLT, PIN, POUT, FGT, FLT, FIN,
91 FOUT, N, NU, NMISS, NUMISS, FIRST, LAST,
92 N_AGR_FUNCS, N_NO_VARS, NU_NO_VARS,
93 FUNC = 0x1f, /* Function mask. */
94 FSTRING = 1<<5, /* String function bit. */
97 /* Attributes of an aggregation function. */
100 const char *name; /* Aggregation function name. */
101 size_t n_args; /* Number of arguments. */
102 enum val_type alpha_type; /* When given ALPHA arguments, output type. */
103 struct fmt_spec format; /* Format spec if alpha_type != ALPHA. */
106 /* Attributes of aggregation functions. */
107 static const struct agr_func agr_func_tab[] =
109 {"<NONE>", 0, -1, {0, 0, 0}},
110 {"SUM", 0, -1, {FMT_F, 8, 2}},
111 {"MEAN", 0, -1, {FMT_F, 8, 2}},
112 {"MEDIAN", 0, -1, {FMT_F, 8, 2}},
113 {"SD", 0, -1, {FMT_F, 8, 2}},
114 {"MAX", 0, VAL_STRING, {-1, -1, -1}},
115 {"MIN", 0, VAL_STRING, {-1, -1, -1}},
116 {"PGT", 1, VAL_NUMERIC, {FMT_F, 5, 1}},
117 {"PLT", 1, VAL_NUMERIC, {FMT_F, 5, 1}},
118 {"PIN", 2, VAL_NUMERIC, {FMT_F, 5, 1}},
119 {"POUT", 2, VAL_NUMERIC, {FMT_F, 5, 1}},
120 {"FGT", 1, VAL_NUMERIC, {FMT_F, 5, 3}},
121 {"FLT", 1, VAL_NUMERIC, {FMT_F, 5, 3}},
122 {"FIN", 2, VAL_NUMERIC, {FMT_F, 5, 3}},
123 {"FOUT", 2, VAL_NUMERIC, {FMT_F, 5, 3}},
124 {"N", 0, VAL_NUMERIC, {FMT_F, 7, 0}},
125 {"NU", 0, VAL_NUMERIC, {FMT_F, 7, 0}},
126 {"NMISS", 0, VAL_NUMERIC, {FMT_F, 7, 0}},
127 {"NUMISS", 0, VAL_NUMERIC, {FMT_F, 7, 0}},
128 {"FIRST", 0, VAL_STRING, {-1, -1, -1}},
129 {"LAST", 0, VAL_STRING, {-1, -1, -1}},
130 {NULL, 0, -1, {-1, -1, -1}},
131 {"N", 0, VAL_NUMERIC, {FMT_F, 7, 0}},
132 {"NU", 0, VAL_NUMERIC, {FMT_F, 7, 0}},
135 /* Missing value types. */
136 enum missing_treatment
138 ITEMWISE, /* Missing values item by item. */
139 COLUMNWISE /* Missing values column by column. */
142 /* An entire AGGREGATE procedure. */
145 /* Break variables. */
146 struct subcase sort; /* Sort criteria (break variables). */
147 const struct variable **break_vars; /* Break variables. */
148 size_t break_var_cnt; /* Number of break variables. */
149 struct ccase *break_case; /* Last values of break variables. */
151 enum missing_treatment missing; /* How to treat missing values. */
152 struct agr_var *agr_vars; /* First aggregate variable. */
153 struct dictionary *dict; /* Aggregate dictionary. */
154 const struct dictionary *src_dict; /* Dict of the source */
155 int case_cnt; /* Counts aggregated cases. */
158 static void initialize_aggregate_info (struct agr_proc *,
159 const struct ccase *);
161 static void accumulate_aggregate_info (struct agr_proc *,
162 const struct ccase *);
164 static bool parse_aggregate_functions (struct lexer *, const struct dictionary *,
166 static void agr_destroy (struct agr_proc *);
167 static void dump_aggregate_info (struct agr_proc *agr,
168 struct casewriter *output);
172 /* Parses and executes the AGGREGATE procedure. */
174 cmd_aggregate (struct lexer *lexer, struct dataset *ds)
176 struct dictionary *dict = dataset_dict (ds);
178 struct file_handle *out_file = NULL;
179 struct casereader *input = NULL, *group;
180 struct casegrouper *grouper;
181 struct casewriter *output = NULL;
183 bool copy_documents = false;
184 bool presorted = false;
188 memset(&agr, 0 , sizeof (agr));
189 agr.missing = ITEMWISE;
190 agr.break_case = NULL;
192 agr.dict = dict_create ();
194 subcase_init_empty (&agr.sort);
195 dict_set_label (agr.dict, dict_get_label (dict));
196 dict_set_documents (agr.dict, dict_get_documents (dict));
198 /* OUTFILE subcommand must be first. */
199 if (!lex_force_match_id (lexer, "OUTFILE"))
201 lex_match (lexer, '=');
202 if (!lex_match (lexer, '*'))
204 out_file = fh_parse (lexer, FH_REF_FILE | FH_REF_SCRATCH);
205 if (out_file == NULL)
209 /* Read most of the subcommands. */
212 lex_match (lexer, '/');
214 if (lex_match_id (lexer, "MISSING"))
216 lex_match (lexer, '=');
217 if (!lex_match_id (lexer, "COLUMNWISE"))
219 lex_error (lexer, _("while expecting COLUMNWISE"));
222 agr.missing = COLUMNWISE;
224 else if (lex_match_id (lexer, "DOCUMENT"))
225 copy_documents = true;
226 else if (lex_match_id (lexer, "PRESORTED"))
228 else if (lex_match_id (lexer, "BREAK"))
232 lex_match (lexer, '=');
233 if (!parse_sort_criteria (lexer, dict, &agr.sort, &agr.break_vars,
236 agr.break_var_cnt = subcase_get_n_fields (&agr.sort);
238 for (i = 0; i < agr.break_var_cnt; i++)
239 dict_clone_var_assert (agr.dict, agr.break_vars[i],
240 var_get_name (agr.break_vars[i]));
242 /* BREAK must follow the options. */
247 lex_error (lexer, _("expecting BREAK"));
251 if (presorted && saw_direction)
252 msg (SW, _("When PRESORTED is specified, specifying sorting directions "
253 "with (A) or (D) has no effect. Output data will be sorted "
254 "the same way as the input data."));
256 /* Read in the aggregate functions. */
257 lex_match (lexer, '/');
258 if (!parse_aggregate_functions (lexer, dict, &agr))
261 /* Delete documents. */
263 dict_clear_documents (agr.dict);
265 /* Cancel SPLIT FILE. */
266 dict_set_split_vars (agr.dict, NULL, 0);
271 if (out_file == NULL)
273 /* The active file will be replaced by the aggregated data,
274 so TEMPORARY is moot. */
275 proc_cancel_temporary_transformations (ds);
276 proc_discard_output (ds);
277 output = autopaging_writer_create (dict_get_proto (agr.dict));
281 output = any_writer_open (out_file, agr.dict);
286 input = proc_open (ds);
287 if (!subcase_is_empty (&agr.sort) && !presorted)
289 input = sort_execute (input, &agr.sort);
290 subcase_clear (&agr.sort);
293 for (grouper = casegrouper_create_vars (input, agr.break_vars,
295 casegrouper_get_next_group (grouper, &group);
296 casereader_destroy (group))
298 struct ccase *c = casereader_peek (group, 0);
301 casereader_destroy (group);
304 initialize_aggregate_info (&agr, c);
307 for (; (c = casereader_read (group)) != NULL; case_unref (c))
308 accumulate_aggregate_info (&agr, c);
309 dump_aggregate_info (&agr, output);
311 if (!casegrouper_destroy (grouper))
314 if (!proc_commit (ds))
321 if (out_file == NULL)
323 struct casereader *next_input = casewriter_make_reader (output);
324 if (next_input == NULL)
327 proc_set_active_file (ds, next_input, agr.dict);
332 ok = casewriter_destroy (output);
345 casewriter_destroy (output);
348 return CMD_CASCADING_FAILURE;
351 /* Parse all the aggregate functions. */
353 parse_aggregate_functions (struct lexer *lexer, const struct dictionary *dict,
354 struct agr_proc *agr)
356 struct agr_var *tail; /* Tail of linked list starting at agr->vars. */
358 /* Parse everything. */
365 struct string function_name;
367 enum mv_class exclude;
368 const struct agr_func *function;
371 union agr_argument arg[2];
373 const struct variable **src;
386 ds_init_empty (&function_name);
388 /* Parse the list of target variables. */
389 while (!lex_match (lexer, '='))
391 size_t n_dest_prev = n_dest;
393 if (!parse_DATA_LIST_vars (lexer, &dest, &n_dest,
394 PV_APPEND | PV_SINGLE | PV_NO_SCRATCH))
397 /* Assign empty labels. */
401 dest_label = xnrealloc (dest_label, n_dest, sizeof *dest_label);
402 for (j = n_dest_prev; j < n_dest; j++)
403 dest_label[j] = NULL;
408 if (lex_token (lexer) == T_STRING)
411 ds_init_string (&label, lex_tokstr (lexer));
413 ds_truncate (&label, 255);
414 dest_label[n_dest - 1] = ds_xstrdup (&label);
420 /* Get the name of the aggregation function. */
421 if (lex_token (lexer) != T_ID)
423 lex_error (lexer, _("expecting aggregation function"));
429 ds_assign_string (&function_name, lex_tokstr (lexer));
431 ds_chomp (&function_name, '.');
433 if (lex_tokid(lexer)[strlen (lex_tokid (lexer)) - 1] == '.')
436 for (function = agr_func_tab; function->name; function++)
437 if (!strcasecmp (function->name, ds_cstr (&function_name)))
439 if (NULL == function->name)
441 msg (SE, _("Unknown aggregation function %s."),
442 ds_cstr (&function_name));
445 ds_destroy (&function_name);
446 func_index = function - agr_func_tab;
449 /* Check for leading lparen. */
450 if (!lex_match (lexer, '('))
453 func_index = N_NO_VARS;
454 else if (func_index == NU)
455 func_index = NU_NO_VARS;
458 lex_error (lexer, _("expecting `('"));
464 /* Parse list of source variables. */
466 int pv_opts = PV_NO_SCRATCH;
468 if (func_index == SUM || func_index == MEAN || func_index == SD)
469 pv_opts |= PV_NUMERIC;
470 else if (function->n_args)
471 pv_opts |= PV_SAME_TYPE;
473 if (!parse_variables_const (lexer, dict, &src, &n_src, pv_opts))
477 /* Parse function arguments, for those functions that
478 require arguments. */
479 if (function->n_args != 0)
480 for (i = 0; i < function->n_args; i++)
484 lex_match (lexer, ',');
485 if (lex_token (lexer) == T_STRING)
487 arg[i].c = ds_xstrdup (lex_tokstr (lexer));
490 else if (lex_is_number (lexer))
492 arg[i].f = lex_tokval (lexer);
497 msg (SE, _("Missing argument %zu to %s."),
498 i + 1, function->name);
504 if (type != var_get_type (src[0]))
506 msg (SE, _("Arguments to %s must be of same type as "
507 "source variables."),
513 /* Trailing rparen. */
514 if (!lex_match (lexer, ')'))
516 lex_error (lexer, _("expecting `)'"));
520 /* Now check that the number of source variables match
521 the number of target variables. If we check earlier
522 than this, the user can get very misleading error
523 message, i.e. `AGGREGATE x=SUM(y t).' will get this
524 error message when a proper message would be more
525 like `unknown variable t'. */
528 msg (SE, _("Number of source variables (%zu) does not match "
529 "number of target variables (%zu)."),
534 if ((func_index == PIN || func_index == POUT
535 || func_index == FIN || func_index == FOUT)
536 && (var_is_numeric (src[0])
537 ? arg[0].f > arg[1].f
538 : str_compare_rpad (arg[0].c, arg[1].c) > 0))
540 union agr_argument t = arg[0];
544 msg (SW, _("The value arguments passed to the %s function "
545 "are out-of-order. They will be treated as if "
546 "they had been specified in the correct order."),
551 /* Finally add these to the linked list of aggregation
553 for (i = 0; i < n_dest; i++)
555 struct agr_var *v = xzalloc (sizeof *v);
557 /* Add variable to chain. */
558 if (agr->agr_vars != NULL)
566 /* Create the target variable in the aggregate
569 struct variable *destvar;
571 v->function = func_index;
577 if (var_is_alpha (src[i]))
579 v->function |= FSTRING;
580 v->string = xmalloc (var_get_width (src[i]));
583 if (function->alpha_type == VAL_STRING)
584 destvar = dict_clone_var (agr->dict, v->src, dest[i]);
587 assert (var_is_numeric (v->src)
588 || function->alpha_type == VAL_NUMERIC);
589 destvar = dict_create_var (agr->dict, dest[i], 0);
593 if ((func_index == N || func_index == NMISS)
594 && dict_get_weight (dict) != NULL)
595 f = fmt_for_output (FMT_F, 8, 2);
597 f = function->format;
598 var_set_both_formats (destvar, &f);
604 destvar = dict_create_var (agr->dict, dest[i], 0);
605 if (func_index == N_NO_VARS && dict_get_weight (dict) != NULL)
606 f = fmt_for_output (FMT_F, 8, 2);
608 f = function->format;
609 var_set_both_formats (destvar, &f);
614 msg (SE, _("Variable name %s is not unique within the "
615 "aggregate file dictionary, which contains "
616 "the aggregate variables and the break "
624 var_set_label (destvar, dest_label[i]);
629 v->exclude = exclude;
635 if (var_is_numeric (v->src))
636 for (j = 0; j < function->n_args; j++)
637 v->arg[j].f = arg[j].f;
639 for (j = 0; j < function->n_args; j++)
640 v->arg[j].c = xstrdup (arg[j].c);
644 if (src != NULL && var_is_alpha (src[0]))
645 for (i = 0; i < function->n_args; i++)
655 if (!lex_match (lexer, '/'))
657 if (lex_token (lexer) == '.')
660 lex_error (lexer, "expecting end of command");
666 ds_destroy (&function_name);
667 for (i = 0; i < n_dest; i++)
670 free (dest_label[i]);
676 if (src && n_src && var_is_alpha (src[0]))
677 for (i = 0; i < function->n_args; i++)
690 agr_destroy (struct agr_proc *agr)
692 struct agr_var *iter, *next;
694 subcase_destroy (&agr->sort);
695 free (agr->break_vars);
696 case_unref (agr->break_case);
697 for (iter = agr->agr_vars; iter; iter = next)
701 if (iter->function & FSTRING)
706 n_args = agr_func_tab[iter->function & FUNC].n_args;
707 for (i = 0; i < n_args; i++)
708 free (iter->arg[i].c);
711 else if (iter->function == SD)
712 moments1_destroy (iter->moments);
714 var_destroy (iter->subject);
715 var_destroy (iter->weight);
719 if (agr->dict != NULL)
720 dict_destroy (agr->dict);
725 /* Accumulates aggregation data from the case INPUT. */
727 accumulate_aggregate_info (struct agr_proc *agr, const struct ccase *input)
729 struct agr_var *iter;
731 bool bad_warn = true;
733 weight = dict_get_case_weight (agr->src_dict, input, &bad_warn);
735 for (iter = agr->agr_vars; iter; iter = iter->next)
738 const union value *v = case_data (input, iter->src);
739 int src_width = var_get_width (iter->src);
741 if (var_is_value_missing (iter->src, v, iter->exclude))
743 switch (iter->function)
746 case NMISS | FSTRING:
747 iter->dbl[0] += weight;
750 case NUMISS | FSTRING:
754 iter->saw_missing = true;
758 /* This is horrible. There are too many possibilities. */
759 switch (iter->function)
762 iter->dbl[0] += v->f * weight;
766 iter->dbl[0] += v->f * weight;
767 iter->dbl[1] += weight;
774 cout = case_create (casewriter_get_proto (iter->writer));
776 case_data_rw (cout, iter->subject)->f
777 = case_data (input, iter->src)->f;
779 wv = dict_get_case_weight (agr->src_dict, input, NULL);
781 case_data_rw (cout, iter->weight)->f = wv;
785 casewriter_write (iter->writer, cout);
789 moments1_add (iter->moments, v->f, weight);
792 iter->dbl[0] = MAX (iter->dbl[0], v->f);
796 if (memcmp (iter->string, value_str (v, src_width), src_width) < 0)
797 memcpy (iter->string, value_str (v, src_width), src_width);
801 iter->dbl[0] = MIN (iter->dbl[0], v->f);
805 if (memcmp (iter->string, value_str (v, src_width), src_width) > 0)
806 memcpy (iter->string, value_str (v, src_width), src_width);
811 if (v->f > iter->arg[0].f)
812 iter->dbl[0] += weight;
813 iter->dbl[1] += weight;
817 if (memcmp (iter->arg[0].c,
818 value_str (v, src_width), src_width) < 0)
819 iter->dbl[0] += weight;
820 iter->dbl[1] += weight;
824 if (v->f < iter->arg[0].f)
825 iter->dbl[0] += weight;
826 iter->dbl[1] += weight;
830 if (memcmp (iter->arg[0].c,
831 value_str (v, src_width), src_width) > 0)
832 iter->dbl[0] += weight;
833 iter->dbl[1] += weight;
837 if (iter->arg[0].f <= v->f && v->f <= iter->arg[1].f)
838 iter->dbl[0] += weight;
839 iter->dbl[1] += weight;
843 if (memcmp (iter->arg[0].c,
844 value_str (v, src_width), src_width) <= 0
845 && memcmp (iter->arg[1].c,
846 value_str (v, src_width), src_width) >= 0)
847 iter->dbl[0] += weight;
848 iter->dbl[1] += weight;
852 if (iter->arg[0].f > v->f || v->f > iter->arg[1].f)
853 iter->dbl[0] += weight;
854 iter->dbl[1] += weight;
858 if (memcmp (iter->arg[0].c,
859 value_str (v, src_width), src_width) > 0
860 || memcmp (iter->arg[1].c,
861 value_str (v, src_width), src_width) < 0)
862 iter->dbl[0] += weight;
863 iter->dbl[1] += weight;
867 iter->dbl[0] += weight;
880 case FIRST | FSTRING:
883 memcpy (iter->string, value_str (v, src_width), src_width);
892 memcpy (iter->string, value_str (v, src_width), src_width);
896 case NMISS | FSTRING:
898 case NUMISS | FSTRING:
899 /* Our value is not missing or it would have been
900 caught earlier. Nothing to do. */
906 switch (iter->function)
909 iter->dbl[0] += weight;
920 /* Writes an aggregated record to OUTPUT. */
922 dump_aggregate_info (struct agr_proc *agr, struct casewriter *output)
924 struct ccase *c = case_create (dict_get_proto (agr->dict));
930 for (i = 0; i < agr->break_var_cnt; i++)
932 const struct variable *v = agr->break_vars[i];
933 value_copy (case_data_rw_idx (c, value_idx),
934 case_data (agr->break_case, v),
943 for (i = agr->agr_vars; i; i = i->next)
945 union value *v = case_data_rw (c, i->dest);
946 int width = var_get_width (i->dest);
948 if (agr->missing == COLUMNWISE && i->saw_missing
949 && (i->function & FUNC) != N && (i->function & FUNC) != NU
950 && (i->function & FUNC) != NMISS && (i->function & FUNC) != NUMISS)
952 value_set_missing (v, width);
953 casewriter_destroy (i->writer);
960 v->f = i->int1 ? i->dbl[0] : SYSMIS;
963 v->f = i->dbl[1] != 0.0 ? i->dbl[0] / i->dbl[1] : SYSMIS;
967 struct casereader *sorted_reader;
968 struct order_stats *median = percentile_create (0.5, i->cc);
970 sorted_reader = casewriter_make_reader (i->writer);
972 order_stats_accumulate (&median, 1,
978 v->f = percentile_calculate ((struct percentile *) median,
981 statistic_destroy ((struct statistic *) median);
988 /* FIXME: we should use two passes. */
989 moments1_calculate (i->moments, NULL, NULL, &variance,
991 if (variance != SYSMIS)
992 v->f = sqrt (variance);
999 v->f = i->int1 ? i->dbl[0] : SYSMIS;
1004 memcpy (value_str_rw (v, width), i->string, width);
1006 value_set_missing (v, width);
1015 case FOUT | FSTRING:
1016 v->f = i->dbl[1] ? i->dbl[0] / i->dbl[1] : SYSMIS;
1025 case POUT | FSTRING:
1026 v->f = i->dbl[1] ? i->dbl[0] / i->dbl[1] * 100.0 : SYSMIS;
1038 v->f = i->int1 ? i->dbl[0] : SYSMIS;
1040 case FIRST | FSTRING:
1041 case LAST | FSTRING:
1043 memcpy (value_str_rw (v, width), i->string, width);
1045 value_set_missing (v, width);
1054 case NMISS | FSTRING:
1058 case NUMISS | FSTRING:
1067 casewriter_write (output, c);
1070 /* Resets the state for all the aggregate functions. */
1072 initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input)
1074 struct agr_var *iter;
1076 case_unref (agr->break_case);
1077 agr->break_case = case_ref (input);
1079 for (iter = agr->agr_vars; iter; iter = iter->next)
1081 iter->saw_missing = false;
1082 iter->dbl[0] = iter->dbl[1] = iter->dbl[2] = 0.0;
1083 iter->int1 = iter->int2 = 0;
1084 switch (iter->function)
1087 iter->dbl[0] = DBL_MAX;
1090 memset (iter->string, 255, var_get_width (iter->src));
1093 iter->dbl[0] = -DBL_MAX;
1096 memset (iter->string, 0, var_get_width (iter->src));
1100 struct caseproto *proto;
1101 struct subcase ordering;
1103 proto = caseproto_create ();
1104 proto = caseproto_add_width (proto, 0);
1105 proto = caseproto_add_width (proto, 0);
1107 if ( ! iter->subject)
1108 iter->subject = var_create_internal (0, 0);
1110 if ( ! iter->weight)
1111 iter->weight = var_create_internal (1, 0);
1113 subcase_init_var (&ordering, iter->subject, SC_ASCEND);
1114 iter->writer = sort_create_writer (&ordering, proto);
1115 subcase_destroy (&ordering);
1116 caseproto_unref (proto);
1122 if (iter->moments == NULL)
1123 iter->moments = moments1_create (MOMENT_VARIANCE);
1125 moments1_clear (iter->moments);