Merge branch 'master' of /home/john/Development/pspp-window-manager
[pspp-builds.git] / src / data / subcase.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2008, 2009 Free Software Foundation, Inc.
3
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.
8
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.
13
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/>. */
16
17 #include <config.h>
18 #include <data/subcase.h>
19 #include <stdlib.h>
20 #include <data/case.h>
21 #include <data/variable.h>
22 #include <libpspp/assertion.h>
23
24 #include "xalloc.h"
25
26 /* Initializes SC as a subcase that contains no fields. */
27 void
28 subcase_init_empty (struct subcase *sc)
29 {
30   sc->fields = NULL;
31   sc->n_fields = 0;
32   sc->n_values = 0;
33 }
34
35 /* Initializes SC as a subcase with fields extracted from the
36    N_VARS variables in VARS, with ascending sort order. */
37 void
38 subcase_init_vars (struct subcase *sc,
39                    const struct variable *const *vars, size_t n_vars)
40 {
41   size_t i;
42
43   sc->fields = xnmalloc (n_vars, sizeof *sc->fields);
44   sc->n_fields = n_vars;
45   sc->n_values = 0;
46   for (i = 0; i < n_vars; i++)
47     {
48       struct subcase_field *field = &sc->fields[i];
49       field->case_index = var_get_case_index (vars[i]);
50       field->width = var_get_width (vars[i]);
51       field->direction = SC_ASCEND;
52       sc->n_values += value_cnt_from_width (field->width);
53     }
54 }
55
56 /* Initializes SC as a subcase with a single field extracted
57    from VAR, with the sort order specified by DIRECTION.  */
58 void
59 subcase_init_var (struct subcase *sc, const struct variable *var,
60                   enum subcase_direction direction)
61 {
62   subcase_init_empty (sc);
63   subcase_add_var (sc, var, direction);
64 }
65
66 /* Removes all the fields from SC. */
67 void
68 subcase_clear (struct subcase *sc)
69 {
70   sc->n_fields = 0;
71   sc->n_values = 0;
72 }
73
74 /* Initializes SC with the same fields as ORIG. */
75 void
76 subcase_clone (struct subcase *sc, const struct subcase *orig)
77 {
78   sc->fields = xmemdup (orig->fields, orig->n_fields * sizeof *orig->fields);
79   sc->n_fields = orig->n_fields;
80   sc->n_values = orig->n_values;
81 }
82
83 /* Frees the memory owned by SC (but not SC itself). */
84 void
85 subcase_destroy (struct subcase *sc)
86 {
87   free (sc->fields);
88 }
89
90 /* Add a field for VAR to SC, with DIRECTION as the sort order.
91    Returns true if successful, false if VAR already has a field
92    in SC. */
93 bool
94 subcase_add_var (struct subcase *sc, const struct variable *var,
95                  enum subcase_direction direction)
96 {
97   size_t case_index = var_get_case_index (var);
98   struct subcase_field *field;
99   size_t i;
100
101   for (i = 0; i < sc->n_fields; i++)
102     if (sc->fields[i].case_index == case_index)
103       return false;
104
105   sc->fields = xnrealloc (sc->fields, sc->n_fields + 1, sizeof *sc->fields);
106   field = &sc->fields[sc->n_fields++];
107   field->case_index = case_index;
108   field->width = var_get_width (var);
109   field->direction = direction;
110   sc->n_values += value_cnt_from_width (field->width);
111   return true;
112 }
113
114 /* Returns true if and only if A and B are conformable, which
115    means that they have the same number of fields and that each
116    corresponding field in A and B have the same width. */
117 bool
118 subcase_conformable (const struct subcase *a, const struct subcase *b)
119 {
120   size_t i;
121
122   if (a == b)
123     return true;
124   if (a->n_values != b->n_values || a->n_fields != b->n_fields)
125     return false;
126   for (i = 0; i < a->n_fields; i++)
127     if (a->fields[i].width != b->fields[i].width)
128       return false;
129   return true;
130 }
131
132 /* Copies the fields represented by SC from C into VALUES.
133    VALUES must have space for at least subcase_get_n_values(SC)
134    array elements. */
135 void
136 subcase_extract (const struct subcase *sc, const struct ccase *c,
137                  union value values[])
138 {
139   size_t i;
140
141   for (i = 0; i < sc->n_fields; i++)
142     {
143       const struct subcase_field *field = &sc->fields[i];
144       value_copy (values, case_data_idx (c, field->case_index), field->width);
145       values += value_cnt_from_width (field->width);
146     }
147 }
148
149 /* Copies the data in VALUES into the fields in C represented by
150    SC.  VALUES must have at least subcase_get_n_values(SC) array
151    elements, and C must be large enough to contain all the fields
152    in SC. */
153 void
154 subcase_inject (const struct subcase *sc,
155                 const union value values[], struct ccase *c)
156 {
157   size_t i;
158
159   for (i = 0; i < sc->n_fields; i++)
160     {
161       const struct subcase_field *field = &sc->fields[i];
162       value_copy (case_data_rw_idx (c, field->case_index), values,
163                   field->width);
164       values += value_cnt_from_width (field->width);
165     }
166 }
167
168 /* Copies the fields in SRC represented by SRC_SC into the
169    corresponding fields in DST respresented by DST_SC.  SRC_SC
170    and DST_SC must be conformable (as tested by
171    subcase_conformable()).
172
173    DST must not be shared. */
174 void
175 subcase_copy (const struct subcase *src_sc, const struct ccase *src,
176               const struct subcase *dst_sc, struct ccase *dst)
177 {
178   size_t i;
179
180   expensive_assert (subcase_conformable (src_sc, dst_sc));
181   for (i = 0; i < src_sc->n_fields; i++)
182     {
183       const struct subcase_field *src_field = &src_sc->fields[i];
184       const struct subcase_field *dst_field = &dst_sc->fields[i];
185       value_copy (case_data_rw_idx (dst, dst_field->case_index),
186                   case_data_idx (src, src_field->case_index),
187                   src_field->width);
188     }
189 }
190
191 /* Compares the fields in A specified in A_SC against the fields
192    in B specified in B_SC.  Returns -1, 0, or 1 if A's fields are
193    lexicographically less than, equal to, or greater than B's
194    fields, respectively.
195
196    A_SC and B_SC must be conformable (as tested by
197    subcase_conformable()). */
198 int
199 subcase_compare_3way (const struct subcase *a_sc, const struct ccase *a,
200                       const struct subcase *b_sc, const struct ccase *b)
201 {
202   size_t i;
203
204   expensive_assert (subcase_conformable (a_sc, b_sc));
205   for (i = 0; i < a_sc->n_fields; i++)
206     {
207       const struct subcase_field *a_field = &a_sc->fields[i];
208       const struct subcase_field *b_field = &b_sc->fields[i];
209       int cmp = value_compare_3way (case_data_idx (a, a_field->case_index),
210                                     case_data_idx (b, b_field->case_index),
211                                     a_field->width);
212       if (cmp != 0)
213         return a_field->direction == SC_ASCEND ? cmp : -cmp;
214     }
215   return 0;
216 }
217
218 /* Compares the values in A against the values in B specified by
219    SC's fields.  Returns -1, 0, or 1 if A's values are
220    lexicographically less than, equal to, or greater than B's
221    values, respectively. */
222 int
223 subcase_compare_3way_xc (const struct subcase *sc,
224                          const union value a[], const struct ccase *b)
225 {
226   size_t i;
227
228   for (i = 0; i < sc->n_fields; i++)
229     {
230       const struct subcase_field *field = &sc->fields[i];
231       int cmp = value_compare_3way (a, case_data_idx (b, field->case_index),
232                                     field->width);
233       if (cmp != 0)
234         return field->direction == SC_ASCEND ? cmp : -cmp;
235       a += value_cnt_from_width (field->width);
236     }
237   return 0;
238 }
239
240 /* Compares the values in A specified by SC's fields against the
241    values in B.  Returns -1, 0, or 1 if A's values are
242    lexicographically less than, equal to, or greater than B's
243    values, respectively. */
244 int
245 subcase_compare_3way_cx (const struct subcase *sc,
246                          const struct ccase *a, const union value b[])
247 {
248   return -subcase_compare_3way_xc (sc, b, a);
249 }
250
251 /* Compares the values in A against the values in B, using SC to
252    obtain the number and width of each value.  Returns -1, 0, or
253    1 if A's values are lexicographically less than, equal to, or
254    greater than B's values, respectively. */
255 int
256 subcase_compare_3way_xx (const struct subcase *sc,
257                          const union value a[], const union value b[])
258 {
259   size_t i;
260
261   for (i = 0; i < sc->n_fields; i++)
262     {
263       const struct subcase_field *field = &sc->fields[i];
264       size_t n_values;
265       int cmp;
266
267       cmp = value_compare_3way (a, b, field->width);
268       if (cmp != 0)
269         return field->direction == SC_ASCEND ? cmp : -cmp;
270
271       n_values = value_cnt_from_width (field->width);
272       a += n_values;
273       b += n_values;
274     }
275   return 0;
276 }
277
278 /* Compares the fields in A specified in A_SC against the fields
279    in B specified in B_SC.  Returns true if the fields' values
280    are equal, false otherwise.
281
282    A_SC and B_SC must be conformable (as tested by
283    subcase_conformable()). */
284 bool
285 subcase_equal (const struct subcase *a_sc, const struct ccase *a,
286                const struct subcase *b_sc, const struct ccase *b)
287 {
288   return subcase_compare_3way (a_sc, a, b_sc, b) == 0;
289 }
290
291 /* Compares the values in A against the values in B specified by
292    SC's fields.  Returns true if A's values are equal to B's
293    values, otherwise false. */
294 bool
295 subcase_equal_xc (const struct subcase *sc,
296                   const union value a[], const struct ccase *b)
297 {
298   return subcase_compare_3way_xc (sc, a, b) == 0;
299 }
300
301 /* Compares the values in A specified by SC's fields against the
302    values in B.  Returns true if A's values are equal to B's
303    values, otherwise false. */
304 bool
305 subcase_equal_cx (const struct subcase *sc,
306                   const struct ccase *a, const union value b[])
307 {
308   return subcase_compare_3way_cx (sc, a, b) == 0;
309 }
310
311 /* Compares the values in A against the values in B, using SC to
312    obtain the number and width of each value.  Returns true if
313    A's values are equal to B's values, otherwise false. */
314 bool
315 subcase_equal_xx (const struct subcase *sc,
316                   const union value a[], const union value b[])
317 {
318   return subcase_compare_3way_xx (sc, a, b) == 0;
319 }
320