From: Ben Pfaff Date: Mon, 27 Dec 2021 00:01:47 +0000 (-0800) Subject: CTABLES X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?p=pspp;a=commitdiff_plain;h=cee6f0eb54144da7034566fa1bcdcee22337ae6a CTABLES --- diff --git a/doc/automake.mk b/doc/automake.mk index 83209001d1..e99b82c6ee 100644 --- a/doc/automake.mk +++ b/doc/automake.mk @@ -117,6 +117,28 @@ FIGURE_SYNTAX = \ doc/pspp-figures/chisquare.sps \ doc/pspp-figures/compute.sps \ doc/pspp-figures/count.sps \ + doc/pspp-figures/ctables1.sps \ + doc/pspp-figures/ctables2.sps \ + doc/pspp-figures/ctables3.sps \ + doc/pspp-figures/ctables4.sps \ + doc/pspp-figures/ctables5.sps \ + doc/pspp-figures/ctables6.sps \ + doc/pspp-figures/ctables7.sps \ + doc/pspp-figures/ctables8.sps \ + doc/pspp-figures/ctables9.sps \ + doc/pspp-figures/ctables10.sps \ + doc/pspp-figures/ctables11.sps \ + doc/pspp-figures/ctables12.sps \ + doc/pspp-figures/ctables13.sps \ + doc/pspp-figures/ctables14.sps \ + doc/pspp-figures/ctables15.sps \ + doc/pspp-figures/ctables16.sps \ + doc/pspp-figures/ctables17.sps \ + doc/pspp-figures/ctables18.sps \ + doc/pspp-figures/ctables19.sps \ + doc/pspp-figures/ctables20.sps \ + doc/pspp-figures/ctables21.sps \ + doc/pspp-figures/ctables22.sps \ doc/pspp-figures/crosstabs.sps \ doc/pspp-figures/descriptives.sps \ doc/pspp-figures/flip.sps \ @@ -246,6 +268,13 @@ EXTRA_DIST += doc/tutorial.stt .spv.html: $(convert) -O format=html -O bare=true +# Make sure that tutorial.stt outputs all layers, because a few of the +# examples in the manual rely on that and it would be easy to replace +# it with a style that didn't. +ALL_LOCAL += tutorial-stt-must-print-all-layers +tutorial-stt-must-print-all-layers: + $(AM_V_GEN)grep 'printAllLayers="true"' $(srcdir)/doc/tutorial.stt >/dev/null 2>&1 && touch $@ + # Convert a text file into a Texinfo file. .txt.texi: $(AM_V_GEN)$(SED) -e 's/@/@@/g' $< > $@ diff --git a/doc/pspp-figures/ctables1.sps b/doc/pspp-figures/ctables1.sps new file mode 100644 index 0000000000..4876fa23f8 --- /dev/null +++ b/doc/pspp-figures/ctables1.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=AgeGroup. \ No newline at end of file diff --git a/doc/pspp-figures/ctables10.sps b/doc/pspp-figures/ctables10.sps new file mode 100644 index 0000000000..8adb5ff336 --- /dev/null +++ b/doc/pspp-figures/ctables10.sps @@ -0,0 +1,4 @@ +GET FILE='nhtsa.sav'. +CTABLES + /TABLE=qnd1 [MEAN, MEDIAN] BY qns3a + /TABLE=AgeGroup [COLPCT, ROWPCT] BY qns3a. diff --git a/doc/pspp-figures/ctables11.sps b/doc/pspp-figures/ctables11.sps new file mode 100644 index 0000000000..d2e064c4cb --- /dev/null +++ b/doc/pspp-figures/ctables11.sps @@ -0,0 +1,4 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=AgeGroup [COLPCT 'Gender %' PCT5.0, + ROWPCT 'Age Group %' PCT5.0] + BY qns3a. diff --git a/doc/pspp-figures/ctables12.sps b/doc/pspp-figures/ctables12.sps new file mode 100644 index 0000000000..0ec07bb344 --- /dev/null +++ b/doc/pspp-figures/ctables12.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=(AgeGroup + qns1)[COLPCT] BY qns3a. diff --git a/doc/pspp-figures/ctables13.sps b/doc/pspp-figures/ctables13.sps new file mode 100644 index 0000000000..723dbeda31 --- /dev/null +++ b/doc/pspp-figures/ctables13.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=qnd1 [MEAN, MEDIAN] BY qns3a. diff --git a/doc/pspp-figures/ctables14.sps b/doc/pspp-figures/ctables14.sps new file mode 100644 index 0000000000..168d237f17 --- /dev/null +++ b/doc/pspp-figures/ctables14.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=qnd1 [MEAN, MEDIAN] BY qns3a /SLABELS POSITION=ROW. diff --git a/doc/pspp-figures/ctables15.sps b/doc/pspp-figures/ctables15.sps new file mode 100644 index 0000000000..c8b86f7162 --- /dev/null +++ b/doc/pspp-figures/ctables15.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=AgeGroup [TABLEPCT] /SLABELS VISIBLE=NO. diff --git a/doc/pspp-figures/ctables16.sps b/doc/pspp-figures/ctables16.sps new file mode 100644 index 0000000000..5812acef97 --- /dev/null +++ b/doc/pspp-figures/ctables16.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE AgeGroup BY qns3a. diff --git a/doc/pspp-figures/ctables17.sps b/doc/pspp-figures/ctables17.sps new file mode 100644 index 0000000000..191703384a --- /dev/null +++ b/doc/pspp-figures/ctables17.sps @@ -0,0 +1,4 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS ROWLABELS=OPPOSITE. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS COLLABELS=OPPOSITE. + diff --git a/doc/pspp-figures/ctables18.sps b/doc/pspp-figures/ctables18.sps new file mode 100644 index 0000000000..71248785cc --- /dev/null +++ b/doc/pspp-figures/ctables18.sps @@ -0,0 +1,9 @@ +DATA LIST LIST NOTABLE/x y z. +BEGIN DATA. +1 . 40 +1 10 50 +1 20 60 +1 30 . +END DATA. +VARIABLE LEVEL x (NOMINAL). +LIST. \ No newline at end of file diff --git a/doc/pspp-figures/ctables19.sps b/doc/pspp-figures/ctables19.sps new file mode 100644 index 0000000000..ada8823bcc --- /dev/null +++ b/doc/pspp-figures/ctables19.sps @@ -0,0 +1,9 @@ +DATA LIST LIST NOTABLE/x y z. +BEGIN DATA. +1 . 40 +1 10 50 +1 20 60 +1 30 . +END DATA. +VARIABLE LEVEL x (NOMINAL). +CTABLES /TABLE (y + z) > x. diff --git a/doc/pspp-figures/ctables2.sps b/doc/pspp-figures/ctables2.sps new file mode 100644 index 0000000000..38b09aadda --- /dev/null +++ b/doc/pspp-figures/ctables2.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE=AgeGroup BY qns3a. \ No newline at end of file diff --git a/doc/pspp-figures/ctables20.sps b/doc/pspp-figures/ctables20.sps new file mode 100644 index 0000000000..6814a274e5 --- /dev/null +++ b/doc/pspp-figures/ctables20.sps @@ -0,0 +1,10 @@ +DATA LIST LIST NOTABLE/x y z. +BEGIN DATA. +1 . 40 +1 10 50 +1 20 60 +1 30 . +END DATA. +VARIABLE LEVEL x (NOMINAL). +CTABLES /SMISSING LISTWISE /TABLE (y + z) > x. + diff --git a/doc/pspp-figures/ctables21.sps b/doc/pspp-figures/ctables21.sps new file mode 100644 index 0000000000..8fb18d8b2b --- /dev/null +++ b/doc/pspp-figures/ctables21.sps @@ -0,0 +1,11 @@ +DATA LIST LIST NOTABLE/x y z. +BEGIN DATA. +1 . 40 +1 10 50 +1 20 60 +1 30 . +END DATA. +VARIABLE LEVEL x (NOMINAL). +CTABLES /SMISSING LISTWISE /TABLE (y > x) + (z > x). + + diff --git a/doc/pspp-figures/ctables22.sps b/doc/pspp-figures/ctables22.sps new file mode 100644 index 0000000000..396fbd3939 --- /dev/null +++ b/doc/pspp-figures/ctables22.sps @@ -0,0 +1,5 @@ +GET FILE='nhtsa.sav'. +CTABLES + /VLABELS VARIABLES=ALL DISPLAY=NAME + /TABLE qn61 > qn57 BY qnd7a > qn86 + qn64b BY qns3a[TABLE.ID, LAYER.ID, SUBTABLE.ID] + /SLABELS POSITION=ROW. diff --git a/doc/pspp-figures/ctables3.sps b/doc/pspp-figures/ctables3.sps new file mode 100644 index 0000000000..4736cce247 --- /dev/null +++ b/doc/pspp-figures/ctables3.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE AgeGroup > qns3a BY qn86. diff --git a/doc/pspp-figures/ctables4.sps b/doc/pspp-figures/ctables4.sps new file mode 100644 index 0000000000..4ddee23ef6 --- /dev/null +++ b/doc/pspp-figures/ctables4.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE AgeGroup + qn1 BY qns3a. diff --git a/doc/pspp-figures/ctables5.sps b/doc/pspp-figures/ctables5.sps new file mode 100644 index 0000000000..ba12f4b7a2 --- /dev/null +++ b/doc/pspp-figures/ctables5.sps @@ -0,0 +1,3 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE qn26 + qn27 > qns3a. +CTABLES /TABLE (qn26 + qn27) > qns3a. diff --git a/doc/pspp-figures/ctables6.sps b/doc/pspp-figures/ctables6.sps new file mode 100644 index 0000000000..9cbaf89cc5 --- /dev/null +++ b/doc/pspp-figures/ctables6.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE qnd1. diff --git a/doc/pspp-figures/ctables7.sps b/doc/pspp-figures/ctables7.sps new file mode 100644 index 0000000000..678570a26b --- /dev/null +++ b/doc/pspp-figures/ctables7.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE qnd1 > qns3a BY lang. diff --git a/doc/pspp-figures/ctables8.sps b/doc/pspp-figures/ctables8.sps new file mode 100644 index 0000000000..799195ace5 --- /dev/null +++ b/doc/pspp-figures/ctables8.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE qns3a > qnd1 BY lang. diff --git a/doc/pspp-figures/ctables9.sps b/doc/pspp-figures/ctables9.sps new file mode 100644 index 0000000000..133d0d7d01 --- /dev/null +++ b/doc/pspp-figures/ctables9.sps @@ -0,0 +1,2 @@ +GET FILE='nhtsa.sav'. +CTABLES /TABLE qn20 [C] BY qns3a. diff --git a/doc/statistics.texi b/doc/statistics.texi index 01976e27c9..75de355bd0 100644 --- a/doc/statistics.texi +++ b/doc/statistics.texi @@ -20,6 +20,7 @@ far. * GRAPH:: Plot data. * CORRELATIONS:: Correlation tables. * CROSSTABS:: Crosstabulation tables. +* CTABLES:: Custom tables. * FACTOR:: Factor analysis and Principal Components analysis. * GLM:: Univariate Linear Models. * LOGISTIC REGRESSION:: Bivariate Logistic Regression. @@ -29,7 +30,6 @@ far. * ONEWAY:: One way analysis of variance. * QUICK CLUSTER:: K-Means clustering. * RANK:: Compute rank scores. -* REGRESSION:: Linear regression. * RELIABILITY:: Reliability analysis. * ROC:: Receiver Operating Characteristic. @end menu @@ -897,6 +897,1022 @@ person's occupation. @caption {The results of a test of independence between @exvar{sex} and @exvar{occupation}} @end float +@node CTABLES +@section CTABLES + +@vindex CTABLES +@cindex custom tables +@cindex tables, custom + +@code{CTABLES} has the following overall syntax. At least one +@code{TABLE} subcommand is required: + +@display +@t{CTABLES} + @dots{}@i{global subcommands}@dots{} + [@t{/TABLE} @i{axis} [@t{BY} @i{axis} [@t{BY} @i{axis}]] + @dots{}@i{per-table subcommands}@dots{}]@dots{} +@end display + +@noindent +where each @i{axis} may be empty or take one of the following forms: + +@display +@i{variable} +@i{variable} @t{[}@{@t{C} @math{|} @t{S}@}@t{]} +@i{axis} + @i{axis} +@i{axis} > @i{axis} +(@i{axis}) +@i{axis} @t{[}@i{summary} [@i{string}] [@i{format}]@t{]} +@end display + +The following subcommands precede the first @code{TABLE} subcommand +and apply to all of the output tables. All of these subcommands are +optional: + +@display +@t{/FORMAT} + [@t{MINCOLWIDTH=}@{@t{DEFAULT} @math{|} @i{width}@}] + [@t{MAXCOLWIDTH=}@{@t{DEFAULT} @math{|} @i{width}@}] + [@t{UNITS=}@{@t{POINTS} @math{|} @t{INCHES} @math{|} @t{CM}@}] + [@t{EMPTY=}@{@t{ZERO} @math{|} @t{BLANK} @math{|} @i{string}@}] + [@t{MISSING=}@i{string}] +@t{/VLABELS} + @t{VARIABLES=}@i{variables} + @t{DISPLAY}=@{@t{DEFAULT} @math{|} @t{NAME} @math{|} @t{LABEL} @math{|} @t{BOTH} @math{|} @t{NONE}@} +@ignore @c not yet implemented +@t{/MRSETS COUNTDUPLICATES=}@{@t{YES} @math{|} @t{NO}@} +@end ignore +@t{/SMISSING} @{@t{VARIABLE} @math{|} @t{LISTWISE}@} +@t{/PCOMPUTE} @t{&}@i{postcompute}@t{=EXPR(}@i{expression}@t{)} +@t{/PPROPERTIES} @t{&}@i{postcompute}@dots{} + [@t{LABEL=}@i{string}] + [@t{FORMAT=}[@i{summary} @i{format}]@dots{}] + [@t{HIDESOURCECATS=}@{@t{NO} @math{|} @t{YES}@} +@t{/WEIGHT VARIABLE=}@i{variable} +@t{/HIDESMALLCOUNTS COUNT=@i{count}} +@end display + +The following subcommands follow @code{TABLE} and apply only to the +previous @code{TABLE}. All of these subcommands are optional: + +@display +@t{/SLABELS} + [@t{POSITION=}@{@t{COLUMN} @math{|} @t{ROW} @math{|} @t{LAYER}@}] + [@t{VISIBLE=}@{@t{YES} @math{|} @t{NO}@}] +@t{/CLABELS} @{@t{AUTO} @math{|} @{@t{ROWLABELS}@math{|}@t{COLLABELS}@}@t{=}@{@t{OPPOSITE}@math{|}@t{LAYER}@}@} +@t{/CATEGORIES} @t{VARIABLES=}@i{variables} + @{@t{[}@i{value}@t{,} @i{value}@dots{}@t{]} + @math{|} [@t{ORDER=}@{@t{A} @math{|} @t{D}@}] + [@t{KEY=}@{@t{VALUE} @math{|} @t{LABEL} @math{|} @i{summary}@t{(}@i{variable}@t{)}@}] + [@t{MISSING=}@{@t{EXCLUDE} @math{|} @t{INCLUDE}@}]@} + [@t{TOTAL=}@{@t{NO} @math{|} @t{YES}@} [@t{LABEL=}@i{string}] [@t{POSITION=}@{@t{AFTER} @math{|} @t{BEFORE}@}]] + [@t{EMPTY=}@{@t{INCLUDE} @math{|} @t{EXCLUDE}@}] +@t{/TITLES} + [@t{TITLE=}@i{string}@dots{}] + [@t{CAPTION=}@i{string}@dots{}] + [@t{CORNER=}@i{string}@dots{}] +@ignore @c not yet implemented +@t{/CRITERIA CILEVEL=}@i{percentage} +@t{/SIGTEST TYPE=CHISQUARE} + [@t{ALPHA=}@i{siglevel}] + [@t{INCLUDEMRSETS=}@{@t{YES} @math{|} @t{NO}@}] + [@t{CATEGORIES=}@{@t{ALLVISIBLE} @math{|} @t{SUBTOTALS}@}] +@t{/COMPARETEST TYPE=}@{@t{PROP} @math{|} @t{MEAN}@} + [@t{ALPHA=}@i{value}[@t{,} @i{value}]] + [@t{ADJUST=}@{@t{BONFERRONI} @math{|} @t{BH} @math{|} @t{NONE}@}] + [@t{INCLUDEMRSETS=}@{@t{YES} @math{|} @t{NO}@}] + [@t{MEANSVARIANCE=}@{@t{ALLCATS} @math{|} @t{TESTEDCATS}@}] + [@t{CATEGORIES=}@{@t{ALLVISIBLE} @math{|} @t{SUBTOTALS}@}] + [@t{MERGE=}@{@t{NO} @math{|} @t{YES}@}] + [@t{STYLE=}@{@t{APA} @math{|} @t{SIMPLE}@}] + [@t{SHOWSIG=}@{@t{NO} @math{|} @t{YES}@}] +@end ignore +@end display + +The @code{CTABLES} (aka ``custom tables'') command produces +multi-dimensional tables from categorical and scale data. It offers +many options for data summarization and formatting. + +This section's examples use data from the 2008 (USA) National Survey +of Drinking and Driving Attitudes and Behaviors, a public domain data +set from the (USA) National Highway Traffic Administration and +available at @url{https://data.transportation.gov}. @pspp{} includes +this data set, with a slightly modified dictionary, as +@file{examples/nhtsa.sav}. + +@node CTABLES Basics +@subsection Basics + +The only required subcommand is @code{TABLE}, which specifies the +variables to include along each axis: +@display +@t{/TABLE} @i{rows} [@t{BY} @i{columns} [@t{BY} @i{layers}]] +@end display +@noindent +In @code{TABLE}, each of @var{rows}, @var{columns}, and @var{layers} +is either empty or an axis expression that specifies one or more +variables. At least one must specify an axis expression. + +@menu +* CTABLES Categorical Variable Basics:: +* CTABLES Scalar Variable Basics:: +* CTABLES Overriding Measurement Level:: +@end menu + +@node CTABLES Categorical Variable Basics +@subsubsection Categorical Variables + +An axis expression that names a categorical variable divides the data +into cells according to the values of that variable. When all the +variables named on @code{TABLE} are categorical, by default each cell +displays the number of cases that it contains, so specifying a single +variable yields a frequency table: + +@example +CTABLES /TABLE=AgeGroup. +@end example +@psppoutput {ctables1} + +@noindent +Specifying a row and a column categorical variable yields a +crosstabulation: + +@example +CTABLES /TABLE=AgeGroup BY qns3a. +@end example +@psppoutput {ctables2} + +@noindent +The @samp{>} ``nesting'' operator nests multiple variables on a single +axis, e.g.: + +@example +CTABLES /TABLE qn105ba BY AgeGroup > qns3a. +@end example +@psppoutput {ctables3} + +@noindent +The @samp{+} ``stacking'' operator allows a single output table to +include multiple data analyses. With @samp{+}, @code{CTABLES} divides +the output table into multiple @dfn{sections}, each of which includes +an analysis of the full data set. For example, the following command +separately tabulates age group and driving frequency by gender: + +@example +CTABLES /TABLE AgeGroup + qn1 BY qns3a. +@end example +@psppoutput {ctables4} + +@noindent +When @samp{+} and @samp{>} are used together, @samp{>} binds more +tightly. Use parentheses to override operator precedence. Thus: + +@example +CTABLES /TABLE qn26 + qn27 > qns3a. +CTABLES /TABLE (qn26 + qn27) > qns3a. +@end example +@psppoutput {ctables5} + +@node CTABLES Scalar Variable Basics +@subsubsection Scalar Variables + +For a categorical variable, @code{CTABLES} divides the table into a +cell per category. For a scalar variable, @code{CTABLES} instead +calculates a summary measure, by default the mean, of the values that +fall into a cell. For example, if the only variable specified is a +scalar variable, then the output is a single cell that holds the mean +of all of the data: + +@example +CTABLES /TABLE qnd1. +@end example +@psppoutput {ctables6} + +A scalar variable may nest with categorical variables. The following +example shows the mean age of survey respondents across gender and +language groups: + +@example +CTABLES /TABLE qns3a > qnd1 BY region. +@end example +@psppoutput {ctables7} + +The order of nesting of scalar and categorical variables affects table +labeling, but it does not affect the data displayed in the table. The +following example shows how the output changes when the nesting order +of the scalar and categorical variable are interchanged: + +@example +CTABLES /TABLE qnd1 > qns3a BY region. +@end example +@psppoutput {ctables8} + +Only a single scalar variable may appear in each section; that is, a +scalar variable may not nest inside a scalar variable directly or +indirectly. Scalar variables may only appear on one axis within +@code{TABLE}. + +@node CTABLES Overriding Measurement Level +@subsubsection Overriding Measurement Level + +By default, @code{CTABLES} uses a variable's measurement level to +decide whether to treat it as categorical or scalar. Variables +assigned the nominal or ordinal measurement level are treated as +categorical, and scalar variables are treated as scalar. + +Use the @code{VARIABLE LEVEL} command to change a variable's +measurement level (@pxref{VARIABLE LEVEL}). To treat a variable as +categorical or scalar only for one use on @code{CTABLES}, add +@samp{[C]} or @samp{[S]}, respectively, after the variable name. The +following example shows how to analyze the scalar variable @code{qn20} +as categorical: + +@example +CTABLES /TABLE qn20 [C] BY qns3a. +@end example +@psppoutput {ctables9} + +@ignore +@node CTABLES Multiple Response Sets +@subsubheading Multiple Response Sets + +The @code{CTABLES} command does not yet support multiple response +sets. +@end ignore + +@node CTABLES Data Summarization +@subsection Data Summarization + +The @code{CTABLES} command allows the user to control how the data are +summarized with summary specifications, which are enclosed in square +brackets following a variable name on the @code{TABLE} subcommand. +When all the variables are categorical, summary specifications can be +given for the innermost nested variables on any one axis. When a +scalar variable is present, only the scalar variable may have summary +specifications. The following example includes a summary +specification for column and row percentages for categorical +variables, and mean and median for a scalar variable: + +@example +CTABLES + /TABLE=qnd1 [MEAN, MEDIAN] BY qns3a + /TABLE=AgeGroup [COLPCT, ROWPCT] BY qns3a. +@end example +@psppoutput {ctables10} + +A summary specification may override the default label and format by +appending a string or format specification or both (in that order) to +the summary function name. For example: + +@example +CTABLES /TABLE=AgeGroup [COLPCT 'Gender %' PCT5.0, + ROWPCT 'Age Group %' PCT5.0] + BY qns3a. +@end example +@psppoutput {ctables11} + +Parentheses provide a shorthand to apply summary specifications to +multiple variables. For example, both of these commands: + +@example +CTABLES /TABLE=AgeGroup[COLPCT] + qns1[COLPCT] BY qns3a. +CTABLES /TABLE=(AgeGroup + qns1)[COLPCT] BY qns3a. +@end example + +@noindent +produce the same output shown below: + +@psppoutput {ctables12} + +The following sections list the available summary functions. + +@menu +* CTABLES Summary Functions for Individual Cells:: +* CTABLES Summary Functions for Groups of Cells:: +* CTABLES Summary Functions for Adjusted Weights:: +* CTABLES Unweighted Summary Functions:: +@end menu + +@node CTABLES Summary Functions for Individual Cells +@subsubsection Summary Functions for Individual Cells + +This section lists the summary functions that can be applied to +individual cells in @code{CTABLES}. Only one such summary function, +@code{COUNT}, may be applied to both categorical and scale variables: + +@table @asis +@item @code{COUNT} (``Count'') +The sum of weights in a cell. + +If @code{CATEGORIES} for one or more of the variables in a table +include missing values (@pxref{CTABLES Per-Variable Category +Options}), then some or all of the categories for a cell might be +missing values. @code{COUNT} counts data included in a cell +regardless of whether its categories are missing. +@end table + +The following summary functions apply only to scale variables or +totals and subtotals for categorical variables. Be cautious about +interpreting the summary value in the latter case, because it is not +necessarily meaningful; however, the mean of a Likert scale, etc.@: +may have a straightforward interpreation. + +@table @asis +@item @code{MAXIMUM} (``Maximum'') +The largest value. + +@item @code{MEAN} (``Mean'') +The mean. + +@item @code{MEDIAN} (``Median'') +The median value. + +@item @code{MINIMUM} (``Minimum'') +The smallest value. + +@item @code{MISSING} (``Missing'') +Sum of weights of user- and system-missing values. + +@item @code{MODE} (``Mode'') +The highest-frequency value. Ties are broken by taking the smallest mode. + +@item @code{PTILE} @i{n} (``Percentile @i{n}'') +The @var{n}th percentile, where @math{0 @leq{} @var{n} @leq{} 100}. + +@item @code{RANGE} (``Range'') +The maximum minus the minimum. + +@item @code{SEMEAN} (``Std Error of Mean'') +The standard error of the mean. + +@item @code{STDDEV} (``Std Deviation'') +The standard deviation. + +@item @code{SUM} (``Sum'') +The sum. + +@item @code{TOTALN} (``Total N'') +The sum of weights in a cell. + +For scale data, @code{COUNT} and @code{TOTALN} are the same. + +For categorical data, @code{TOTALN} counts missing values in excluded +categories, that is, user-missing values not in an explicit category +list on @code{CATEGORIES} (@pxref{CTABLES Per-Variable Category +Options}), or user-missing values excluded because +@code{MISSING=EXCLUDE} is in effect on @code{CATEGORIES}, or +system-missing values. @code{COUNT} does not count these. + +@item @code{VALIDN} (``Valid N'') +The sum of valid count weights in included categories. + +@code{VALIDN} does not count missing values regardless of whether they +are in included categories via @code{CATEGORIES}. @code{VALIDN} does +not count valid values that are in excluded categories. + +@item @code{VARIANCE} (``Variance'') +The variance. +@end table + +@node CTABLES Summary Functions for Groups of Cells +@subsubsection Summary Functions for Groups of Cells + +These summary functions summarize over multiple cells within an area +of the output chosen by the user and specified as part of the function +name. The following basic @var{area}s are supported, in decreasing +order of size: + +@table @code +@item TABLE +A @dfn{section}. Stacked variables divide sections of the output from +each other. sections may span multiple layers. + +@item LAYER +A section within a single layer. + +@item SUBTABLE +A @dfn{subtable}, whose contents are the cells that pair an innermost +row variable and an innermost column variable within a single layer. +@end table + +The following shows how the output for the table expression @code{qn61 +> qn57 BY qnd7a > qn86 + qn64b BY qns3a}@footnote{This is not +necessarily a meaningful table, so for clarity variable labels are +omitted.} is divided up into @code{TABLE}, @code{LAYER}, and +@code{SUBTABLE} areas. Each unique value for Table ID is one section, +and similarly for Layer ID and Subtable ID. Thus, this output has two +@code{TABLE} areas (one for @code{qnd7a} and one for @code{qn64b}), +four @code{LAYER} areas (for those two variables, per layer), and 12 +@code{SUBTABLE} areas. +@psppoutput {ctables22} + +@code{CTABLES} also supports the following @var{area}s that further +divide a subtable or a layer within a section: + +@table @code +@item LAYERROW +@itemx LAYERCOL +A row or column, respectively, in one layer of a section. + +@item ROW +@itemx COL +A row or column, respectively, in a subtable. +@end table + +The following summary functions for groups of cells are available for +each @var{area} described above, for both categorical and scale +variables: + +@table @asis +@item @code{@i{area}PCT} or @code{@i{area}PCT.COUNT} (``@i{Area} %'') +A percentage of total counts within @var{area}. + +@item @code{@i{area}PCT.VALIDN} (``@i{Area} Valid N %'') +A percentage of total counts for valid values within @var{area}. + +@item @code{@i{area}PCT.TOTALN} (``@i{Area} Total N %'') +A percentage of total counts for all values within @var{area}. +@end table + +Scale variables and totals and subtotals for categorical variables may +use the following additional group cell summary function: + +@table @asis +@item @code{@i{area}PCT.SUM} (``@i{Area} Sum %'') +Percentage of the sum of the values within @var{area}. +@end table + +@node CTABLES Summary Functions for Adjusted Weights +@subsubsection Summary Functions for Adjusted Weights + +If the @code{WEIGHT} subcommand specified an adjustment weight +variable, then the following summary functions use its value instead +of the dictionary weight variable. Otherwise, they are equivalent to +the summary function without the @samp{E}-prefix: + +@itemize @bullet +@item +@code{ECOUNT} (``Adjusted Count'') + +@item +@code{ETOTALN} (``Adjusted Total N'') + +@item +@code{EVALIDN} (``Adjusted Valid N'') +@end itemize + +@node CTABLES Unweighted Summary Functions +@subsubsection Unweighted Summary Functions + +The following summary functions with a @samp{U}-prefix are equivalent +to the same ones without the prefix, except that they use unweighted +counts: + +@itemize @bullet +@item +@code{UCOUNT} (``Unweighted Count'') + +@item +@code{U@i{area}PCT} or @code{U@i{area}PCT.COUNT} (``Unweighted @i{Area} %'') + +@item +@code{U@i{area}PCT.VALIDN} (``Unweighted @i{Area} Valid N %'') + +@item +@code{U@i{area}PCT.TOTALN} (``Unweighted @i{Area} Total N %'') + +@item +@code{UMEAN} (``Unweighted Mean'') + +@item +@code{UMEDIAN} (``Unweighted Median'') + +@item +@code{UMISSING} (``Unweighted Missing'') + +@item +@code{UMODE} (``Unweight Mode'') + +@item +@code{U@i{area}PCT.SUM} (``Unweighted @i{Area} Sum %'') + +@item +@code{UPTILE} @i{n} (``Unweighted Percentile @i{n}'') + +@item +@code{USEMEAN} (``Unweighted Std Error of Mean'') + +@item +@code{USTDDEV} (``Unweighted Std Deviation'') + +@item +@code{USUM} (``Unweighted Sum'') + +@item +@code{UTOTALN} (``Unweighted Total N'') + +@item +@code{UVALIDN} (``Unweighted Valid N'') + +@item +@code{UVARIANCE} (``Unweighted Variance'') +@end itemize + +@node CTABLES Statistics Positions and Labels +@subsection Statistics Positions and Labels + +@display +@t{/SLABELS} + [@t{POSITION=}@{@t{COLUMN} @math{|} @t{ROW} @math{|} @t{LAYER}@}] + [@t{VISIBLE=}@{@t{YES} @math{|} @t{NO}@}] +@end display + +The @code{SLABELS} subcommand controls the position and visibility of +summary statistics for the @code{TABLE} subcommand that it follows. + +@code{POSITION} sets the axis on which summary statistics appear. +With @t{POSITION=COLUMN}, which is the default, each summary statistic +appears in a column. For example: + +@example +CTABLES /TABLE=qnd1 [MEAN, MEDIAN] BY qns3a. +@end example +@psppoutput {ctables13} + +@noindent +With @t{POSITION=ROW}, each summary statistic appears in a row, as +shown below: + +@example +CTABLES /TABLE=qnd1 [MEAN, MEDIAN] BY qns3a /SLABELS POSITION=ROW. +@end example +@psppoutput {ctables14} + +@noindent +@t{POSITION=LAYER} is also available to place each summary statistic in +a separate layer. + +Labels for summary statistics are shown by default. Use +@t{VISIBLE=NO} to suppress them. Because unlabeled data can cause +confusion, it should only be considered if the meaning of the data is +evident, as in a simple case like this: + +@example +CTABLES /TABLE=AgeGroup [TABLEPCT] /SLABELS VISIBLE=NO. +@end example +@psppoutput {ctables15} + +@node CTABLES Category Label Positions +@subsection Category Label Positions + +@display +@t{/CLABELS} @{@t{AUTO} @math{|} @{@t{ROWLABELS}@math{|}@t{COLLABELS}@}@t{=}@{@t{OPPOSITE}@math{|}@t{LAYER}@}@} +@end display + +The @code{CLABELS} subcommand controls the position of category labels +for the @code{TABLE} subcommand that it follows. By default, or if +@t{AUTO} is specified, category labels for a given variable nest +inside the variable's label on the same axis. For example, the +command below results in age categories nesting within the age group +variable on the rows axis and gender categories within the gender +variable on the columns axis: + +@example +CTABLES /TABLE AgeGroup BY qns3a. +@end example +@psppoutput {ctables16} + +@t{ROWLABELS=OPPOSITE} or @t{COLLABELS=OPPOSITE} move row or column +variable category labels, respectively, to the opposite axis. The +setting affects only the innermost variable on the given axis. For +example: + +@example +CTABLES /TABLE AgeGroup BY qns3a /CLABELS ROWLABELS=OPPOSITE. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS COLLABELS=OPPOSITE. +@end example +@psppoutput {ctables17} + +@t{ROWLABELS=LAYER} or @t{COLLABELS=LAYER} move the innermost row or +column variable category labels, respectively, to the layer axis. + +Only one axis's labels may be moved, whether to the opposite axis or +to the layer axis. + +@node CTABLES Per-Variable Category Options +@subsection Per-Variable Category Options + +@display +@t{/CATEGORIES} @t{VARIABLES=}@i{variables} + @{@t{[}@i{value}@t{,} @i{value}@dots{}@t{]} + @math{|} [@t{ORDER=}@{@t{A} @math{|} @t{D}@}] + [@t{KEY=}@{@t{VALUE} @math{|} @t{LABEL} @math{|} @i{summary}@t{(}@i{variable}@t{)}@}] + [@t{MISSING=}@{@t{EXCLUDE} @math{|} @t{INCLUDE}@}]@} + [@t{TOTAL=}@{@t{NO} @math{|} @t{YES}@} [@t{LABEL=}@i{string}] [@t{POSITION=}@{@t{AFTER} @math{|} @t{BEFORE}@}]] + [@t{EMPTY=}@{@t{INCLUDE} @math{|} @t{EXCLUDE}@}] +@end display + +The @code{CATEGORIES} subcommand specifies, for one or more +categorical variables, the categories to include and exclude, the sort +order for included categories, and treatment of missing values. It +also controls the totals and subtotals to display. It may be +specified any number of times, each time for a different set of +variables. @code{CATEGORIES} applies to the table produced by the +@code{TABLE} subcommand that it follows. + +@code{CATEGORIES} does not apply to scalar variables. + +@t{VARIABLES} is required. List the variables for the subcommand +to affect. + +There are two way to specify the Categories to include and their sort +order: + +@table @asis +@item Explicit categories. +@anchor{CTABLES Explicit Category List} +To explicitly specify categories to include, list the categories +within square brackets in the desired sort order. Use spaces or +commas to separate values. Categories not covered by the list are +excluded from analysis. + +Each element of the list takes one of the following forms: + +@table @t +@item @i{number} +@itemx '@i{string}' +A numeric or string category value, for variables that have the +corresponding type. + +@item '@i{date}' +@itemx '@i{time}' +A date or time category value, for variables that have a date or time +print format. + +@item @i{min} THRU @i{max} +@itemx LO THRU @i{max} +@itemx @i{min} THRU HI +A range of category values, where @var{min} and @var{max} each takes +one of the forms above, in increasing order. + +@item MISSING +All user-missing values. (To match individual user-missing values, +specify their category values.) + +@item OTHERNM +Any non-missing value not covered by any other element of the list +(regardless of where @t{OTHERNM} is placed in the list). + +@item &@i{postcompute} +A computed category name (@pxref{CTABLES Computed Categories}). +@end table + +Additional forms, described later, allow for subtotals. +If multiple elements of the list cover a given category, the last one +in the list is considered to be a match. + +@item Implicit categories. +Without an explicit list of categories, @pspp{} sorts +categories automatically. + +The @code{KEY} setting specifies the sort key. By default, or with +@code{KEY=VALUE}, categories are sorted by default. Categories may +also be sorted by value label, with @code{KEY=LABEL}, or by the value +of a summary function, e.g.@: @code{KEY=COUNT}. For summary +functions, a variable name may be specified in parentheses, e.g.@: +@code{KEY=MAXIUM(qnd1)}, and this is required for functions that apply +only to scalar variables. The @code{PTILE} function also requires a +percentage argument, e.g.@: @code{KEY=PTILE(qnd1, 90)}. Only summary +functions used in the table may be used, except that @code{COUNT} is +always allowed. + +By default, or with @code{ORDER=A}, categories are sorted in ascending +order. Specify @code{ORDER=D} to sort in descending order. + +User-missing values are excluded by default, or with +@code{MISSING=EXCLUDE}. Specify @code{MISSING=INCLUDE} to include +user-missing values. The system-missing value is always excluded. +@end table + +@subsubheading Totals and Subtotals + +@code{CATEGORIES} also controls display of totals and subtotals. +Totals are not displayed by default, or with @code{TOTAL=NO}. Specify +@code{TOTAL=YES} to display a total. By default, the total is labeled +``Total''; use @code{LABEL="@i{label}"} to override it. + +Subtotals are also not displayed by default. To add one or more +subtotals, use an explicit category list and insert @code{SUBTOTAL} or +@code{HSUBTOTAL} in the position or positions where the subtotal +should appear. With @code{SUBTOTAL}, the subtotal becomes an extra +row or column or layer; @code{HSUBTOTAL} additionally hides the +categories that make up the subtotal. Either way, the default label +is ``Subtotal'', use @code{SUBTOTAL="@i{label}"} or +@code{HSUBTOTAL="@i{label}"} to specify a custom label. + +By default, or with @code{POSITION=AFTER}, totals come after the last +category and subtotals apply to categories that precede them. With +@code{POSITION=BEFORE}, totals come before the first category and +subtotals apply to categories that follow them. + +Only categorical variables may have totals and subtotals. Scalar +variables may be ``totaled'' indirectly by enabling totals and +subtotals on a categorical variable within which the scalar variable is +summarized. + +@subsubheading Categories Without Values + +Some categories might not be included in the data set being analyzed. +For example, our example data set has no cases in the ``15 or +younger'' age group. By default, or with @code{EMPTY=INCLUDE}, +@pspp{} includes these empty categories in output tables. To exclude +them, specify @code{EMPTY=EXCLUDE}. + +For implicit categories, empty categories potentially include all the +values with labels for a given variable; for explicit categories, they +include all the values listed individually and all labeled values +covered by ranges or @code{MISSING} or @code{OTHERNM}. + +@node CTABLES Titles +@subsection Titles + +@display +@t{/TITLES} + [@t{TITLE=}@i{string}@dots{}] + [@t{CAPTION=}@i{string}@dots{}] + [@t{CORNER=}@i{string}@dots{}] +@end display + +The @code{TITLES} subcommand sets the title, caption, and corner text +for the table output for the previous @code{TABLE} subcommand. The +title appears above the table, the caption below the table, and the +corner text appears in the table's upper left corner. By default, the +title is ``Custom Tables'' and the caption and corner text are empty. + +@node CTABLES Table Formatting +@subsection Table Formatting + +@display +@t{/FORMAT} + [@t{MINCOLWIDTH=}@{@t{DEFAULT} @math{|} @i{width}@}] + [@t{MAXCOLWIDTH=}@{@t{DEFAULT} @math{|} @i{width}@}] + [@t{UNITS=}@{@t{POINTS} @math{|} @t{INCHES} @math{|} @t{CM}@}] + [@t{EMPTY=}@{@t{ZERO} @math{|} @t{BLANK} @math{|} @i{string}@}] + [@t{MISSING=}@i{string}] +@end display + +The @code{FORMAT} subcommand, which must precede the first +@code{TABLE} subcommand, controls formatting for all the output +tables. @code{FORMAT} and all of its settings are optional. + +Use @code{MINCOLWIDTH} and @code{MAXCOLWIDTH} to control the minimum +or maximum width of columns in output tables. By default, or with +@code{DEFAULT}, column width varies based on content. Otherwise, +specify a number for either or both of these settings. If both are +specified, @code{MAXCOLWIDTH} must be bigger than @code{MINCOLWIDTH}. +The default unit, or with @code{UNITS=POINTS}, is points (1/72 inch), +but specify @code{UNITS=INCHES} to use inches or @code{UNITS=CM} for +centimeters. + +By default, or with @code{EMPTY=ZERO}, zero values are displayed in +their usual format. Use @code{EMPTY=BLANK} to use an empty cell +instead, or @code{EMPTY="@i{string}"} to use the specified string. + +By default, missing values are displayed as @samp{.}, the same as in +other tables. Specify @code{MISSING="@i{string}"} to instead use a +custom string. + +@node CTABLES Display of Variable Labels +@subsection Display of Variable Labels + +@display +@t{/VLABELS} + @t{VARIABLES=}@i{variables} + @t{DISPLAY}=@{@t{DEFAULT} @math{|} @t{NAME} @math{|} @t{LABEL} @math{|} @t{BOTH} @math{|} @t{NONE}@} +@end display + +The @code{VLABELS} subcommand, which must precede the first +@code{TABLE} subcommand, controls display of variable labels in all +the output tables. @code{VLABELS} is optional. It may appear +multiple times to adjust settings for different variables. + +@code{VARIABLES} and @code{DISPLAY} are required. The value of +@code{DISPLAY} controls how variable labels are displayed for the +variables listed on @code{VARIABLES}. The supported values are: + +@table @code +@item DEFAULT +Uses the setting from @ref{SET TVARS}. + +@item NAME +Show only a variable name. + +@item LABEL +Show only a variable label. + +@item BOTH +Show variable name and label. + +@item NONE +Show nothing. +@end table + +@node CTABLES Missing Value Treatment +@subsection Missing Value Treatment + +@display +@t{/SMISSING} @{@t{VARIABLE} @math{|} @t{LISTWISE}@} +@end display + +The @code{SMISSING} subcommand, which must precede the first +@code{TABLE} subcommand, controls treatment of missing values for +scalar variables in producing all the output tables. @code{SMISSING} +is optional. + +With @code{SMISSING=VARIABLE}, which is the default, missing values +are excluded on a variable-by-variable basis. With +@code{SMISSING=LISTWISE}, when stacked scalar variables are nested +together with a categorical variable, a missing value for any of the +scalar variables causes the case to be excluded for all of them. + +As an example, consider the following dataset, in which @samp{x} is a +categorical variable and @samp{y} and @samp{z} are scale: + +@psppoutput{ctables18} + +@noindent +With the default missing-value treatment, @samp{x}'s mean is 20, based +on the values 10, 20, and 30, and @samp{y}'s mean is 50, based on 40, +50, and 60: + +@example +CTABLES /TABLE (y + z) > x. +@end example +@psppoutput{ctables19} + +@noindent +By adding @code{SMISSING=LISTWISE}, only cases where @samp{y} and +@samp{z} are both non-missing are considered, so @samp{x}'s mean +becomes 15, as the average of 10 and 20, and @samp{y}'s mean becomes +55, the average of 50 and 60: + +@example +CTABLES /SMISSING LISTWISE /TABLE (y + z) > x. +@end example +@psppoutput{ctables20} + +@noindent +Even with @code{SMISSING=LISTWISE}, if @samp{y} and @samp{z} are +separately nested with @samp{x}, instead of using a single @samp{>} +operator, missing values revert to being considered on a +variable-by-variable basis: + +@example +CTABLES /SMISSING LISTWISE /TABLE (y > x) + (z > x). +@end example +@psppoutput{ctables21} + +@node CTABLES Computed Categories +@subsection Computed Categories + +@display +@t{/PCOMPUTE} @t{&}@i{postcompute}@t{=EXPR(}@i{expression}@t{)} +@end display + +@dfn{Computed categories}, also called @dfn{postcomputes}, are +categories created using arithmetic on categories obtained from the +data. The @code{PCOMPUTE} subcommand defines computed categories, +which can then be used in two places: on @code{CATEGORIES} within an +explicit category list (@pxref{CTABLES Explicit Category List}), and on +the @code{PPROPERTIES} subcommand to define further properties for a +given postcompute. + +@code{PCOMPUTE} must precede the first @code{TABLE} command. It is +optional and it may be used any number of times to define multiple +postcomputes. + +Each @code{PCOMPUTE} defines one postcompute. Its syntax consists of +a name to identify the postcompute as a @pspp{} identifier prefixed by +@samp{&}, followed by @samp{=} and a postcompute expression enclosed +in @code{EXPR(@dots{})}. A postcompute expression consists of: + +@table @t +@item [@i{category}] +This form evaluates to the summary statistic for @i{category}, e.g.@: +@code{[1]} evaluates to the value of the summary statistic associated +with category 1. The @i{category} may be a number, a quoted string, +or a quoted time or date value, and all of the categories for a given +postcompute must have the same form. + +@item [@i{min} THRU @i{max}] +@itemx [LO THRU @i{max}] +@itemx [@i{min} THRU HI] +@itemx MISSING +@itemx OTHERNM +These forms evaluate to the summary statistics for categories matching +the given syntax, as described in previous sections (@pxref{CTABLES +Explicit Category List}). If more than one category matches, their +values are summed. + +@item SUBTOTAL +The summary statistic for the subtotal category. This form is allowed +only for variables with exactly one subtotal. + +@item SUBTOTAL[@i{index}] +The summary statistic for subtotal category @i{index}, where 1 is the +first subtotal, 2 is the second, and so on. This form may be used for +any number of subtotals. + +@item TOTAL +The summary statistic for the total. + +@item @i{a} + @i{b} +@itemx @i{a} - @i{b} +@itemx @i{a} * @i{b} +@itemx @i{a} / @i{b} +@itemx @i{a} ** @i{b} +These forms perform arithmetic on the values of postcompute +expressions @i{a} and @i{b}. The usual operator precedence rules +apply. + +@item @i{number} +Numeric constants may be used in postcompute expressions. + +@item (@i{a}) +Parentheses override operator precedence. +@end table + +A postcompute is not associated with any particular variable. +Instead, it may be referenced within @code{CATEGORIES} for any +suitable variable (e.g.@: only a string variable is suitable for a +postcompute expression that refers to a string category, only a +variable with subtotals for an expression that refers to subtotals, +@dots{}). + +Normally a named postcompute is defined only once, but if a later +@code{PCOMPUTE} redefines a postcompute with the same name as an +earlier one, the later one take precedence. + +@node CTABLES Computed Category Properties +@subsection Computed Category Properties + +@display +@t{/PPROPERTIES} @t{&}@i{postcompute}@dots{} + [@t{LABEL=}@i{string}] + [@t{FORMAT=}[@i{summary} @i{format}]@dots{}] + [@t{HIDESOURCECATS=}@{@t{NO} @math{|} @t{YES}@} +@end display + +The @code{PPROPERTIES} subcommand, which must appear before +@code{TABLE}, sets properties for one or more postcomputes defined on +prior @code{PCOMPUTE} subcommands. The subcommand syntax begins with +the list of postcomputes, each prefixed with @samp{&} as specified on +@code{PCOMPUTE}. + +All of the settings on @code{PPROPERTIES} are optional. Use +@code{LABEL} to set the label shown for the postcomputes in table +output. The default label for a postcompute is the expression used to +define it. + +The @code{FORMAT} setting sets summary statistics and display formats +for the postcomputes. + +By default, or with @code{HIDESOURCECATS=NO}, categories referred to +by computed categories are displayed like other categories. Use +@code{HIDESOURCECATS=YES} to hide them. + +@node CTABLES Base Weight +@subsection Base Weight + +@display +@t{/WEIGHT VARIABLE=}@i{variable} +@end display + +The @code{WEIGHT} subcommand is optional and must appear before +@code{TABLE}. If it appears, it must name a numeric variable, known +as the @dfn{effective base weight} or @dfn{adjustment weight}. The +effective base weight variable is used for the @code{ECOUNT}, +@code{ETOTALN}, and @code{EVALIDN} summary functions. + +Cases with zero, missing, or negative effective base weight are +excluded from all analysis. + +Weights obtained from the @pspp{} dictionary are rounded to the +nearest integer. Effective base weights are not rounded. + +@node CTABLES Hiding Small Counts +@subsection Hiding Small Counts + +@display +@t{/HIDESMALLCOUNTS COUNT=@i{count}} +@end display + +The @code{HIDESMALLCOUNTS} subcommand is optional. If it specified, +then count values in output tables less than the value of @i{count} +are shown as @code{<@i{count}} instead of their true values. The +value of @i{count} must be an integer and must be at least 2. Case +weights are considered for deciding whether to hide a count. @node FACTOR @section FACTOR diff --git a/doc/tutorial.stt b/doc/tutorial.stt index 130ae9b23b..5c15a7130d 100644 --- a/doc/tutorial.stt +++ b/doc/tutorial.stt @@ -49,5 +49,5 @@ - + diff --git a/doc/utilities.texi b/doc/utilities.texi index 4cad836ad1..5062ead2eb 100644 --- a/doc/utilities.texi +++ b/doc/utilities.texi @@ -861,6 +861,7 @@ If the value has no label, then the literal value is used for display. If @subcmd{TNUMBERS} is set to @subcmd{BOTH}, then values are displayed with both their label (if any) and their literal value in parentheses. @item TVARS +@anchor{SET TVARS} The @subcmd{TVARS} option sets the way in which variables are displayed in output tables. The valid settings are @subcmd{NAMES}, @subcmd{LABELS} and @subcmd{BOTH}. If @subcmd{TVARS} is set to @subcmd{NAMES}, then all variables are displayed using their names. diff --git a/doc/variables.texi b/doc/variables.texi index 5cc1a23620..ab6f83daea 100644 --- a/doc/variables.texi +++ b/doc/variables.texi @@ -600,18 +600,12 @@ purposes. It does not affect the display of variables in the @pspp{} output. @section VARIABLE LEVEL @vindex VARIABLE LEVEL @display -VARIABLE LEVEL - @var{var_list} ( SCALE | NOMINAL | ORDINAL ) - [ /@var{var_list} ( SCALE | NOMINAL | ORDINAL ) ] - . - . - . - [ /@var{var_list} ( SCALE | NOMINAL | ORDINAL ) ] +@t{VARIABLE LEVEL} @i{variables} @t{(}@{@t{SCALE} @math{|} @t{NOMINAL} @math{|} @t{ORDINAL}@}@t{)}@dots{} @end display -@cmd{VARIABLE LEVEL} sets the measurement level of variables. -Currently, this has no effect except for certain third party software. - +@cmd{VARIABLE LEVEL} sets the measurement level of @var{variables} as +specified. @xref{Attributes}, for the definitions of the available +measurement levels. @node VARIABLE ROLE @section VARIABLE ROLE diff --git a/examples/automake.mk b/examples/automake.mk index fd78765c00..21244bc408 100644 --- a/examples/automake.mk +++ b/examples/automake.mk @@ -25,6 +25,9 @@ examples_DATA = \ examples/grid.sps \ examples/hotel.sav \ examples/horticulture.sav \ + examples/nhtsa.sav \ + examples/nhtsa-drinking-2008.sav \ + examples/nhtsa-drinking-2008.sps \ examples/personnel.sav \ examples/physiology.sav \ examples/repairs.sav \ diff --git a/examples/nhtsa-drinking-2008.sav b/examples/nhtsa-drinking-2008.sav new file mode 100644 index 0000000000..bae9e0109e Binary files /dev/null and b/examples/nhtsa-drinking-2008.sav differ diff --git a/examples/nhtsa-drinking-2008.sps b/examples/nhtsa-drinking-2008.sps new file mode 100644 index 0000000000..2fb83065d7 --- /dev/null +++ b/examples/nhtsa-drinking-2008.sps @@ -0,0 +1,97 @@ +GET 'nhtsa-drinking-2008.sav'. +VARIABLE LEVEL + ALL (NOMINAL) + qns1 qn1 qn15 qn49 qn87 qn103 qn1058ba TO qn105bd qn122c qn139a TO qn139n qn139ca TO qn139cn qn140aa TO qn140af qnd8 qnd11 (ORDINAL) + id qn18 qn19a qn20 qn23 qn31 qn35 qn36 qn38 qn41 qn44 qn52 qn65 qn66 qn114 qn121 qn126 qnd1 qnd1b qnd9 (SCALE). +FORMATS + state qns1 qn1 (F2.0) + qn100 qn102 qn103 qn116 qn123 qn131a qn133 qn139a qn139e qn139g qn139h (F1.0). +MISSING VALUES + qns1 (97, 98, 99) + qn1 (6, 7) + qn15 (8, 9) + qn17 (2, 3) + qn18 (98, 99) + qn19a (97, 98, 99) + qn20 qn23 (98, 99) + qn26 qn27 qn28 qn29 (3, 4) + qn31 (98, 99) + qn33 (3, 4) + qn35 (998, 999) + qn36 (98, 99) + qn37 (2, 3) + qn38 (998, 999) + qn39h (0) + qn39m (0) + qn41 (998, 999) + qn43a (3, 4) + qn44 (98, 99) + qn44a (98, 99) + qn49 (5, 6) + qn52 (998, 999) + qn56 (2, 3) + qn57 (3, 4) + qn61 (3, 4) + qn64b (3, 4) + qn65 (98, 99) + qn65a (3, 4) + qn66 (98, 99) + qn86 (3, 4) + qn87 (6, 7) + qn88_1 qn88_2 qn88_3 (2, 3) + qn89 qn90 qn90a (3, 4) + qn91_1 qn91_2 qn91_3 (2, 3) + qn96a (3, 4) + qn100 (3, 4) + qn101 (2, 3) + qn102 qn102b qn102c (3, 4) + qn103 (4, 5) + qn105ba qn105bb qn105bc qn105bd (6, 7) + qn113 (3, 4) + qn114 (98, 99) + qn116 (7, 8) + qn120 (3, 4) + qn121 (998, 999) + qn122c (6, 7) + qn123 (3, 4) + qn126 (98, 99) + qn131a (3, 4) + qn132a (3, 4) + qn133 (3, 4) + qn139a qn139e qn139g qn139h qn139k qn139l qn139m qn139n (6, 7) + qn139_a (3, 4) + qn139_b (98, 99) + qn139ca qn139ce qn139cf qn139cg qn139ch qn139ck qn139cl qn139cn (6, 7) + qn140aa qn140ab qn140ac qn140ad qn140ae qn140af (6, 7) + qnd1 (998, 999) + qnd1b (8, 9) + qnd2_1 qnd2_2 qnd2_3 (2, 3) + qnd3 (10, 11) + qnd5 (3, 4) + qnd5a (9, 10) + qnd6_1 qnd6_2 qnd6_3 qnd6_4 qnd6_5 (2, 3) + qnd7a (3, 4) + qnd8 (8, 9) + qnd9 (997, 998, 999) + qnd11a (3, 4) + qnd11 (6, 7). +RECODE qnd1 (LO THRU 15=1) + (16 THRU 25=2) + (26 THRU 35=3) + (36 THRU 45=4) + (46 THRU 55=5) + (56 THRU 65=6) + (66 THRU HI=7) + INTO agegroup. +VAR LEVEL agegroup (ORDINAL). +VARIABLE LABEL agegroup 'Age group'. +VALUE LABELS + /agegroup + 1 '15 or younger' + 2 '16 to 25' + 3 '26 to 35' + 4 '36 to 45' + 5 '46 to 55' + 6 '56 to 65' + 7 '66 or older'. +SAVE OUTFILE='nhtsa.sav'. diff --git a/examples/nhtsa.sav b/examples/nhtsa.sav new file mode 100644 index 0000000000..9e63f334c1 Binary files /dev/null and b/examples/nhtsa.sav differ diff --git a/po/automake.mk b/po/automake.mk index f8b326f229..81c659c145 100644 --- a/po/automake.mk +++ b/po/automake.mk @@ -43,7 +43,7 @@ LOCALPOFILES = po/cs.po POTFILE=po/$(DOMAIN).pot -TRANSLATABLE_FILES = $(DIST_SOURCES) $(all_q_sources) +TRANSLATABLE_FILES = $(DIST_SOURCES) XGETTEXT_OPTIONS = \ --copyright-holder="$(COPYRIGHT_HOLDER)" \ diff --git a/src/data/dictionary.c b/src/data/dictionary.c index c13321c782..d04a4f70fa 100644 --- a/src/data/dictionary.c +++ b/src/data/dictionary.c @@ -416,6 +416,12 @@ dict_set_split_vars__ (struct dictionary *d, } } +enum split_type +dict_get_split_type (const struct dictionary *d) +{ + return d->split_type; +} + /* Sets N split vars SPLIT in dictionary D. */ void dict_set_split_vars (struct dictionary *d, diff --git a/src/language/command.def b/src/language/command.def index 352f7c1078..6db5e74e2e 100644 --- a/src/language/command.def +++ b/src/language/command.def @@ -114,6 +114,7 @@ DEF_CMD (S_DATA, 0, "AUTORECODE", cmd_autorecode) DEF_CMD (S_DATA, 0, "BEGIN DATA", cmd_begin_data) DEF_CMD (S_DATA, 0, "COUNT", cmd_count) DEF_CMD (S_DATA, 0, "CROSSTABS", cmd_crosstabs) +DEF_CMD (S_DATA, 0, "CTABLES", cmd_ctables) DEF_CMD (S_DATA, 0, "CORRELATIONS", cmd_correlation) DEF_CMD (S_DATA, 0, "DELETE VARIABLES", cmd_delete_variables) DEF_CMD (S_DATA, 0, "DESCRIPTIVES", cmd_descriptives) @@ -194,7 +195,6 @@ UNIMPL_CMD ("CSLOGISTIC", "Complex samples logistic regression") UNIMPL_CMD ("CSPLAN", "Complex samples design") UNIMPL_CMD ("CSSELECT", "Select complex samples") UNIMPL_CMD ("CSTABULATE", "Tabulate complex samples") -UNIMPL_CMD ("CTABLES", "Display complex samples") UNIMPL_CMD ("CURVEFIT", "Fit curve to line plot") UNIMPL_CMD ("DATE", "Create time series data") UNIMPL_CMD ("DETECTANOMALY", "Find unusual cases") diff --git a/src/language/lexer/format-parser.c b/src/language/lexer/format-parser.c index 85579a2ab2..aa30852d11 100644 --- a/src/language/lexer/format-parser.c +++ b/src/language/lexer/format-parser.c @@ -32,7 +32,16 @@ #include "gettext.h" #define _(msgid) gettext (msgid) -static bool +/* Parses a token taking the form of a format specifier and + returns true only if successful. Emits an error message on + failure. Stores a null-terminated string representing the + format type in TYPE, and the width and number of decimal + places in *WIDTH and *DECIMALS. + + TYPE is not checked as to whether it is really the name of a + format. Both width and decimals are considered optional. If + missing, *WIDTH or *DECIMALS or both will be set to 0. */ +bool parse_abstract_format_specifier__ (struct lexer *lexer, char type[FMT_TYPE_LEN_MAX + 1], uint16_t *width, uint8_t *decimals) @@ -79,15 +88,8 @@ error: return false; } -/* Parses a token taking the form of a format specifier and - returns true only if successful. Emits an error message on - failure. Stores a null-terminated string representing the - format type in TYPE, and the width and number of decimal - places in *WIDTH and *DECIMALS. - - TYPE is not checked as to whether it is really the name of a - format. Both width and decimals are considered optional. If - missing, *WIDTH or *DECIMALS or both will be set to 0. */ +/* Like parse_abstract_format_specifier__(), but additionally advanced past + the token if successful. */ bool parse_abstract_format_specifier (struct lexer *lexer, char type[FMT_TYPE_LEN_MAX + 1], diff --git a/src/language/lexer/format-parser.h b/src/language/lexer/format-parser.h index 7601bc46b2..6316e38762 100644 --- a/src/language/lexer/format-parser.h +++ b/src/language/lexer/format-parser.h @@ -21,14 +21,16 @@ #include "data/format.h" +struct fmt_spec; struct lexer; +bool parse_abstract_format_specifier__ (struct lexer *, + char type[FMT_TYPE_LEN_MAX + 1], + uint16_t *width, uint8_t *decimals); bool parse_abstract_format_specifier (struct lexer *, char type[FMT_TYPE_LEN_MAX + 1], uint16_t *width, uint8_t *decimals); -enum fmt_type ; -struct fmt_spec; bool parse_format_specifier (struct lexer *, struct fmt_spec *); bool parse_format_specifier_name (struct lexer *, enum fmt_type *type); diff --git a/src/language/stats/automake.mk b/src/language/stats/automake.mk index 460e95e707..26284d9f5c 100644 --- a/src/language/stats/automake.mk +++ b/src/language/stats/automake.mk @@ -31,6 +31,8 @@ language_stats_sources = \ src/language/stats/cochran.h \ src/language/stats/correlations.c \ src/language/stats/crosstabs.c \ + src/language/stats/ctables.c \ + src/language/stats/ctables.inc \ src/language/stats/descriptives.c \ src/language/stats/examine.c \ src/language/stats/factor.c \ diff --git a/src/language/stats/ctables.c b/src/language/stats/ctables.c new file mode 100644 index 0000000000..7b7a81946c --- /dev/null +++ b/src/language/stats/ctables.c @@ -0,0 +1,6904 @@ +/* PSPP - a program for statistical analysis. + Copyright (C) 2021 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 . */ + +#include + +#include +#include + +#include "data/casegrouper.h" +#include "data/casereader.h" +#include "data/casewriter.h" +#include "data/data-in.h" +#include "data/data-out.h" +#include "data/dataset.h" +#include "data/dictionary.h" +#include "data/mrset.h" +#include "data/subcase.h" +#include "data/value-labels.h" +#include "language/command.h" +#include "language/dictionary/split-file.h" +#include "language/lexer/format-parser.h" +#include "language/lexer/lexer.h" +#include "language/lexer/token.h" +#include "language/lexer/variable-parser.h" +#include "libpspp/array.h" +#include "libpspp/assertion.h" +#include "libpspp/hash-functions.h" +#include "libpspp/hmap.h" +#include "libpspp/i18n.h" +#include "libpspp/message.h" +#include "libpspp/string-array.h" +#include "math/mode.h" +#include "math/moments.h" +#include "math/percentiles.h" +#include "math/sort.h" +#include "output/pivot-table.h" + +#include "gl/minmax.h" +#include "gl/xalloc.h" + +#include "gettext.h" +#define _(msgid) gettext (msgid) +#define N_(msgid) (msgid) + +enum ctables_vlabel + { + CTVL_NONE = SETTINGS_VALUE_SHOW_DEFAULT, + CTVL_NAME = SETTINGS_VALUE_SHOW_VALUE, + CTVL_LABEL = SETTINGS_VALUE_SHOW_LABEL, + CTVL_BOTH = SETTINGS_VALUE_SHOW_BOTH, + }; + +/* XXX: + - unweighted summaries (U*) + - lower confidence limits (*.LCL) + - upper confidence limits (*.UCL) + - standard error (*.SE) + */ + +enum ctables_summary_function + { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) ENUM, +#include "ctables.inc" +#undef S + }; + +enum { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) +1 + N_CTSF_FUNCTIONS = +#include "ctables.inc" +#undef S +}; + +static bool ctables_summary_function_is_count (enum ctables_summary_function); + +enum ctables_domain_type + { + /* Within a section, where stacked variables divide one section from + another. */ + CTDT_TABLE, /* All layers of a whole section. */ + CTDT_LAYER, /* One layer within a section. */ + CTDT_LAYERROW, /* Row in one layer within a section. */ + CTDT_LAYERCOL, /* Column in one layer within a section. */ + + /* Within a subtable, where a subtable pairs an innermost row variable with + an innermost column variable within a single layer. */ + CTDT_SUBTABLE, /* Whole subtable. */ + CTDT_ROW, /* Row within a subtable. */ + CTDT_COL, /* Column within a subtable. */ +#define N_CTDTS 7 + }; + +struct ctables_domain + { + struct hmap_node node; + + const struct ctables_cell *example; + + size_t sequence; + double d_valid; /* Dictionary weight. */ + double d_count; + double d_total; + double e_valid; /* Effective weight */ + double e_count; + double e_total; + double u_valid; /* Unweighted. */ + double u_count; + double u_total; + struct ctables_sum *sums; + }; + +struct ctables_sum + { + double e_sum; + double u_sum; + }; + +enum ctables_summary_variant + { + CSV_CELL, + CSV_TOTAL +#define N_CSVS 2 + }; + +struct ctables_cell + { + /* In struct ctables_section's 'cells' hmap. Indexed by all the values in + all the axes (except the scalar variable, if any). */ + struct hmap_node node; + + /* The domains that contain this cell. */ + uint32_t omit_domains; + struct ctables_domain *domains[N_CTDTS]; + + bool hide; + + bool postcompute; + enum ctables_summary_variant sv; + + struct ctables_cell_axis + { + struct ctables_cell_value + { + const struct ctables_category *category; + union value value; + } + *cvs; + int leaf; + } + axes[PIVOT_N_AXES]; + + union ctables_summary *summaries; + + //char *name; + }; + +struct ctables + { + const struct dictionary *dict; + struct pivot_table_look *look; + + /* CTABLES has a number of extra formats that we implement via custom + currency specifications on an alternate fmt_settings. */ +#define CTEF_NEGPAREN FMT_CCA +#define CTEF_NEQUAL FMT_CCB +#define CTEF_PAREN FMT_CCC +#define CTEF_PCTPAREN FMT_CCD + struct fmt_settings ctables_formats; + + /* If this is NULL, zeros are displayed using the normal print format. + Otherwise, this string is displayed. */ + char *zero; + + /* If this is NULL, missing values are displayed using the normal print + format. Otherwise, this string is displayed. */ + char *missing; + + /* Indexed by variable dictionary index. */ + enum ctables_vlabel *vlabels; + + struct hmap postcomputes; /* Contains "struct ctables_postcompute"s. */ + + bool mrsets_count_duplicates; /* MRSETS. */ + bool smissing_listwise; /* SMISSING. */ + struct variable *e_weight; /* WEIGHT. */ + int hide_threshold; /* HIDESMALLCOUNTS. */ + + struct ctables_table **tables; + size_t n_tables; + }; + +static struct ctables_postcompute *ctables_find_postcompute (struct ctables *, + const char *name); + +struct ctables_postcompute + { + struct hmap_node hmap_node; /* In struct ctables's 'pcompute' hmap. */ + char *name; /* Name, without leading &. */ + + struct msg_location *location; /* Location of definition. */ + struct ctables_pcexpr *expr; + char *label; + struct ctables_summary_spec_set *specs; + bool hide_source_cats; + }; + +struct ctables_pcexpr + { + /* Precedence table: + + () + ** + - + * / + - + + */ + enum ctables_postcompute_op + { + /* Terminals. */ + CTPO_CONSTANT, /* 5 */ + CTPO_CAT_NUMBER, /* [5] */ + CTPO_CAT_STRING, /* ["STRING"] */ + CTPO_CAT_NRANGE, /* [LO THRU 5] */ + CTPO_CAT_SRANGE, /* ["A" THRU "B"] */ + CTPO_CAT_MISSING, /* MISSING */ + CTPO_CAT_OTHERNM, /* OTHERNM */ + CTPO_CAT_SUBTOTAL, /* SUBTOTAL */ + CTPO_CAT_TOTAL, /* TOTAL */ + + /* Nonterminals. */ + CTPO_ADD, + CTPO_SUB, + CTPO_MUL, + CTPO_DIV, + CTPO_POW, + CTPO_NEG, + } + op; + + union + { + /* CTPO_CAT_NUMBER. */ + double number; + + /* CTPO_CAT_STRING, in dictionary encoding. */ + struct substring string; + + /* CTPO_CAT_NRANGE. */ + double nrange[2]; + + /* CTPO_CAT_SRANGE. */ + struct substring srange[2]; + + /* CTPO_CAT_SUBTOTAL. */ + size_t subtotal_index; + + /* Two elements: CTPO_ADD, CTPO_SUB, CTPO_MUL, CTPO_DIV, CTPO_POW. + One element: CTPO_NEG. */ + struct ctables_pcexpr *subs[2]; + }; + + /* Source location. */ + struct msg_location *location; + }; + +static void ctables_pcexpr_destroy (struct ctables_pcexpr *); +static struct ctables_pcexpr *ctables_pcexpr_allocate_binary ( + enum ctables_postcompute_op, struct ctables_pcexpr *sub0, + struct ctables_pcexpr *sub1); + +struct ctables_summary_spec_set + { + struct ctables_summary_spec *specs; + size_t n; + size_t allocated; + + /* The variable to which the summary specs are applied. */ + struct variable *var; + + /* Whether the variable to which the summary specs are applied is a scale + variable for the purpose of summarization. + + (VALIDN and TOTALN act differently for summarizing scale and categorical + variables.) */ + bool is_scale; + + /* If any of these optional additional scale variables are missing, then + treat 'var' as if it's missing too. This is for implementing + SMISSING=LISTWISE. */ + struct variable **listwise_vars; + size_t n_listwise_vars; + }; + +static void ctables_summary_spec_set_clone (struct ctables_summary_spec_set *, + const struct ctables_summary_spec_set *); +static void ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *); + +/* A nested sequence of variables, e.g. a > b > c. */ +struct ctables_nest + { + struct variable **vars; + size_t n; + size_t scale_idx; + size_t *domains[N_CTDTS]; + size_t n_domains[N_CTDTS]; + size_t group_head; + + struct ctables_summary_spec_set specs[N_CSVS]; + }; + +/* A stack of nestings, e.g. nest1 + nest2 + ... + nestN. */ +struct ctables_stack + { + struct ctables_nest *nests; + size_t n; + }; + +static void ctables_stack_uninit (struct ctables_stack *); + +struct ctables_value + { + struct hmap_node node; + union value value; + int leaf; + }; + +struct ctables_occurrence + { + struct hmap_node node; + union value value; + }; + +struct ctables_section + { + /* Settings. */ + struct ctables_table *table; + struct ctables_nest *nests[PIVOT_N_AXES]; + + /* Data. */ + struct hmap *occurrences[PIVOT_N_AXES]; /* "struct ctables_occurrence"s. */ + struct hmap cells; /* Contains "struct ctables_cell"s. */ + struct hmap domains[N_CTDTS]; /* Contains "struct ctables_domain"s. */ + }; + +static void ctables_section_uninit (struct ctables_section *); + +struct ctables_table + { + struct ctables *ctables; + struct ctables_axis *axes[PIVOT_N_AXES]; + struct ctables_stack stacks[PIVOT_N_AXES]; + struct ctables_section *sections; + size_t n_sections; + enum pivot_axis_type summary_axis; + struct ctables_summary_spec_set summary_specs; + struct variable **sum_vars; + size_t n_sum_vars; + + enum pivot_axis_type slabels_axis; + bool slabels_visible; + + /* The innermost category labels for axis 'a' appear on axis label_axis[a]. + + Most commonly, label_axis[a] == a, and in particular we always have + label_axis{PIVOT_AXIS_LAYER] == PIVOT_AXIS_LAYER. + + If ROWLABELS or COLLABELS is specified, then one of + label_axis[PIVOT_AXIS_ROW] or label_axis[PIVOT_AXIS_COLUMN] can be the + opposite axis or PIVOT_AXIS_LAYER. Only one of them will differ. + + If any category labels are moved, then 'clabels_example' is one of the + variables being moved (and it is otherwise NULL). All of the variables + being moved have the same width, value labels, and categories, so this + example variable can be used to find those out. + + The remaining members in this group are relevant only if category labels + are moved. + + 'clabels_values_map' holds a "struct ctables_value" for all the values + that appear in all of the variables in the moved categories. It is + accumulated as the data is read. Once the data is fully read, its + sorted values are put into 'clabels_values' and 'n_clabels_values'. + */ + enum pivot_axis_type label_axis[PIVOT_N_AXES]; + enum pivot_axis_type clabels_from_axis; + const struct variable *clabels_example; + struct hmap clabels_values_map; + struct ctables_value **clabels_values; + size_t n_clabels_values; + + /* Indexed by variable dictionary index. */ + struct ctables_categories **categories; + size_t n_categories; + + double cilevel; + + char *caption; + char *corner; + char *title; + + struct ctables_chisq *chisq; + struct ctables_pairwise *pairwise; + }; + +struct ctables_categories + { + size_t n_refs; + struct ctables_category *cats; + size_t n_cats; + bool show_empty; + }; + +struct ctables_category + { + enum ctables_category_type + { + /* Explicit category lists. */ + CCT_NUMBER, + CCT_STRING, + CCT_NRANGE, /* Numerical range. */ + CCT_SRANGE, /* String range. */ + CCT_MISSING, + CCT_OTHERNM, + CCT_POSTCOMPUTE, + + /* Totals and subtotals. */ + CCT_SUBTOTAL, + CCT_TOTAL, + + /* Implicit category lists. */ + CCT_VALUE, + CCT_LABEL, + CCT_FUNCTION, + + /* For contributing to TOTALN. */ + CCT_EXCLUDED_MISSING, + } + type; + + struct ctables_category *subtotal; + + bool hide; + + union + { + double number; /* CCT_NUMBER. */ + struct substring string; /* CCT_STRING, in dictionary encoding. */ + double nrange[2]; /* CCT_NRANGE. */ + struct substring srange[2]; /* CCT_SRANGE. */ + + struct + { + char *total_label; /* CCT_SUBTOTAL, CCT_TOTAL. */ + bool hide_subcategories; /* CCT_SUBTOTAL. */ + }; + + /* CCT_POSTCOMPUTE. */ + struct + { + const struct ctables_postcompute *pc; + enum fmt_type parse_format; + }; + + /* CCT_VALUE, CCT_LABEL, CCT_FUNCTION. */ + struct + { + bool include_missing; + bool sort_ascending; + + /* CCT_FUNCTION. */ + enum ctables_summary_function sort_function; + struct variable *sort_var; + double percentile; + }; + }; + + /* Source location. This is null for CCT_TOTAL, CCT_VALUE, CCT_LABEL, + CCT_FUNCTION, CCT_EXCLUDED_MISSING. */ + struct msg_location *location; + }; + +static void +ctables_category_uninit (struct ctables_category *cat) +{ + if (!cat) + return; + + msg_location_destroy (cat->location); + switch (cat->type) + { + case CCT_NUMBER: + case CCT_NRANGE: + case CCT_MISSING: + case CCT_OTHERNM: + case CCT_POSTCOMPUTE: + break; + + case CCT_STRING: + ss_dealloc (&cat->string); + break; + + case CCT_SRANGE: + ss_dealloc (&cat->srange[0]); + ss_dealloc (&cat->srange[1]); + break; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + free (cat->total_label); + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + break; + + case CCT_EXCLUDED_MISSING: + break; + } +} + +static bool +nullable_substring_equal (const struct substring *a, + const struct substring *b) +{ + return !a->string ? !b->string : b->string && ss_equals (*a, *b); +} + +static bool +ctables_category_equal (const struct ctables_category *a, + const struct ctables_category *b) +{ + if (a->type != b->type) + return false; + + switch (a->type) + { + case CCT_NUMBER: + return a->number == b->number; + + case CCT_STRING: + return ss_equals (a->string, b->string); + + case CCT_NRANGE: + return a->nrange[0] == b->nrange[0] && a->nrange[1] == b->nrange[1]; + + case CCT_SRANGE: + return (nullable_substring_equal (&a->srange[0], &b->srange[0]) + && nullable_substring_equal (&a->srange[1], &b->srange[1])); + + case CCT_MISSING: + case CCT_OTHERNM: + return true; + + case CCT_POSTCOMPUTE: + return a->pc == b->pc; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + return !strcmp (a->total_label, b->total_label); + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (a->include_missing == b->include_missing + && a->sort_ascending == b->sort_ascending + && a->sort_function == b->sort_function + && a->sort_var == b->sort_var + && a->percentile == b->percentile); + + case CCT_EXCLUDED_MISSING: + return true; + } + + NOT_REACHED (); +} + +static void +ctables_categories_unref (struct ctables_categories *c) +{ + if (!c) + return; + + assert (c->n_refs > 0); + if (--c->n_refs) + return; + + for (size_t i = 0; i < c->n_cats; i++) + ctables_category_uninit (&c->cats[i]); + free (c->cats); + free (c); +} + +static bool +ctables_categories_equal (const struct ctables_categories *a, + const struct ctables_categories *b) +{ + if (a->n_cats != b->n_cats || a->show_empty != b->show_empty) + return false; + + for (size_t i = 0; i < a->n_cats; i++) + if (!ctables_category_equal (&a->cats[i], &b->cats[i])) + return false; + + return true; +} + +/* Chi-square test (SIGTEST). */ +struct ctables_chisq + { + double alpha; + bool include_mrsets; + bool all_visible; + }; + +/* Pairwise comparison test (COMPARETEST). */ +struct ctables_pairwise + { + enum { PROP, MEAN } type; + double alpha[2]; + bool include_mrsets; + bool meansvariance_allcats; + bool all_visible; + enum { BONFERRONI = 1, BH } adjust; + bool merge; + bool apa_style; + bool show_sig; + }; + +struct ctables_axis + { + enum ctables_axis_op + { + /* Terminals. */ + CTAO_VAR, + + /* Nonterminals. */ + CTAO_STACK, /* + */ + CTAO_NEST, /* > */ + } + op; + + union + { + /* Terminals. */ + struct + { + struct variable *var; + bool scale; + struct ctables_summary_spec_set specs[N_CSVS]; + }; + + /* Nonterminals. */ + struct ctables_axis *subs[2]; + }; + + struct msg_location *loc; + }; + +static void ctables_axis_destroy (struct ctables_axis *); + +enum ctables_format + { + CTF_COUNT, + CTF_PERCENT, + CTF_GENERAL + }; + +enum ctables_function_availability + { + CTFA_ALL, /* Any variables. */ + CTFA_SCALE, /* Only scale variables, totals, and subtotals. */ + //CTFA_MRSETS, /* Only multiple-response sets */ + }; + +struct ctables_summary_spec + { + enum ctables_summary_function function; + double percentile; /* CTSF_PTILE only. */ + char *label; + + struct fmt_spec format; + bool is_ctables_format; /* Is 'format' one of CTEF_*? */ + + size_t axis_idx; + size_t sum_var_idx; + }; + +static void +ctables_summary_spec_clone (struct ctables_summary_spec *dst, + const struct ctables_summary_spec *src) +{ + *dst = *src; + dst->label = xstrdup_if_nonnull (src->label); +} + +static void +ctables_summary_spec_uninit (struct ctables_summary_spec *s) +{ + if (s) + free (s->label); +} + +static void +ctables_summary_spec_set_clone (struct ctables_summary_spec_set *dst, + const struct ctables_summary_spec_set *src) +{ + struct ctables_summary_spec *specs + = (src->n ? xnmalloc (src->n, sizeof *specs) : NULL); + for (size_t i = 0; i < src->n; i++) + ctables_summary_spec_clone (&specs[i], &src->specs[i]); + + *dst = (struct ctables_summary_spec_set) { + .specs = specs, + .n = src->n, + .allocated = src->n, + .var = src->var, + .is_scale = src->is_scale, + }; +} + +static void +ctables_summary_spec_set_uninit (struct ctables_summary_spec_set *set) +{ + for (size_t i = 0; i < set->n; i++) + ctables_summary_spec_uninit (&set->specs[i]); + free (set->listwise_vars); + free (set->specs); +} + +static bool +parse_col_width (struct lexer *lexer, const char *name, double *width) +{ + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "DEFAULT")) + *width = SYSMIS; + else if (lex_force_num_range_closed (lexer, name, 0, DBL_MAX)) + { + *width = lex_number (lexer); + lex_get (lexer); + } + else + return false; + + return true; +} + +static bool +parse_bool (struct lexer *lexer, bool *b) +{ + if (lex_match_id (lexer, "NO")) + *b = false; + else if (lex_match_id (lexer, "YES")) + *b = true; + else + { + lex_error_expecting (lexer, "YES", "NO"); + return false; + } + return true; +} + +static enum ctables_function_availability +ctables_function_availability (enum ctables_summary_function f) +{ + static enum ctables_function_availability availability[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = AVAILABILITY, +#include "ctables.inc" +#undef S + }; + + return availability[f]; +} + +static bool +ctables_summary_function_is_count (enum ctables_summary_function f) +{ + return f == CTSF_COUNT || f == CTSF_ECOUNT || f == CTSF_UCOUNT; +} + +static bool +parse_ctables_summary_function (struct lexer *lexer, + enum ctables_summary_function *f) +{ + struct pair + { + enum ctables_summary_function function; + struct substring name; + }; + static struct pair names[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) \ + { ENUM, SS_LITERAL_INITIALIZER (NAME) }, +#include "ctables.inc" + /* The .COUNT suffix may be omitted. */ + S(CTSF_ROWPCT_COUNT, "ROWPCT", _, _, _) + S(CTSF_COLPCT_COUNT, "COLPCT", _, _, _) + S(CTSF_TABLEPCT_COUNT, "TABLEPCT", _, _, _) + S(CTSF_SUBTABLEPCT_COUNT, "SUBTABLEPCT", _, _, _) + S(CTSF_LAYERPCT_COUNT, "LAYERPCT", _, _, _) + S(CTSF_LAYERROWPCT_COUNT, "LAYERROWPCT", _, _, _) + S(CTSF_LAYERCOLPCT_COUNT, "LAYERCOLPCT", _, _, _) +#undef S + }; + + if (!lex_force_id (lexer)) + return false; + + for (size_t i = 0; i < sizeof names / sizeof *names; i++) + if (ss_equals_case (names[i].name, lex_tokss (lexer))) + { + *f = names[i].function; + lex_get (lexer); + return true; + } + + lex_error (lexer, _("Expecting summary function name.")); + return false; +} + +static void +ctables_axis_destroy (struct ctables_axis *axis) +{ + if (!axis) + return; + + switch (axis->op) + { + case CTAO_VAR: + for (size_t i = 0; i < N_CSVS; i++) + ctables_summary_spec_set_uninit (&axis->specs[i]); + break; + + case CTAO_STACK: + case CTAO_NEST: + ctables_axis_destroy (axis->subs[0]); + ctables_axis_destroy (axis->subs[1]); + break; + } + msg_location_destroy (axis->loc); + free (axis); +} + +static struct ctables_axis * +ctables_axis_new_nonterminal (enum ctables_axis_op op, + struct ctables_axis *sub0, + struct ctables_axis *sub1, + struct lexer *lexer, int start_ofs) +{ + struct ctables_axis *axis = xmalloc (sizeof *axis); + *axis = (struct ctables_axis) { + .op = op, + .subs = { sub0, sub1 }, + .loc = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1), + }; + return axis; +} + +struct ctables_axis_parse_ctx + { + struct lexer *lexer; + struct dictionary *dict; + struct ctables *ct; + struct ctables_table *t; + }; + +static struct fmt_spec +ctables_summary_default_format (enum ctables_summary_function function, + const struct variable *var) +{ + static const enum ctables_format default_formats[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = FORMAT, +#include "ctables.inc" +#undef S + }; + switch (default_formats[function]) + { + case CTF_COUNT: + return (struct fmt_spec) { .type = FMT_F, .w = 40 }; + + case CTF_PERCENT: + return (struct fmt_spec) { .type = FMT_PCT, .w = 40, .d = 1 }; + + case CTF_GENERAL: + return *var_get_print_format (var); + + default: + NOT_REACHED (); + } +} + +static struct pivot_value * +ctables_summary_label (const struct ctables_summary_spec *spec, double cilevel) +{ + if (!spec->label) + { + static const char *default_labels[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = LABEL, +#include "ctables.inc" +#undef S + }; + + return (spec->function == CTSF_PTILE + ? pivot_value_new_text_format (N_("Percentile %.2f"), + spec->percentile) + : pivot_value_new_text (default_labels[spec->function])); + } + else + { + struct substring in = ss_cstr (spec->label); + struct substring target = ss_cstr (")CILEVEL"); + + struct string out = DS_EMPTY_INITIALIZER; + for (;;) + { + size_t chunk = ss_find_substring (in, target); + ds_put_substring (&out, ss_head (in, chunk)); + ss_advance (&in, chunk); + if (!in.length) + return pivot_value_new_user_text_nocopy (ds_steal_cstr (&out)); + + ss_advance (&in, target.length); + ds_put_format (&out, "%g", cilevel); + } + } +} + +static const char * +ctables_summary_function_name (enum ctables_summary_function function) +{ + static const char *names[] = { +#define S(ENUM, NAME, LABEL, FORMAT, AVAILABILITY) [ENUM] = NAME, +#include "ctables.inc" +#undef S + }; + return names[function]; +} + +static bool +add_summary_spec (struct ctables_axis *axis, + enum ctables_summary_function function, double percentile, + const char *label, const struct fmt_spec *format, + bool is_ctables_format, const struct msg_location *loc, + enum ctables_summary_variant sv) +{ + if (axis->op == CTAO_VAR) + { + const char *function_name = ctables_summary_function_name (function); + const char *var_name = var_get_name (axis->var); + switch (ctables_function_availability (function)) + { +#if 0 + case CTFA_MRSETS: + msg_at (SE, loc, _("Summary function %s applies only to multiple " + "response sets."), function_name); + msg_at (SN, axis->loc, _("'%s' is not a multiple response set."), + var_name); + return false; +#endif + + case CTFA_SCALE: + if (!axis->scale && sv != CSV_TOTAL) + { + msg_at (SE, loc, + _("Summary function %s applies only to scale variables."), + function_name); + msg_at (SN, axis->loc, _("'%s' is not a scale variable."), + var_name); + return false; + } + break; + + case CTFA_ALL: + break; + } + + struct ctables_summary_spec_set *set = &axis->specs[sv]; + if (set->n >= set->allocated) + set->specs = x2nrealloc (set->specs, &set->allocated, + sizeof *set->specs); + + struct ctables_summary_spec *dst = &set->specs[set->n++]; + *dst = (struct ctables_summary_spec) { + .function = function, + .percentile = percentile, + .label = xstrdup_if_nonnull (label), + .format = (format ? *format + : ctables_summary_default_format (function, axis->var)), + .is_ctables_format = is_ctables_format, + }; + return true; + } + else + { + for (size_t i = 0; i < 2; i++) + if (!add_summary_spec (axis->subs[i], function, percentile, label, + format, is_ctables_format, loc, sv)) + return false; + return true; + } +} + +static struct ctables_axis *ctables_axis_parse_stack ( + struct ctables_axis_parse_ctx *); + + +static struct ctables_axis * +ctables_axis_parse_primary (struct ctables_axis_parse_ctx *ctx) +{ + if (lex_match (ctx->lexer, T_LPAREN)) + { + struct ctables_axis *sub = ctables_axis_parse_stack (ctx); + if (!sub || !lex_force_match (ctx->lexer, T_RPAREN)) + { + ctables_axis_destroy (sub); + return NULL; + } + return sub; + } + + if (!lex_force_id (ctx->lexer)) + return NULL; + + int start_ofs = lex_ofs (ctx->lexer); + struct variable *var = parse_variable (ctx->lexer, ctx->dict); + if (!var) + return NULL; + + struct ctables_axis *axis = xmalloc (sizeof *axis); + *axis = (struct ctables_axis) { .op = CTAO_VAR, .var = var }; + + axis->scale = (lex_match_phrase (ctx->lexer, "[S]") ? true + : lex_match_phrase (ctx->lexer, "[C]") ? false + : var_get_measure (var) == MEASURE_SCALE); + axis->loc = lex_ofs_location (ctx->lexer, start_ofs, + lex_ofs (ctx->lexer) - 1); + if (axis->scale && var_is_alpha (var)) + { + msg_at (SE, axis->loc, _("Cannot use string variable %s as a scale " + "variable."), + var_get_name (var)); + ctables_axis_destroy (axis); + return NULL; + } + + return axis; +} + +static bool +has_digit (const char *s) +{ + return s[strcspn (s, "0123456789")] != '\0'; +} + +static bool +parse_ctables_format_specifier (struct lexer *lexer, struct fmt_spec *format, + bool *is_ctables_format) +{ + char type[FMT_TYPE_LEN_MAX + 1]; + if (!parse_abstract_format_specifier__ (lexer, type, &format->w, &format->d)) + return false; + + if (!strcasecmp (type, "NEGPAREN")) + format->type = CTEF_NEGPAREN; + else if (!strcasecmp (type, "NEQUAL")) + format->type = CTEF_NEQUAL; + else if (!strcasecmp (type, "PAREN")) + format->type = CTEF_PAREN; + else if (!strcasecmp (type, "PCTPAREN")) + format->type = CTEF_PCTPAREN; + else + { + *is_ctables_format = false; + return (parse_format_specifier (lexer, format) + && fmt_check_output (format) + && fmt_check_type_compat (format, VAL_NUMERIC)); + } + + lex_get (lexer); + if (format->w < 2) + { + lex_next_error (lexer, -1, -1, + _("Output format %s requires width 2 or greater."), type); + return false; + } + else if (format->d > format->w - 1) + { + lex_next_error (lexer, -1, -1, _("Output format %s requires width " + "greater than decimals."), type); + return false; + } + else + { + *is_ctables_format = true; + return true; + } +} + +static struct ctables_axis * +ctables_axis_parse_postfix (struct ctables_axis_parse_ctx *ctx) +{ + struct ctables_axis *sub = ctables_axis_parse_primary (ctx); + if (!sub || !lex_match (ctx->lexer, T_LBRACK)) + return sub; + + enum ctables_summary_variant sv = CSV_CELL; + for (;;) + { + int start_ofs = lex_ofs (ctx->lexer); + + /* Parse function. */ + enum ctables_summary_function function; + if (!parse_ctables_summary_function (ctx->lexer, &function)) + goto error; + + /* Parse percentile. */ + double percentile = 0; + if (function == CTSF_PTILE) + { + if (!lex_force_num_range_closed (ctx->lexer, "PTILE", 0, 100)) + goto error; + percentile = lex_number (ctx->lexer); + lex_get (ctx->lexer); + } + + /* Parse label. */ + char *label = NULL; + if (lex_is_string (ctx->lexer)) + { + label = ss_xstrdup (lex_tokss (ctx->lexer)); + lex_get (ctx->lexer); + } + + /* Parse format. */ + struct fmt_spec format; + const struct fmt_spec *formatp; + bool is_ctables_format = false; + if (lex_token (ctx->lexer) == T_ID + && has_digit (lex_tokcstr (ctx->lexer))) + { + if (!parse_ctables_format_specifier (ctx->lexer, &format, + &is_ctables_format)) + { + free (label); + goto error; + } + formatp = &format; + } + else + formatp = NULL; + + struct msg_location *loc = lex_ofs_location (ctx->lexer, start_ofs, + lex_ofs (ctx->lexer) - 1); + add_summary_spec (sub, function, percentile, label, formatp, + is_ctables_format, loc, sv); + free (label); + msg_location_destroy (loc); + + lex_match (ctx->lexer, T_COMMA); + if (sv == CSV_CELL && lex_match_id (ctx->lexer, "TOTALS")) + { + if (!lex_force_match (ctx->lexer, T_LBRACK)) + goto error; + sv = CSV_TOTAL; + } + else if (lex_match (ctx->lexer, T_RBRACK)) + { + if (sv == CSV_TOTAL && !lex_force_match (ctx->lexer, T_RBRACK)) + goto error; + return sub; + } + } + +error: + ctables_axis_destroy (sub); + return NULL; +} + +static const struct ctables_axis * +find_scale (const struct ctables_axis *axis) +{ + if (!axis) + return NULL; + else if (axis->op == CTAO_VAR) + return axis->scale ? axis : NULL; + else + { + for (size_t i = 0; i < 2; i++) + { + const struct ctables_axis *scale = find_scale (axis->subs[i]); + if (scale) + return scale; + } + return NULL; + } +} + +static const struct ctables_axis * +find_categorical_summary_spec (const struct ctables_axis *axis) +{ + if (!axis) + return NULL; + else if (axis->op == CTAO_VAR) + return !axis->scale && axis->specs[CSV_CELL].n ? axis : NULL; + else + { + for (size_t i = 0; i < 2; i++) + { + const struct ctables_axis *sum + = find_categorical_summary_spec (axis->subs[i]); + if (sum) + return sum; + } + return NULL; + } +} + +static struct ctables_axis * +ctables_axis_parse_nest (struct ctables_axis_parse_ctx *ctx) +{ + int start_ofs = lex_ofs (ctx->lexer); + struct ctables_axis *lhs = ctables_axis_parse_postfix (ctx); + if (!lhs) + return NULL; + + while (lex_match (ctx->lexer, T_GT)) + { + struct ctables_axis *rhs = ctables_axis_parse_postfix (ctx); + if (!rhs) + { + ctables_axis_destroy (lhs); + return NULL; + } + + struct ctables_axis *nest = ctables_axis_new_nonterminal ( + CTAO_NEST, lhs, rhs, ctx->lexer, start_ofs); + + const struct ctables_axis *outer_scale = find_scale (lhs); + const struct ctables_axis *inner_scale = find_scale (rhs); + if (outer_scale && inner_scale) + { + msg_at (SE, nest->loc, _("Cannot nest scale variables.")); + msg_at (SN, outer_scale->loc, _("This is an outer scale variable.")); + msg_at (SN, inner_scale->loc, _("This is an inner scale variable.")); + ctables_axis_destroy (nest); + return NULL; + } + + const struct ctables_axis *outer_sum = find_categorical_summary_spec (lhs); + if (outer_sum) + { + msg_at (SE, nest->loc, + _("Summaries may only be requested for categorical variables " + "at the innermost nesting level.")); + msg_at (SN, outer_sum->loc, + _("This outer categorical variable has a summary.")); + ctables_axis_destroy (nest); + return NULL; + } + + lhs = nest; + } + + return lhs; +} + +static struct ctables_axis * +ctables_axis_parse_stack (struct ctables_axis_parse_ctx *ctx) +{ + int start_ofs = lex_ofs (ctx->lexer); + struct ctables_axis *lhs = ctables_axis_parse_nest (ctx); + if (!lhs) + return NULL; + + while (lex_match (ctx->lexer, T_PLUS)) + { + struct ctables_axis *rhs = ctables_axis_parse_nest (ctx); + if (!rhs) + { + ctables_axis_destroy (lhs); + return NULL; + } + + lhs = ctables_axis_new_nonterminal (CTAO_STACK, lhs, rhs, + ctx->lexer, start_ofs); + } + + return lhs; +} + +static bool +ctables_axis_parse (struct lexer *lexer, struct dictionary *dict, + struct ctables *ct, struct ctables_table *t, + enum pivot_axis_type a) +{ + if (lex_token (lexer) == T_BY + || lex_token (lexer) == T_SLASH + || lex_token (lexer) == T_ENDCMD) + return true; + + struct ctables_axis_parse_ctx ctx = { + .lexer = lexer, + .dict = dict, + .ct = ct, + .t = t + }; + t->axes[a] = ctables_axis_parse_stack (&ctx); + return t->axes[a] != NULL; +} + +static void +ctables_chisq_destroy (struct ctables_chisq *chisq) +{ + free (chisq); +} + +static void +ctables_pairwise_destroy (struct ctables_pairwise *pairwise) +{ + free (pairwise); +} + +static void +ctables_table_destroy (struct ctables_table *t) +{ + if (!t) + return; + + for (size_t i = 0; i < t->n_sections; i++) + ctables_section_uninit (&t->sections[i]); + free (t->sections); + + for (size_t i = 0; i < t->n_categories; i++) + ctables_categories_unref (t->categories[i]); + free (t->categories); + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + ctables_axis_destroy (t->axes[a]); + ctables_stack_uninit (&t->stacks[a]); + } + free (t->summary_specs.specs); + + struct ctables_value *ctv, *next_ctv; + HMAP_FOR_EACH_SAFE (ctv, next_ctv, struct ctables_value, node, + &t->clabels_values_map) + { + value_destroy (&ctv->value, var_get_width (t->clabels_example)); + hmap_delete (&t->clabels_values_map, &ctv->node); + free (ctv); + } + hmap_destroy (&t->clabels_values_map); + free (t->clabels_values); + + free (t->sum_vars); + free (t->caption); + free (t->corner); + free (t->title); + ctables_chisq_destroy (t->chisq); + ctables_pairwise_destroy (t->pairwise); + free (t); +} + +static void +ctables_destroy (struct ctables *ct) +{ + if (!ct) + return; + + struct ctables_postcompute *pc, *next_pc; + HMAP_FOR_EACH_SAFE (pc, next_pc, struct ctables_postcompute, hmap_node, + &ct->postcomputes) + { + free (pc->name); + msg_location_destroy (pc->location); + ctables_pcexpr_destroy (pc->expr); + free (pc->label); + if (pc->specs) + { + ctables_summary_spec_set_uninit (pc->specs); + free (pc->specs); + } + hmap_delete (&ct->postcomputes, &pc->hmap_node); + free (pc); + } + + fmt_settings_uninit (&ct->ctables_formats); + pivot_table_look_unref (ct->look); + free (ct->zero); + free (ct->missing); + free (ct->vlabels); + for (size_t i = 0; i < ct->n_tables; i++) + ctables_table_destroy (ct->tables[i]); + free (ct->tables); + free (ct); +} + +static struct ctables_category +cct_nrange (double low, double high) +{ + return (struct ctables_category) { + .type = CCT_NRANGE, + .nrange = { low, high } + }; +} + +static struct ctables_category +cct_srange (struct substring low, struct substring high) +{ + return (struct ctables_category) { + .type = CCT_SRANGE, + .srange = { low, high } + }; +} + +static bool +ctables_table_parse_subtotal (struct lexer *lexer, bool hide_subcategories, + struct ctables_category *cat) +{ + char *total_label; + if (lex_match (lexer, T_EQUALS)) + { + if (!lex_force_string (lexer)) + return false; + + total_label = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else + total_label = xstrdup (_("Subtotal")); + + *cat = (struct ctables_category) { + .type = CCT_SUBTOTAL, + .hide_subcategories = hide_subcategories, + .total_label = total_label + }; + return true; +} + +static struct substring +parse_substring (struct lexer *lexer, struct dictionary *dict) +{ + struct substring s = recode_substring_pool ( + dict_get_encoding (dict), "UTF-8", lex_tokss (lexer), NULL); + ss_rtrim (&s, ss_cstr (" ")); + lex_get (lexer); + return s; +} + +static bool +ctables_table_parse_explicit_category (struct lexer *lexer, + struct dictionary *dict, + struct ctables *ct, + struct ctables_category *cat) +{ + if (lex_match_id (lexer, "OTHERNM")) + *cat = (struct ctables_category) { .type = CCT_OTHERNM }; + else if (lex_match_id (lexer, "MISSING")) + *cat = (struct ctables_category) { .type = CCT_MISSING }; + else if (lex_match_id (lexer, "SUBTOTAL")) + return ctables_table_parse_subtotal (lexer, false, cat); + else if (lex_match_id (lexer, "HSUBTOTAL")) + return ctables_table_parse_subtotal (lexer, true, cat); + else if (lex_match_id (lexer, "LO")) + { + if (!lex_force_match_id (lexer, "THRU")) + return false; + if (lex_is_string (lexer)) + { + struct substring sr0 = { .string = NULL }; + struct substring sr1 = parse_substring (lexer, dict); + *cat = cct_srange (sr0, sr1); + } + else if (lex_force_num (lexer)) + { + *cat = cct_nrange (-DBL_MAX, lex_number (lexer)); + lex_get (lexer); + } + else + return false; + } + else if (lex_is_number (lexer)) + { + double number = lex_number (lexer); + lex_get (lexer); + if (lex_match_id (lexer, "THRU")) + { + if (lex_match_id (lexer, "HI")) + *cat = cct_nrange (number, DBL_MAX); + else + { + if (!lex_force_num (lexer)) + return false; + *cat = cct_nrange (number, lex_number (lexer)); + lex_get (lexer); + } + } + else + *cat = (struct ctables_category) { + .type = CCT_NUMBER, + .number = number + }; + } + else if (lex_is_string (lexer)) + { + struct substring s = parse_substring (lexer, dict); + if (lex_match_id (lexer, "THRU")) + { + if (lex_match_id (lexer, "HI")) + { + struct substring sr1 = { .string = NULL }; + *cat = cct_srange (s, sr1); + } + else + { + if (!lex_force_string (lexer)) + { + ss_dealloc (&s); + return false; + } + struct substring sr1 = parse_substring (lexer, dict); + *cat = cct_srange (s, sr1); + } + } + else + *cat = (struct ctables_category) { .type = CCT_STRING, .string = s }; + } + else if (lex_match (lexer, T_AND)) + { + if (!lex_force_id (lexer)) + return false; + struct ctables_postcompute *pc = ctables_find_postcompute ( + ct, lex_tokcstr (lexer)); + if (!pc) + { + struct msg_location *loc = lex_get_location (lexer, -1, 0); + msg_at (SE, loc, _("Unknown postcompute &%s."), + lex_tokcstr (lexer)); + msg_location_destroy (loc); + return false; + } + lex_get (lexer); + + *cat = (struct ctables_category) { .type = CCT_POSTCOMPUTE, .pc = pc }; + } + else + { + lex_error (lexer, NULL); + return false; + } + + return true; +} + +static bool +parse_category_string (struct msg_location *location, + struct substring s, const struct dictionary *dict, + enum fmt_type format, double *n) +{ + union value v; + char *error = data_in (s, dict_get_encoding (dict), format, + settings_get_fmt_settings (), &v, 0, NULL); + if (error) + { + msg_at (SE, location, + _("Failed to parse category specification as format %s: %s."), + fmt_name (format), error); + free (error); + return false; + } + + *n = v.f; + return true; +} + +static struct ctables_category * +ctables_find_category_for_postcompute__ (const struct ctables_categories *cats, + const struct ctables_pcexpr *e) +{ + struct ctables_category *best = NULL; + size_t n_subtotals = 0; + for (size_t i = 0; i < cats->n_cats; i++) + { + struct ctables_category *cat = &cats->cats[i]; + switch (e->op) + { + case CTPO_CAT_NUMBER: + if (cat->type == CCT_NUMBER && cat->number == e->number) + best = cat; + break; + + case CTPO_CAT_STRING: + if (cat->type == CCT_STRING && ss_equals (cat->string, e->string)) + best = cat; + break; + + case CTPO_CAT_NRANGE: + if (cat->type == CCT_NRANGE + && cat->nrange[0] == e->nrange[0] + && cat->nrange[1] == e->nrange[1]) + best = cat; + break; + + case CTPO_CAT_SRANGE: + if (cat->type == CCT_SRANGE + && nullable_substring_equal (&cat->srange[0], &e->srange[0]) + && nullable_substring_equal (&cat->srange[1], &e->srange[1])) + best = cat; + break; + + case CTPO_CAT_MISSING: + if (cat->type == CCT_MISSING) + best = cat; + break; + + case CTPO_CAT_OTHERNM: + if (cat->type == CCT_OTHERNM) + best = cat; + break; + + case CTPO_CAT_SUBTOTAL: + if (cat->type == CCT_SUBTOTAL) + { + n_subtotals++; + if (e->subtotal_index == n_subtotals) + return cat; + else if (e->subtotal_index == 0) + best = cat; + } + break; + + case CTPO_CAT_TOTAL: + if (cat->type == CCT_TOTAL) + return cat; + break; + + case CTPO_CONSTANT: + case CTPO_ADD: + case CTPO_SUB: + case CTPO_MUL: + case CTPO_DIV: + case CTPO_POW: + case CTPO_NEG: + NOT_REACHED (); + } + } + if (e->op == CTPO_CAT_SUBTOTAL && e->subtotal_index == 0 && n_subtotals > 1) + return NULL; + return best; +} + +static struct ctables_category * +ctables_find_category_for_postcompute (const struct dictionary *dict, + const struct ctables_categories *cats, + enum fmt_type parse_format, + const struct ctables_pcexpr *e) +{ + if (parse_format != FMT_F) + { + if (e->op == CTPO_CAT_STRING) + { + double number; + if (!parse_category_string (e->location, e->string, dict, + parse_format, &number)) + return NULL; + + struct ctables_pcexpr e2 = { + .op = CTPO_CAT_NUMBER, + .number = number, + .location = e->location, + }; + return ctables_find_category_for_postcompute__ (cats, &e2); + } + else if (e->op == CTPO_CAT_SRANGE) + { + double nrange[2]; + if (!e->srange[0].string) + nrange[0] = -DBL_MAX; + else if (!parse_category_string (e->location, e->srange[0], dict, + parse_format, &nrange[0])) + return NULL; + + if (!e->srange[1].string) + nrange[1] = DBL_MAX; + else if (!parse_category_string (e->location, e->srange[1], dict, + parse_format, &nrange[1])) + return NULL; + + struct ctables_pcexpr e2 = { + .op = CTPO_CAT_NRANGE, + .nrange = { nrange[0], nrange[1] }, + .location = e->location, + }; + return ctables_find_category_for_postcompute__ (cats, &e2); + } + } + return ctables_find_category_for_postcompute__ (cats, e); +} + +static bool +ctables_recursive_check_postcompute (struct dictionary *dict, + const struct ctables_pcexpr *e, + struct ctables_category *pc_cat, + const struct ctables_categories *cats, + const struct msg_location *cats_location) +{ + switch (e->op) + { + case CTPO_CAT_NUMBER: + case CTPO_CAT_STRING: + case CTPO_CAT_NRANGE: + case CTPO_CAT_SRANGE: + case CTPO_CAT_MISSING: + case CTPO_CAT_OTHERNM: + case CTPO_CAT_SUBTOTAL: + case CTPO_CAT_TOTAL: + { + struct ctables_category *cat = ctables_find_category_for_postcompute ( + dict, cats, pc_cat->parse_format, e); + if (!cat) + { + if (e->op == CTPO_CAT_SUBTOTAL && e->subtotal_index == 0) + { + size_t n_subtotals = 0; + for (size_t i = 0; i < cats->n_cats; i++) + n_subtotals += cats->cats[i].type == CCT_SUBTOTAL; + if (n_subtotals > 1) + { + msg_at (SE, cats_location, + ngettext ("These categories include %zu instance " + "of SUBTOTAL or HSUBTOTAL, so references " + "from computed categories must refer to " + "subtotals by position, " + "e.g. SUBTOTAL[1].", + "These categories include %zu instances " + "of SUBTOTAL or HSUBTOTAL, so references " + "from computed categories must refer to " + "subtotals by position, " + "e.g. SUBTOTAL[1].", + n_subtotals), + n_subtotals); + msg_at (SN, e->location, + _("This is the reference that lacks a position.")); + return NULL; + } + } + + msg_at (SE, pc_cat->location, + _("Computed category &%s references a category not included " + "in the category list."), + pc_cat->pc->name); + msg_at (SN, e->location, _("This is the missing category.")); + if (e->op == CTPO_CAT_SUBTOTAL) + msg_at (SN, cats_location, + _("To fix the problem, add subtotals to the " + "list of categories here.")); + else if (e->op == CTPO_CAT_TOTAL) + msg (SN, _("To fix the problem, add TOTAL=YES to the variable's " + "CATEGORIES specification.")); + else + msg_at (SN, cats_location, + _("To fix the problem, add the missing category to the " + "list of categories here.")); + return false; + } + if (pc_cat->pc->hide_source_cats) + cat->hide = true; + return true; + } + + case CTPO_CONSTANT: + return true; + + case CTPO_ADD: + case CTPO_SUB: + case CTPO_MUL: + case CTPO_DIV: + case CTPO_POW: + case CTPO_NEG: + for (size_t i = 0; i < 2; i++) + if (e->subs[i] && !ctables_recursive_check_postcompute ( + dict, e->subs[i], pc_cat, cats, cats_location)) + return false; + return true; + } + + NOT_REACHED (); +} + +static bool +all_strings (struct variable **vars, size_t n_vars, + const struct ctables_category *cat) +{ + for (size_t j = 0; j < n_vars; j++) + if (var_is_numeric (vars[j])) + { + msg_at (SE, cat->location, + _("This category specification may be applied only to string " + "variables, but this subcommand tries to apply it to " + "numeric variable %s."), + var_get_name (vars[j])); + return false; + } + return true; +} + +static bool +ctables_table_parse_categories (struct lexer *lexer, struct dictionary *dict, + struct ctables *ct, struct ctables_table *t) +{ + if (!lex_match_id (lexer, "VARIABLES")) + return false; + lex_match (lexer, T_EQUALS); + + struct variable **vars; + size_t n_vars; + if (!parse_variables (lexer, dict, &vars, &n_vars, PV_NO_SCRATCH)) + return false; + + const struct fmt_spec *common_format = var_get_print_format (vars[0]); + for (size_t i = 1; i < n_vars; i++) + { + const struct fmt_spec *f = var_get_print_format (vars[i]); + if (f->type != common_format->type) + { + common_format = NULL; + break; + } + } + bool parse_strings + = (common_format + && (fmt_get_category (common_format->type) + & (FMT_CAT_DATE | FMT_CAT_TIME | FMT_CAT_DATE_COMPONENT))); + + struct ctables_categories *c = xmalloc (sizeof *c); + *c = (struct ctables_categories) { .n_refs = n_vars, .show_empty = true }; + for (size_t i = 0; i < n_vars; i++) + { + struct ctables_categories **cp + = &t->categories[var_get_dict_index (vars[i])]; + ctables_categories_unref (*cp); + *cp = c; + } + + size_t allocated_cats = 0; + int cats_start_ofs = -1; + int cats_end_ofs = -1; + if (lex_match (lexer, T_LBRACK)) + { + cats_start_ofs = lex_ofs (lexer); + do + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + + int start_ofs = lex_ofs (lexer); + struct ctables_category *cat = &c->cats[c->n_cats]; + if (!ctables_table_parse_explicit_category (lexer, dict, ct, cat)) + goto error; + cat->location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1); + c->n_cats++; + + lex_match (lexer, T_COMMA); + } + while (!lex_match (lexer, T_RBRACK)); + cats_end_ofs = lex_ofs (lexer) - 1; + } + + struct ctables_category cat = { + .type = CCT_VALUE, + .include_missing = false, + .sort_ascending = true, + }; + bool show_totals = false; + char *total_label = NULL; + bool totals_before = false; + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (!c->n_cats && lex_match_id (lexer, "ORDER")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "A")) + cat.sort_ascending = true; + else if (lex_match_id (lexer, "D")) + cat.sort_ascending = false; + else + { + lex_error_expecting (lexer, "A", "D"); + goto error; + } + } + else if (!c->n_cats && lex_match_id (lexer, "KEY")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "VALUE")) + cat.type = CCT_VALUE; + else if (lex_match_id (lexer, "LABEL")) + cat.type = CCT_LABEL; + else + { + cat.type = CCT_FUNCTION; + if (!parse_ctables_summary_function (lexer, &cat.sort_function)) + goto error; + + if (lex_match (lexer, T_LPAREN)) + { + cat.sort_var = parse_variable (lexer, dict); + if (!cat.sort_var) + goto error; + + if (cat.sort_function == CTSF_PTILE) + { + lex_match (lexer, T_COMMA); + if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100)) + goto error; + cat.percentile = lex_number (lexer); + lex_get (lexer); + } + + if (!lex_force_match (lexer, T_RPAREN)) + goto error; + } + else if (ctables_function_availability (cat.sort_function) + == CTFA_SCALE) + { + bool UNUSED b = lex_force_match (lexer, T_LPAREN); + goto error; + } + } + } + else if (!c->n_cats && lex_match_id (lexer, "MISSING")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "INCLUDE")) + cat.include_missing = true; + else if (lex_match_id (lexer, "EXCLUDE")) + cat.include_missing = false; + else + { + lex_error_expecting (lexer, "INCLUDE", "EXCLUDE"); + goto error; + } + } + else if (lex_match_id (lexer, "TOTAL")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &show_totals)) + goto error; + } + else if (lex_match_id (lexer, "LABEL")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + goto error; + free (total_label); + total_label = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else if (lex_match_id (lexer, "POSITION")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "BEFORE")) + totals_before = true; + else if (lex_match_id (lexer, "AFTER")) + totals_before = false; + else + { + lex_error_expecting (lexer, "BEFORE", "AFTER"); + goto error; + } + } + else if (lex_match_id (lexer, "EMPTY")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "INCLUDE")) + c->show_empty = true; + else if (lex_match_id (lexer, "EXCLUDE")) + c->show_empty = false; + else + { + lex_error_expecting (lexer, "INCLUDE", "EXCLUDE"); + goto error; + } + } + else + { + if (!c->n_cats) + lex_error_expecting (lexer, "ORDER", "KEY", "MISSING", + "TOTAL", "LABEL", "POSITION", "EMPTY"); + else + lex_error_expecting (lexer, "TOTAL", "LABEL", "POSITION", "EMPTY"); + goto error; + } + } + + if (!c->n_cats) + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + c->cats[c->n_cats++] = cat; + } + + if (show_totals) + { + if (c->n_cats >= allocated_cats) + c->cats = x2nrealloc (c->cats, &allocated_cats, sizeof *c->cats); + + struct ctables_category *totals; + if (totals_before) + { + insert_element (c->cats, c->n_cats, sizeof *c->cats, 0); + totals = &c->cats[0]; + } + else + totals = &c->cats[c->n_cats]; + c->n_cats++; + + *totals = (struct ctables_category) { + .type = CCT_TOTAL, + .total_label = total_label ? total_label : xstrdup (_("Total")), + }; + } + + struct ctables_category *subtotal = NULL; + for (size_t i = totals_before ? 0 : c->n_cats; + totals_before ? i < c->n_cats : i-- > 0; + totals_before ? i++ : 0) + { + struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_NRANGE: + case CCT_SRANGE: + case CCT_MISSING: + case CCT_OTHERNM: + cat->subtotal = subtotal; + break; + + case CCT_POSTCOMPUTE: + break; + + case CCT_SUBTOTAL: + subtotal = cat; + break; + + case CCT_TOTAL: + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + case CCT_EXCLUDED_MISSING: + break; + } + } + + if (cats_start_ofs != -1) + { + for (size_t i = 0; i < c->n_cats; i++) + { + struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_POSTCOMPUTE: + cat->parse_format = parse_strings ? common_format->type : FMT_F; + struct msg_location *cats_location + = lex_ofs_location (lexer, cats_start_ofs, cats_end_ofs); + bool ok = ctables_recursive_check_postcompute ( + dict, cat->pc->expr, cat, c, cats_location); + msg_location_destroy (cats_location); + if (!ok) + goto error; + break; + + case CCT_NUMBER: + case CCT_NRANGE: + for (size_t j = 0; j < n_vars; j++) + if (var_is_alpha (vars[j])) + { + msg_at (SE, cat->location, + _("This category specification may be applied " + "only to numeric variables, but this " + "subcommand tries to apply it to string " + "variable %s."), + var_get_name (vars[j])); + goto error; + } + break; + + case CCT_STRING: + if (parse_strings) + { + double n; + if (!parse_category_string (cat->location, cat->string, dict, + common_format->type, &n)) + goto error; + + ss_dealloc (&cat->string); + + cat->type = CCT_NUMBER; + cat->number = n; + } + else if (!all_strings (vars, n_vars, cat)) + goto error; + break; + + case CCT_SRANGE: + if (parse_strings) + { + double n[2]; + + if (!cat->srange[0].string) + n[0] = -DBL_MAX; + else if (!parse_category_string (cat->location, + cat->srange[0], dict, + common_format->type, &n[0])) + goto error; + + if (!cat->srange[1].string) + n[1] = DBL_MAX; + else if (!parse_category_string (cat->location, + cat->srange[1], dict, + common_format->type, &n[1])) + goto error; + + ss_dealloc (&cat->srange[0]); + ss_dealloc (&cat->srange[1]); + + cat->type = CCT_NRANGE; + cat->nrange[0] = n[0]; + cat->nrange[1] = n[1]; + } + else if (!all_strings (vars, n_vars, cat)) + goto error; + break; + + case CCT_MISSING: + case CCT_OTHERNM: + case CCT_SUBTOTAL: + case CCT_TOTAL: + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + case CCT_EXCLUDED_MISSING: + break; + } + } + } + + free (vars); + return true; + +error: + free (vars); + return false; +} + +static void +ctables_nest_uninit (struct ctables_nest *nest) +{ + free (nest->vars); + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + ctables_summary_spec_set_uninit (&nest->specs[sv]); + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + free (nest->domains[dt]); +} + +static void +ctables_stack_uninit (struct ctables_stack *stack) +{ + if (stack) + { + for (size_t i = 0; i < stack->n; i++) + ctables_nest_uninit (&stack->nests[i]); + free (stack->nests); + } +} + +static struct ctables_stack +nest_fts (struct ctables_stack s0, struct ctables_stack s1) +{ + if (!s0.n) + return s1; + else if (!s1.n) + return s0; + + struct ctables_stack stack = { .nests = xnmalloc (s0.n, s1.n * sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + for (size_t j = 0; j < s1.n; j++) + { + const struct ctables_nest *a = &s0.nests[i]; + const struct ctables_nest *b = &s1.nests[j]; + + size_t allocate = a->n + b->n; + struct variable **vars = xnmalloc (allocate, sizeof *vars); + size_t n = 0; + for (size_t k = 0; k < a->n; k++) + vars[n++] = a->vars[k]; + for (size_t k = 0; k < b->n; k++) + vars[n++] = b->vars[k]; + assert (n == allocate); + + const struct ctables_nest *summary_src; + if (!a->specs[CSV_CELL].var) + summary_src = b; + else if (!b->specs[CSV_CELL].var) + summary_src = a; + else + NOT_REACHED (); + + struct ctables_nest *new = &stack.nests[stack.n++]; + *new = (struct ctables_nest) { + .vars = vars, + .scale_idx = (a->scale_idx != SIZE_MAX ? a->scale_idx + : b->scale_idx != SIZE_MAX ? a->n + b->scale_idx + : SIZE_MAX), + .n = n, + }; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + ctables_summary_spec_set_clone (&new->specs[sv], &summary_src->specs[sv]); + } + ctables_stack_uninit (&s0); + ctables_stack_uninit (&s1); + return stack; +} + +static struct ctables_stack +stack_fts (struct ctables_stack s0, struct ctables_stack s1) +{ + struct ctables_stack stack = { .nests = xnmalloc (s0.n + s1.n, sizeof *stack.nests) }; + for (size_t i = 0; i < s0.n; i++) + stack.nests[stack.n++] = s0.nests[i]; + for (size_t i = 0; i < s1.n; i++) + { + stack.nests[stack.n] = s1.nests[i]; + stack.nests[stack.n].group_head += s0.n; + stack.n++; + } + assert (stack.n == s0.n + s1.n); + free (s0.nests); + free (s1.nests); + return stack; +} + +static struct ctables_stack +var_fts (const struct ctables_axis *a) +{ + struct variable **vars = xmalloc (sizeof *vars); + *vars = a->var; + + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { + .vars = vars, + .n = 1, + .scale_idx = a->scale ? 0 : SIZE_MAX, + }; + if (a->specs[CSV_CELL].n || a->scale) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + ctables_summary_spec_set_clone (&nest->specs[sv], &a->specs[sv]); + nest->specs[sv].var = a->var; + nest->specs[sv].is_scale = a->scale; + } + return (struct ctables_stack) { .nests = nest, .n = 1 }; +} + +static struct ctables_stack +enumerate_fts (enum pivot_axis_type axis_type, const struct ctables_axis *a) +{ + if (!a) + return (struct ctables_stack) { .n = 0 }; + + switch (a->op) + { + case CTAO_VAR: + return var_fts (a); + + case CTAO_STACK: + return stack_fts (enumerate_fts (axis_type, a->subs[0]), + enumerate_fts (axis_type, a->subs[1])); + + case CTAO_NEST: + /* This should consider any of the scale variables found in the result to + be linked to each other listwise for SMISSING=LISTWISE. */ + return nest_fts (enumerate_fts (axis_type, a->subs[0]), + enumerate_fts (axis_type, a->subs[1])); + } + + NOT_REACHED (); +} + +union ctables_summary + { + /* COUNT, VALIDN, TOTALN. */ + double count; + + /* MINIMUM, MAXIMUM, RANGE. */ + struct + { + double min; + double max; + }; + + /* MEAN, SEMEAN, STDDEV, SUM, VARIANCE, *.SUM. */ + struct moments1 *moments; + + /* MEDIAN, MODE, PTILE. */ + struct + { + struct casewriter *writer; + double ovalid; + double ovalue; + }; + + /* XXX multiple response */ + }; + +static void +ctables_summary_init (union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + s->count = 0; + break; + + case CTSF_ROW_ID: + case CTSF_COL_ID: + case CTSF_TABLE_ID: + case CTSF_SUBTABLE_ID: + case CTSF_LAYER_ID: + case CTSF_LAYERROW_ID: + case CTSF_LAYERCOL_ID: + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + s->min = s->max = SYSMIS; + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + s->moments = moments1_create (MOMENT_VARIANCE); + break; + + case CTSF_MEDIAN: + case CTSF_MODE: + case CTSF_PTILE: + case CTSF_UMEDIAN: + case CTSF_UMODE: + case CTSF_UPTILE: + { + struct caseproto *proto = caseproto_create (); + proto = caseproto_add_width (proto, 0); + proto = caseproto_add_width (proto, 0); + + struct subcase ordering; + subcase_init (&ordering, 0, 0, SC_ASCEND); + s->writer = sort_create_writer (&ordering, proto); + subcase_uninit (&ordering); + caseproto_unref (proto); + + s->ovalid = 0; + s->ovalue = SYSMIS; + } + break; + } +} + +static void +ctables_summary_uninit (union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + break; + + case CTSF_ROW_ID: + case CTSF_COL_ID: + case CTSF_TABLE_ID: + case CTSF_SUBTABLE_ID: + case CTSF_LAYER_ID: + case CTSF_LAYERROW_ID: + case CTSF_LAYERCOL_ID: + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + moments1_destroy (s->moments); + break; + + case CTSF_MEDIAN: + case CTSF_MODE: + case CTSF_PTILE: + case CTSF_UMEDIAN: + case CTSF_UMODE: + case CTSF_UPTILE: + casewriter_destroy (s->writer); + break; + } +} + +static void +ctables_summary_add (union ctables_summary *s, + const struct ctables_summary_spec *ss, + const struct variable *var, const union value *value, + bool is_scale, bool is_scale_missing, + bool is_missing, bool excluded_missing, + double d_weight, double e_weight) +{ + /* To determine whether a case is included in a given table for a particular + kind of summary, consider the following charts for each variable in the + table. Only if "yes" appears for every variable for the summary is the + case counted. + + Categorical variables: VALIDN COUNT TOTALN + Valid values in included categories yes yes yes + Missing values in included categories --- yes yes + Missing values in excluded categories --- --- yes + Valid values in excluded categories --- --- --- + + Scale variables: VALIDN COUNT TOTALN + Valid value yes yes yes + Missing value --- yes yes + + Missing values include both user- and system-missing. (The system-missing + value is always in an excluded category.) + */ + switch (ss->function) + { + case CSTF_TOTALN: + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + s->count += d_weight; + break; + + case CSTF_UTOTALN: + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + s->count += 1.0; + break; + + case CTSF_COUNT: + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + if (is_scale || !excluded_missing) + s->count += d_weight; + break; + + case CTSF_UCOUNT: + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + if (is_scale || !excluded_missing) + s->count += 1.0; + break; + + case CTSF_VALIDN: + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + if (is_scale + ? !is_scale_missing + : !is_missing) + s->count += d_weight; + break; + + case CTSF_UVALIDN: + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + if (is_scale + ? !is_scale_missing + : !is_missing) + s->count += 1.0; + break; + + case CTSF_ROW_ID: + case CTSF_COL_ID: + case CTSF_TABLE_ID: + case CTSF_SUBTABLE_ID: + case CTSF_LAYER_ID: + case CTSF_LAYERROW_ID: + case CTSF_LAYERCOL_ID: + break; + + case CTSF_MISSING: + if (is_missing) + s->count += d_weight; + break; + + case CTSF_UMISSING: + if (is_missing) + s->count += 1.0; + break; + + case CTSF_ECOUNT: + if (is_scale || !excluded_missing) + s->count += e_weight; + break; + + case CTSF_EVALIDN: + if (is_scale + ? !is_scale_missing + : !is_missing) + s->count += e_weight; + break; + + case CTSF_ETOTALN: + s->count += e_weight; + break; + + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + if (!is_scale_missing) + { + assert (!var_is_alpha (var)); /* XXX? */ + if (s->min == SYSMIS || value->f < s->min) + s->min = value->f; + if (s->max == SYSMIS || value->f > s->max) + s->max = value->f; + } + break; + + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + if (!is_scale_missing) + moments1_add (s->moments, value->f, e_weight); + break; + + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + if (!is_scale_missing) + moments1_add (s->moments, value->f, 1.0); + break; + + case CTSF_UMEDIAN: + case CTSF_UMODE: + case CTSF_UPTILE: + d_weight = e_weight = 1.0; + /* Fall through. */ + case CTSF_MEDIAN: + case CTSF_MODE: + case CTSF_PTILE: + if (!is_scale_missing) + { + s->ovalid += e_weight; + + struct ccase *c = case_create (casewriter_get_proto (s->writer)); + *case_num_rw_idx (c, 0) = value->f; + *case_num_rw_idx (c, 1) = e_weight; + casewriter_write (s->writer, c); + } + break; + } +} + +static enum ctables_domain_type +ctables_function_domain (enum ctables_summary_function function) +{ + switch (function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_MODE: + case CTSF_UCOUNT: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UMEDIAN: + case CTSF_UPTILE: + case CTSF_UMODE: + NOT_REACHED (); + + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_SUM: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + case CTSF_UCOLPCT_COUNT: + case CTSF_UCOLPCT_SUM: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_COL_ID: + return CTDT_COL; + + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_ULAYERCOLPCT_SUM: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_LAYERCOL_ID: + return CTDT_LAYERCOL; + + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_LAYER_ID: + return CTDT_LAYER; + + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_LAYERROW_ID: + return CTDT_LAYERROW; + + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_SUM: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + case CTSF_UROWPCT_COUNT: + case CTSF_UROWPCT_SUM: + case CTSF_UROWPCT_TOTALN: + case CTSF_UROWPCT_VALIDN: + case CTSF_ROW_ID: + return CTDT_ROW; + + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_SUBTABLE_ID: + return CTDT_SUBTABLE; + + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_SUM: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_UTABLEPCT_COUNT: + case CTSF_UTABLEPCT_SUM: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_TABLE_ID: + return CTDT_TABLE; + } + + NOT_REACHED (); +} + +static enum ctables_domain_type +ctables_function_is_pctsum (enum ctables_summary_function function) +{ + switch (function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_MISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CTSF_VALIDN: + case CTSF_EVALIDN: + case CTSF_MAXIMUM: + case CTSF_MINIMUM: + case CTSF_RANGE: + case CTSF_MEAN: + case CTSF_SEMEAN: + case CTSF_STDDEV: + case CTSF_SUM: + case CTSF_VARIANCE: + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_MODE: + case CTSF_UCOUNT: + case CTSF_UMISSING: + case CSTF_UTOTALN: + case CTSF_UVALIDN: + case CTSF_UMEAN: + case CTSF_USEMEAN: + case CTSF_USTDDEV: + case CTSF_USUM: + case CTSF_UVARIANCE: + case CTSF_UMEDIAN: + case CTSF_UPTILE: + case CTSF_UMODE: + case CTSF_COLPCT_COUNT: + case CTSF_COLPCT_TOTALN: + case CTSF_COLPCT_VALIDN: + case CTSF_UCOLPCT_COUNT: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_LAYERCOLPCT_COUNT: + case CTSF_LAYERCOLPCT_TOTALN: + case CTSF_LAYERCOLPCT_VALIDN: + case CTSF_ULAYERCOLPCT_COUNT: + case CTSF_ULAYERCOLPCT_TOTALN: + case CTSF_ULAYERCOLPCT_VALIDN: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ROWPCT_COUNT: + case CTSF_ROWPCT_TOTALN: + case CTSF_ROWPCT_VALIDN: + case CTSF_UROWPCT_COUNT: + case CTSF_UROWPCT_TOTALN: + case CTSF_UROWPCT_VALIDN: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_TABLEPCT_COUNT: + case CTSF_TABLEPCT_TOTALN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_UTABLEPCT_COUNT: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_ROW_ID: + case CTSF_COL_ID: + case CTSF_TABLE_ID: + case CTSF_SUBTABLE_ID: + case CTSF_LAYER_ID: + case CTSF_LAYERROW_ID: + case CTSF_LAYERCOL_ID: + return false; + + case CTSF_COLPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ROWPCT_SUM: + case CTSF_UROWPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_UTABLEPCT_SUM: + return true; + } + + NOT_REACHED (); +} + +static double +ctables_summary_value (const struct ctables_cell *cell, + union ctables_summary *s, + const struct ctables_summary_spec *ss) +{ + switch (ss->function) + { + case CTSF_COUNT: + case CTSF_ECOUNT: + case CTSF_UCOUNT: + return s->count; + + case CTSF_ROW_ID: + case CTSF_COL_ID: + case CTSF_TABLE_ID: + case CTSF_SUBTABLE_ID: + case CTSF_LAYER_ID: + case CTSF_LAYERROW_ID: + case CTSF_LAYERCOL_ID: + return cell->domains[ctables_function_domain (ss->function)]->sequence; + + case CTSF_ROWPCT_COUNT: + case CTSF_COLPCT_COUNT: + case CTSF_TABLEPCT_COUNT: + case CTSF_SUBTABLEPCT_COUNT: + case CTSF_LAYERPCT_COUNT: + case CTSF_LAYERROWPCT_COUNT: + case CTSF_LAYERCOLPCT_COUNT: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_count + ? s->count / cell->domains[d]->e_count * 100 + : SYSMIS); + } + + case CTSF_UROWPCT_COUNT: + case CTSF_UCOLPCT_COUNT: + case CTSF_UTABLEPCT_COUNT: + case CTSF_USUBTABLEPCT_COUNT: + case CTSF_ULAYERPCT_COUNT: + case CTSF_ULAYERROWPCT_COUNT: + case CTSF_ULAYERCOLPCT_COUNT: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->u_count + ? s->count / cell->domains[d]->u_count * 100 + : SYSMIS); + } + + case CTSF_ROWPCT_VALIDN: + case CTSF_COLPCT_VALIDN: + case CTSF_TABLEPCT_VALIDN: + case CTSF_SUBTABLEPCT_VALIDN: + case CTSF_LAYERPCT_VALIDN: + case CTSF_LAYERROWPCT_VALIDN: + case CTSF_LAYERCOLPCT_VALIDN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_valid + ? s->count / cell->domains[d]->e_valid * 100 + : SYSMIS); + } + + case CTSF_UROWPCT_VALIDN: + case CTSF_UCOLPCT_VALIDN: + case CTSF_UTABLEPCT_VALIDN: + case CTSF_USUBTABLEPCT_VALIDN: + case CTSF_ULAYERPCT_VALIDN: + case CTSF_ULAYERROWPCT_VALIDN: + case CTSF_ULAYERCOLPCT_VALIDN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->u_valid + ? s->count / cell->domains[d]->u_valid * 100 + : SYSMIS); + } + + case CTSF_ROWPCT_TOTALN: + case CTSF_COLPCT_TOTALN: + case CTSF_TABLEPCT_TOTALN: + case CTSF_SUBTABLEPCT_TOTALN: + case CTSF_LAYERPCT_TOTALN: + case CTSF_LAYERROWPCT_TOTALN: + case CTSF_LAYERCOLPCT_TOTALN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->e_total + ? s->count / cell->domains[d]->e_total * 100 + : SYSMIS); + } + + case CTSF_UROWPCT_TOTALN: + case CTSF_UCOLPCT_TOTALN: + case CTSF_UTABLEPCT_TOTALN: + case CTSF_USUBTABLEPCT_TOTALN: + case CTSF_ULAYERPCT_TOTALN: + case CTSF_ULAYERROWPCT_TOTALN: + case CTSF_ULAYERCOLPCT_TOTALN: + { + enum ctables_domain_type d = ctables_function_domain (ss->function); + return (cell->domains[d]->u_total + ? s->count / cell->domains[d]->u_total * 100 + : SYSMIS); + } + + case CTSF_MISSING: + case CTSF_UMISSING: + case CSTF_TOTALN: + case CTSF_ETOTALN: + case CSTF_UTOTALN: + case CTSF_VALIDN: + case CTSF_UVALIDN: + case CTSF_EVALIDN: + return s->count; + + case CTSF_MAXIMUM: + return s->max; + + case CTSF_MINIMUM: + return s->min; + + case CTSF_RANGE: + return s->max != SYSMIS && s->min != SYSMIS ? s->max - s->min : SYSMIS; + + case CTSF_MEAN: + case CTSF_UMEAN: + { + double mean; + moments1_calculate (s->moments, NULL, &mean, NULL, NULL, NULL); + return mean; + } + + case CTSF_SEMEAN: + case CTSF_USEMEAN: + { + double weight, variance; + moments1_calculate (s->moments, &weight, NULL, &variance, NULL, NULL); + return calc_semean (variance, weight); + } + + case CTSF_STDDEV: + case CTSF_USTDDEV: + { + double variance; + moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL); + return variance != SYSMIS ? sqrt (variance) : SYSMIS; + } + + case CTSF_SUM: + case CTSF_USUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + return weight != SYSMIS && mean != SYSMIS ? weight * mean : SYSMIS; + } + + case CTSF_VARIANCE: + case CTSF_UVARIANCE: + { + double variance; + moments1_calculate (s->moments, NULL, NULL, &variance, NULL, NULL); + return variance; + } + + case CTSF_ROWPCT_SUM: + case CTSF_COLPCT_SUM: + case CTSF_TABLEPCT_SUM: + case CTSF_SUBTABLEPCT_SUM: + case CTSF_LAYERPCT_SUM: + case CTSF_LAYERROWPCT_SUM: + case CTSF_LAYERCOLPCT_SUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + if (weight == SYSMIS || mean == SYSMIS) + return SYSMIS; + enum ctables_domain_type d = ctables_function_domain (ss->function); + double num = weight * mean; + double denom = cell->domains[d]->sums[ss->sum_var_idx].e_sum; + return denom != 0 ? num / denom * 100 : SYSMIS; + } + case CTSF_UROWPCT_SUM: + case CTSF_UCOLPCT_SUM: + case CTSF_UTABLEPCT_SUM: + case CTSF_USUBTABLEPCT_SUM: + case CTSF_ULAYERPCT_SUM: + case CTSF_ULAYERROWPCT_SUM: + case CTSF_ULAYERCOLPCT_SUM: + { + double weight, mean; + moments1_calculate (s->moments, &weight, &mean, NULL, NULL, NULL); + if (weight == SYSMIS || mean == SYSMIS) + return SYSMIS; + enum ctables_domain_type d = ctables_function_domain (ss->function); + double num = weight * mean; + double denom = cell->domains[d]->sums[ss->sum_var_idx].u_sum; + return denom != 0 ? num / denom * 100 : SYSMIS; + } + + case CTSF_MEDIAN: + case CTSF_PTILE: + case CTSF_UMEDIAN: + case CTSF_UPTILE: + if (s->writer) + { + struct casereader *reader = casewriter_make_reader (s->writer); + s->writer = NULL; + + struct percentile *ptile = percentile_create ( + ss->function == CTSF_PTILE ? ss->percentile : 0.5, s->ovalid); + struct order_stats *os = &ptile->parent; + order_stats_accumulate_idx (&os, 1, reader, 1, 0); + s->ovalue = percentile_calculate (ptile, PC_HAVERAGE); + statistic_destroy (&ptile->parent.parent); + } + return s->ovalue; + + case CTSF_MODE: + case CTSF_UMODE: + if (s->writer) + { + struct casereader *reader = casewriter_make_reader (s->writer); + s->writer = NULL; + + struct mode *mode = mode_create (); + struct order_stats *os = &mode->parent; + order_stats_accumulate_idx (&os, 1, reader, 1, 0); + s->ovalue = mode->mode; + statistic_destroy (&mode->parent.parent); + } + return s->ovalue; + } + + NOT_REACHED (); +} + +struct ctables_cell_sort_aux + { + const struct ctables_nest *nest; + enum pivot_axis_type a; + }; + +static int +ctables_cell_compare_3way (const void *a_, const void *b_, const void *aux_) +{ + const struct ctables_cell_sort_aux *aux = aux_; + struct ctables_cell *const *ap = a_; + struct ctables_cell *const *bp = b_; + const struct ctables_cell *a = *ap; + const struct ctables_cell *b = *bp; + + const struct ctables_nest *nest = aux->nest; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct variable *var = nest->vars[i]; + const struct ctables_cell_value *a_cv = &a->axes[aux->a].cvs[i]; + const struct ctables_cell_value *b_cv = &b->axes[aux->a].cvs[i]; + if (a_cv->category != b_cv->category) + return a_cv->category > b_cv->category ? 1 : -1; + + const union value *a_val = &a_cv->value; + const union value *b_val = &b_cv->value; + switch (a_cv->category->type) + { + case CCT_NUMBER: + case CCT_STRING: + case CCT_SUBTOTAL: + case CCT_TOTAL: + case CCT_POSTCOMPUTE: + case CCT_EXCLUDED_MISSING: + /* Must be equal. */ + continue; + + case CCT_NRANGE: + case CCT_SRANGE: + case CCT_MISSING: + case CCT_OTHERNM: + { + int cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + if (cmp) + return cmp; + } + break; + + case CCT_VALUE: + { + int cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + if (cmp) + return a_cv->category->sort_ascending ? cmp : -cmp; + } + break; + + case CCT_LABEL: + { + const char *a_label = var_lookup_value_label (var, a_val); + const char *b_label = var_lookup_value_label (var, b_val); + int cmp; + if (a_label) + { + if (!b_label) + return -1; + cmp = strcmp (a_label, b_label); + } + else + { + if (b_label) + return 1; + cmp = value_compare_3way (a_val, b_val, var_get_width (var)); + } + if (cmp) + return a_cv->category->sort_ascending ? cmp : -cmp; + } + break; + + case CCT_FUNCTION: + NOT_REACHED (); + } + } + return 0; +} + +static int +ctables_cell_compare_leaf_3way (const void *a_, const void *b_, + const void *aux UNUSED) +{ + struct ctables_cell *const *ap = a_; + struct ctables_cell *const *bp = b_; + const struct ctables_cell *a = *ap; + const struct ctables_cell *b = *bp; + + for (enum pivot_axis_type axis = 0; axis < PIVOT_N_AXES; axis++) + { + int al = a->axes[axis].leaf; + int bl = b->axes[axis].leaf; + if (al != bl) + return al > bl ? 1 : -1; + } + return 0; +} + +/* Algorithm: + + For each row: + For each ctables_table: + For each combination of row vars: + For each combination of column vars: + For each combination of layer vars: + Add entry + Make a table of row values: + Sort entries by row values + Assign a 0-based index to each actual value + Construct a dimension + Make a table of column values + Make a table of layer values + For each entry: + Fill the table entry using the indexes from before. + */ + +static struct ctables_domain * +ctables_domain_insert (struct ctables_section *s, struct ctables_cell *cell, + enum ctables_domain_type domain) +{ + size_t hash = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n_domains[domain]; i++) + { + size_t v_idx = nest->domains[domain][i]; + struct ctables_cell_value *cv = &cell->axes[a].cvs[v_idx]; + hash = hash_pointer (cv->category, hash); + if (cv->category->type != CCT_TOTAL + && cv->category->type != CCT_SUBTOTAL + && cv->category->type != CCT_POSTCOMPUTE) + hash = value_hash (&cv->value, + var_get_width (nest->vars[v_idx]), hash); + } + } + + struct ctables_domain *d; + HMAP_FOR_EACH_WITH_HASH (d, struct ctables_domain, node, hash, &s->domains[domain]) + { + const struct ctables_cell *df = d->example; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n_domains[domain]; i++) + { + size_t v_idx = nest->domains[domain][i]; + struct ctables_cell_value *cv1 = &df->axes[a].cvs[v_idx]; + struct ctables_cell_value *cv2 = &cell->axes[a].cvs[v_idx]; + if (cv1->category != cv2->category + || (cv1->category->type != CCT_TOTAL + && cv1->category->type != CCT_SUBTOTAL + && cv1->category->type != CCT_POSTCOMPUTE + && !value_equal (&cv1->value, &cv2->value, + var_get_width (nest->vars[v_idx])))) + goto not_equal; + } + } + return d; + + not_equal: ; + } + + struct ctables_sum *sums = (s->table->n_sum_vars + ? xzalloc (s->table->n_sum_vars * sizeof *sums) + : NULL); + + d = xmalloc (sizeof *d); + *d = (struct ctables_domain) { .example = cell, .sums = sums }; + hmap_insert (&s->domains[domain], &d->node, hash); + return d; +} + +static struct substring +rtrim_value (const union value *v, const struct variable *var) +{ + struct substring s = ss_buffer (CHAR_CAST (char *, v->s), + var_get_width (var)); + ss_rtrim (&s, ss_cstr (" ")); + return s; +} + +static bool +in_string_range (const union value *v, const struct variable *var, + const struct substring *srange) +{ + struct substring s = rtrim_value (v, var); + return ((!srange[0].string || ss_compare (s, srange[0]) >= 0) + && (!srange[1].string || ss_compare (s, srange[1]) <= 0)); +} + +static const struct ctables_category * +ctables_categories_match (const struct ctables_categories *c, + const union value *v, const struct variable *var) +{ + if (var_is_numeric (var) && v->f == SYSMIS) + return NULL; + + const struct ctables_category *othernm = NULL; + for (size_t i = c->n_cats; i-- > 0; ) + { + const struct ctables_category *cat = &c->cats[i]; + switch (cat->type) + { + case CCT_NUMBER: + if (cat->number == v->f) + return cat; + break; + + case CCT_STRING: + if (ss_equals (cat->string, rtrim_value (v, var))) + return cat; + break; + + case CCT_NRANGE: + if ((cat->nrange[0] == -DBL_MAX || v->f >= cat->nrange[0]) + && (cat->nrange[1] == DBL_MAX || v->f <= cat->nrange[1])) + return cat; + break; + + case CCT_SRANGE: + if (in_string_range (v, var, cat->srange)) + return cat; + break; + + case CCT_MISSING: + if (var_is_value_missing (var, v)) + return cat; + break; + + case CCT_POSTCOMPUTE: + break; + + case CCT_OTHERNM: + if (!othernm) + othernm = cat; + break; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + return (cat->include_missing || !var_is_value_missing (var, v) ? cat + : NULL); + + case CCT_EXCLUDED_MISSING: + break; + } + } + + return var_is_value_missing (var, v) ? NULL : othernm; +} + +static const struct ctables_category * +ctables_categories_total (const struct ctables_categories *c) +{ + const struct ctables_category *first = &c->cats[0]; + const struct ctables_category *last = &c->cats[c->n_cats - 1]; + return (first->type == CCT_TOTAL ? first + : last->type == CCT_TOTAL ? last + : NULL); +} + +static struct ctables_cell * +ctables_cell_insert__ (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10]) +{ + size_t hash = 0; + enum ctables_summary_variant sv = CSV_CELL; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + hash = hash_pointer (cats[a][i], hash); + if (cats[a][i]->type != CCT_TOTAL + && cats[a][i]->type != CCT_SUBTOTAL + && cats[a][i]->type != CCT_POSTCOMPUTE) + hash = value_hash (case_data (c, nest->vars[i]), + var_get_width (nest->vars[i]), hash); + else + sv = CSV_TOTAL; + } + } + + struct ctables_cell *cell; + HMAP_FOR_EACH_WITH_HASH (cell, struct ctables_cell, node, hash, &s->cells) + { + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx + && (cats[a][i] != cell->axes[a].cvs[i].category + || (cats[a][i]->type != CCT_TOTAL + && cats[a][i]->type != CCT_SUBTOTAL + && cats[a][i]->type != CCT_POSTCOMPUTE + && !value_equal (case_data (c, nest->vars[i]), + &cell->axes[a].cvs[i].value, + var_get_width (nest->vars[i]))))) + goto not_equal; + } + + return cell; + + not_equal: ; + } + + cell = xmalloc (sizeof *cell); + cell->hide = false; + cell->sv = sv; + cell->omit_domains = 0; + cell->postcompute = false; + //struct string name = DS_EMPTY_INITIALIZER; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + cell->axes[a].cvs = (nest->n + ? xnmalloc (nest->n, sizeof *cell->axes[a].cvs) + : NULL); + for (size_t i = 0; i < nest->n; i++) + { + const struct ctables_category *cat = cats[a][i]; + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + if (i != nest->scale_idx) + { + const struct ctables_category *subtotal = cat->subtotal; + if (cat->hide || (subtotal && subtotal->hide_subcategories)) + cell->hide = true; + + if (cat->type == CCT_TOTAL + || cat->type == CCT_SUBTOTAL + || cat->type == CCT_POSTCOMPUTE) + { + /* XXX these should be more encompassing I think.*/ + + switch (a) + { + case PIVOT_AXIS_COLUMN: + cell->omit_domains |= ((1u << CTDT_TABLE) | + (1u << CTDT_LAYER) | + (1u << CTDT_LAYERCOL) | + (1u << CTDT_SUBTABLE) | + (1u << CTDT_COL)); + break; + case PIVOT_AXIS_ROW: + cell->omit_domains |= ((1u << CTDT_TABLE) | + (1u << CTDT_LAYER) | + (1u << CTDT_LAYERROW) | + (1u << CTDT_SUBTABLE) | + (1u << CTDT_ROW)); + break; + case PIVOT_AXIS_LAYER: + cell->omit_domains |= ((1u << CTDT_TABLE) | + (1u << CTDT_LAYER)); + break; + } + } + if (cat->type == CCT_POSTCOMPUTE) + cell->postcompute = true; + } + + cell->axes[a].cvs[i].category = cat; + value_clone (&cell->axes[a].cvs[i].value, value, var_get_width (var)); + +#if 0 + if (i != nest->scale_idx) + { + if (!ds_is_empty (&name)) + ds_put_cstr (&name, ", "); + char *value_s = data_out (value, var_get_encoding (var), + var_get_print_format (var), + settings_get_fmt_settings ()); + if (cat->type == CCT_TOTAL + || cat->type == CCT_SUBTOTAL + || cat->type == CCT_POSTCOMPUTE) + ds_put_format (&name, "%s=total", var_get_name (var)); + else + ds_put_format (&name, "%s=%s", var_get_name (var), + value_s + strspn (value_s, " ")); + free (value_s); + } +#endif + } + } + //cell->name = ds_steal_cstr (&name); + + const struct ctables_nest *ss = s->nests[s->table->summary_axis]; + const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv]; + cell->summaries = xmalloc (specs->n * sizeof *cell->summaries); + for (size_t i = 0; i < specs->n; i++) + ctables_summary_init (&cell->summaries[i], &specs->specs[i]); + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + cell->domains[dt] = ctables_domain_insert (s, cell, dt); + hmap_insert (&s->cells, &cell->node, hash); + return cell; +} + +static bool +is_scale_missing (const struct ctables_summary_spec_set *specs, + const struct ccase *c) +{ + if (!specs->is_scale) + return false; + + if (var_is_num_missing (specs->var, case_num (c, specs->var))) + return true; + + for (size_t i = 0; i < specs->n_listwise_vars; i++) + { + const struct variable *var = specs->listwise_vars[i]; + if (var_is_num_missing (var, case_num (c, var))) + return true; + } + + return false; +} + +static void +ctables_cell_add__ (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10], + bool is_missing, bool excluded_missing, + double d_weight, double e_weight) +{ + struct ctables_cell *cell = ctables_cell_insert__ (s, c, cats); + const struct ctables_nest *ss = s->nests[s->table->summary_axis]; + + const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv]; + + bool scale_missing = is_scale_missing (specs, c); + for (size_t i = 0; i < specs->n; i++) + ctables_summary_add (&cell->summaries[i], &specs->specs[i], + specs->var, case_data (c, specs->var), specs->is_scale, + scale_missing, is_missing, excluded_missing, + d_weight, e_weight); + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + if (!(cell->omit_domains && (1u << dt))) + { + struct ctables_domain *d = cell->domains[dt]; + d->d_total += d_weight; + d->e_total += e_weight; + d->u_total += 1.0; + if (!excluded_missing) + { + d->d_count += d_weight; + d->e_count += e_weight; + d->u_count += 1.0; + } + if (!is_missing) + { + d->d_valid += d_weight; + d->e_valid += e_weight; + d->u_count += 1.0; + + for (size_t i = 0; i < s->table->n_sum_vars; i++) + { + /* XXX listwise_missing??? */ + const struct variable *var = s->table->sum_vars[i]; + double addend = case_num (c, var); + if (!var_is_num_missing (var, addend)) + { + struct ctables_sum *sum = &d->sums[i]; + sum->e_sum += addend * e_weight; + sum->u_sum += addend; + } + } + } + } +} + +static void +recurse_totals (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10], + bool is_missing, bool excluded_missing, + double d_weight, double e_weight, + enum pivot_axis_type start_axis, size_t start_nest) +{ + for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = start_nest; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct variable *var = nest->vars[i]; + + const struct ctables_category *total = ctables_categories_total ( + s->table->categories[var_get_dict_index (var)]); + if (total) + { + const struct ctables_category *save = cats[a][i]; + cats[a][i] = total; + ctables_cell_add__ (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight); + recurse_totals (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight, a, i + 1); + cats[a][i] = save; + } + } + start_nest = 0; + } +} + +static void +recurse_subtotals (struct ctables_section *s, const struct ccase *c, + const struct ctables_category *cats[PIVOT_N_AXES][10], + bool is_missing, bool excluded_missing, + double d_weight, double e_weight, + enum pivot_axis_type start_axis, size_t start_nest) +{ + for (enum pivot_axis_type a = start_axis; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = start_nest; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct ctables_category *save = cats[a][i]; + if (save->subtotal) + { + cats[a][i] = save->subtotal; + ctables_cell_add__ (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight); + recurse_subtotals (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight, a, i + 1); + cats[a][i] = save; + } + } + start_nest = 0; + } +} + +static void +ctables_add_occurrence (const struct variable *var, + const union value *value, + struct hmap *occurrences) +{ + int width = var_get_width (var); + unsigned int hash = value_hash (value, width, 0); + + struct ctables_occurrence *o; + HMAP_FOR_EACH_WITH_HASH (o, struct ctables_occurrence, node, hash, + occurrences) + if (value_equal (value, &o->value, width)) + return; + + o = xmalloc (sizeof *o); + value_clone (&o->value, value, width); + hmap_insert (occurrences, &o->node, hash); +} + +static void +ctables_cell_insert (struct ctables_section *s, + const struct ccase *c, + double d_weight, double e_weight) +{ + const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */ + + /* Does at least one categorical variable have a missing value in an included + or excluded category? */ + bool is_missing = false; + + /* Does at least one categorical variable have a missing value in an excluded + category? */ + bool excluded_missing = false; + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + { + if (i == nest->scale_idx) + continue; + + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + + bool var_missing = var_is_value_missing (var, value) != 0; + if (var_missing) + is_missing = true; + + cats[a][i] = ctables_categories_match ( + s->table->categories[var_get_dict_index (var)], value, var); + if (!cats[a][i]) + { + if (!var_missing) + return; + + static const struct ctables_category cct_excluded_missing = { + .type = CCT_EXCLUDED_MISSING, + .hide = true, + }; + cats[a][i] = &cct_excluded_missing; + excluded_missing = true; + } + } + } + + if (!excluded_missing) + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct variable *var = nest->vars[i]; + const union value *value = case_data (c, var); + ctables_add_occurrence (var, value, &s->occurrences[a][i]); + } + } + + ctables_cell_add__ (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight); + + //if (!excluded_missing) + { + recurse_totals (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight, 0, 0); + recurse_subtotals (s, c, cats, is_missing, excluded_missing, + d_weight, e_weight, 0, 0); + } +} + +struct merge_item + { + const struct ctables_summary_spec_set *set; + size_t ofs; + }; + +static int +merge_item_compare_3way (const struct merge_item *a, const struct merge_item *b) +{ + const struct ctables_summary_spec *as = &a->set->specs[a->ofs]; + const struct ctables_summary_spec *bs = &b->set->specs[b->ofs]; + if (as->function != bs->function) + return as->function > bs->function ? 1 : -1; + else if (as->percentile != bs->percentile) + return as->percentile < bs->percentile ? 1 : -1; + + const char *as_label = as->label ? as->label : ""; + const char *bs_label = bs->label ? bs->label : ""; + return strcmp (as_label, bs_label); +} + +static struct pivot_value * +ctables_category_create_label__ (const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + return (cat->type == CCT_TOTAL || cat->type == CCT_SUBTOTAL + ? pivot_value_new_user_text (cat->total_label, SIZE_MAX) + : pivot_value_new_var_value (var, value)); +} + +static struct pivot_value * +ctables_postcompute_label (const struct ctables_categories *cats, + const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + struct substring in = ss_cstr (cat->pc->label); + struct substring target = ss_cstr (")LABEL["); + + struct string out = DS_EMPTY_INITIALIZER; + for (;;) + { + size_t chunk = ss_find_substring (in, target); + if (chunk == SIZE_MAX) + { + if (ds_is_empty (&out)) + return pivot_value_new_user_text (in.string, in.length); + else + { + ds_put_substring (&out, in); + return pivot_value_new_user_text_nocopy (ds_steal_cstr (&out)); + } + } + + ds_put_substring (&out, ss_head (in, chunk)); + ss_advance (&in, chunk + target.length); + + struct substring idx_s; + if (!ss_get_until (&in, ']', &idx_s)) + goto error; + char *tail; + long int idx = strtol (idx_s.string, &tail, 10); + if (idx < 1 || idx > cats->n_cats || tail != ss_end (idx_s)) + goto error; + + struct ctables_category *cat2 = &cats->cats[idx - 1]; + struct pivot_value *label2 + = ctables_category_create_label__ (cat2, var, value); + char *label2_s = pivot_value_to_string_defaults (label2); + ds_put_cstr (&out, label2_s); + free (label2_s); + pivot_value_destroy (label2); + } + +error: + ds_destroy (&out); + return pivot_value_new_user_text (cat->pc->label, SIZE_MAX); +} + +static struct pivot_value * +ctables_category_create_label (const struct ctables_categories *cats, + const struct ctables_category *cat, + const struct variable *var, + const union value *value) +{ + return (cat->type == CCT_POSTCOMPUTE && cat->pc->label + ? ctables_postcompute_label (cats, cat, var, value) + : ctables_category_create_label__ (cat, var, value)); +} + +static struct ctables_value * +ctables_value_find__ (struct ctables_table *t, const union value *value, + int width, unsigned int hash) +{ + struct ctables_value *clv; + HMAP_FOR_EACH_WITH_HASH (clv, struct ctables_value, node, + hash, &t->clabels_values_map) + if (value_equal (value, &clv->value, width)) + return clv; + return NULL; +} + +static void +ctables_value_insert (struct ctables_table *t, const union value *value, + int width) +{ + unsigned int hash = value_hash (value, width, 0); + struct ctables_value *clv = ctables_value_find__ (t, value, width, hash); + if (!clv) + { + clv = xmalloc (sizeof *clv); + value_clone (&clv->value, value, width); + hmap_insert (&t->clabels_values_map, &clv->node, hash); + } +} + +static struct ctables_value * +ctables_value_find (struct ctables_table *t, + const union value *value, int width) +{ + return ctables_value_find__ (t, value, width, + value_hash (value, width, 0)); +} + +static void +ctables_table_add_section (struct ctables_table *t, enum pivot_axis_type a, + size_t ix[PIVOT_N_AXES]) +{ + if (a < PIVOT_N_AXES) + { + size_t limit = MAX (t->stacks[a].n, 1); + for (ix[a] = 0; ix[a] < limit; ix[a]++) + ctables_table_add_section (t, a + 1, ix); + } + else + { + struct ctables_section *s = &t->sections[t->n_sections++]; + *s = (struct ctables_section) { + .table = t, + .cells = HMAP_INITIALIZER (s->cells), + }; + for (a = 0; a < PIVOT_N_AXES; a++) + if (t->stacks[a].n) + { + struct ctables_nest *nest = &t->stacks[a].nests[ix[a]]; + s->nests[a] = nest; + s->occurrences[a] = xnmalloc (nest->n, sizeof *s->occurrences[a]); + for (size_t i = 0; i < nest->n; i++) + hmap_init (&s->occurrences[a][i]); + } + for (size_t i = 0; i < N_CTDTS; i++) + hmap_init (&s->domains[i]); + } +} + +static double +ctpo_add (double a, double b) +{ + return a + b; +} + +static double +ctpo_sub (double a, double b) +{ + return a - b; +} + +static double +ctpo_mul (double a, double b) +{ + return a * b; +} + +static double +ctpo_div (double a, double b) +{ + return b ? a / b : SYSMIS; +} + +static double +ctpo_pow (double a, double b) +{ + int save_errno = errno; + errno = 0; + double result = pow (a, b); + if (errno) + result = SYSMIS; + errno = save_errno; + return result; +} + +static double +ctpo_neg (double a, double b UNUSED) +{ + return -a; +} + +struct ctables_pcexpr_evaluate_ctx + { + const struct ctables_cell *cell; + const struct ctables_section *section; + const struct ctables_categories *cats; + enum pivot_axis_type pc_a; + size_t pc_a_idx; + size_t summary_idx; + enum fmt_type parse_format; + }; + +static double ctables_pcexpr_evaluate ( + const struct ctables_pcexpr_evaluate_ctx *, const struct ctables_pcexpr *); + +static double +ctables_pcexpr_evaluate_nonterminal ( + const struct ctables_pcexpr_evaluate_ctx *ctx, + const struct ctables_pcexpr *e, size_t n_args, + double evaluate (double, double)) +{ + double args[2] = { 0, 0 }; + for (size_t i = 0; i < n_args; i++) + { + args[i] = ctables_pcexpr_evaluate (ctx, e->subs[i]); + if (!isfinite (args[i]) || args[i] == SYSMIS) + return SYSMIS; + } + return evaluate (args[0], args[1]); +} + +static double +ctables_pcexpr_evaluate_category (const struct ctables_pcexpr_evaluate_ctx *ctx, + const struct ctables_cell_value *pc_cv) +{ + const struct ctables_section *s = ctx->section; + + size_t hash = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct ctables_cell_value *cv + = (a == ctx->pc_a && i == ctx->pc_a_idx ? pc_cv + : &ctx->cell->axes[a].cvs[i]); + hash = hash_pointer (cv->category, hash); + if (cv->category->type != CCT_TOTAL + && cv->category->type != CCT_SUBTOTAL + && cv->category->type != CCT_POSTCOMPUTE) + hash = value_hash (&cv->value, + var_get_width (nest->vars[i]), hash); + } + } + + struct ctables_cell *tc; + HMAP_FOR_EACH_WITH_HASH (tc, struct ctables_cell, node, hash, &s->cells) + { + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct ctables_cell_value *p_cv + = (a == ctx->pc_a && i == ctx->pc_a_idx ? pc_cv + : &ctx->cell->axes[a].cvs[i]); + const struct ctables_cell_value *t_cv = &tc->axes[a].cvs[i]; + if (p_cv->category != t_cv->category + || (p_cv->category->type != CCT_TOTAL + && p_cv->category->type != CCT_SUBTOTAL + && p_cv->category->type != CCT_POSTCOMPUTE + && !value_equal (&p_cv->value, + &t_cv->value, + var_get_width (nest->vars[i])))) + goto not_equal; + } + } + + goto found; + + not_equal: ; + } + return 0; + +found: ; + const struct ctables_table *t = s->table; + const struct ctables_nest *specs_nest = s->nests[t->summary_axis]; + const struct ctables_summary_spec_set *specs = &specs_nest->specs[tc->sv]; + return ctables_summary_value (tc, &tc->summaries[ctx->summary_idx], + &specs->specs[ctx->summary_idx]); +} + +static double +ctables_pcexpr_evaluate (const struct ctables_pcexpr_evaluate_ctx *ctx, + const struct ctables_pcexpr *e) +{ + switch (e->op) + { + case CTPO_CONSTANT: + return e->number; + + case CTPO_CAT_NRANGE: + case CTPO_CAT_SRANGE: + { + struct ctables_cell_value cv = { + .category = ctables_find_category_for_postcompute (ctx->section->table->ctables->dict, ctx->cats, ctx->parse_format, e) + }; + assert (cv.category != NULL); + + struct hmap *occurrences = &ctx->section->occurrences[ctx->pc_a][ctx->pc_a_idx]; + const struct ctables_occurrence *o; + + double sum = 0.0; + const struct variable *var = ctx->section->nests[ctx->pc_a]->vars[ctx->pc_a_idx]; + HMAP_FOR_EACH (o, struct ctables_occurrence, node, occurrences) + if (ctables_categories_match (ctx->cats, &o->value, var) == cv.category) + { + cv.value = o->value; + sum += ctables_pcexpr_evaluate_category (ctx, &cv); + } + return sum; + } + + case CTPO_CAT_NUMBER: + case CTPO_CAT_MISSING: + case CTPO_CAT_OTHERNM: + case CTPO_CAT_SUBTOTAL: + case CTPO_CAT_TOTAL: + { + struct ctables_cell_value cv = { + .category = ctables_find_category_for_postcompute (ctx->section->table->ctables->dict, ctx->cats, ctx->parse_format, e), + .value = { .f = e->number }, + }; + assert (cv.category != NULL); + return ctables_pcexpr_evaluate_category (ctx, &cv); + } + + case CTPO_CAT_STRING: + { + int width = var_get_width (ctx->section->nests[ctx->pc_a]->vars[ctx->pc_a_idx]); + char *s = NULL; + if (width > e->string.length) + { + s = xmalloc (width); + buf_copy_rpad (s, width, e->string.string, e->string.length, ' '); + } + struct ctables_cell_value cv = { + .category = ctables_find_category_for_postcompute (ctx->section->table->ctables->dict, ctx->cats, ctx->parse_format, e), + .value = { .s = CHAR_CAST (uint8_t *, s ? s : e->string.string) }, + }; + assert (cv.category != NULL); + double retval = ctables_pcexpr_evaluate_category (ctx, &cv); + free (s); + return retval; + } + + case CTPO_ADD: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_add); + + case CTPO_SUB: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_sub); + + case CTPO_MUL: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_mul); + + case CTPO_DIV: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_div); + + case CTPO_POW: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 2, ctpo_pow); + + case CTPO_NEG: + return ctables_pcexpr_evaluate_nonterminal (ctx, e, 1, ctpo_neg); + } + + NOT_REACHED (); +} + +static const struct ctables_category * +ctables_cell_postcompute (const struct ctables_section *s, + const struct ctables_cell *cell, + enum pivot_axis_type *pc_a_p, + size_t *pc_a_idx_p) +{ + assert (cell->postcompute); + const struct ctables_category *pc_cat = NULL; + for (enum pivot_axis_type pc_a = 0; pc_a < PIVOT_N_AXES; pc_a++) + for (size_t pc_a_idx = 0; pc_a_idx < s->nests[pc_a]->n; pc_a_idx++) + { + const struct ctables_cell_value *cv = &cell->axes[pc_a].cvs[pc_a_idx]; + if (cv->category->type == CCT_POSTCOMPUTE) + { + if (pc_cat) + { + /* Multiple postcomputes cross each other. The value is + undefined. */ + return NULL; + } + + pc_cat = cv->category; + if (pc_a_p) + *pc_a_p = pc_a; + if (pc_a_idx_p) + *pc_a_idx_p = pc_a_idx; + } + } + + assert (pc_cat != NULL); + return pc_cat; +} + +static double +ctables_cell_calculate_postcompute (const struct ctables_section *s, + const struct ctables_cell *cell, + const struct ctables_summary_spec *ss, + struct fmt_spec *format, + bool *is_ctables_format, + size_t summary_idx) +{ + enum pivot_axis_type pc_a = 0; + size_t pc_a_idx = 0; + const struct ctables_category *pc_cat = ctables_cell_postcompute ( + s, cell, &pc_a, &pc_a_idx); + if (!pc_cat) + return SYSMIS; + + const struct ctables_postcompute *pc = pc_cat->pc; + if (pc->specs) + { + for (size_t i = 0; i < pc->specs->n; i++) + { + const struct ctables_summary_spec *ss2 = &pc->specs->specs[i]; + if (ss->function == ss2->function + && ss->percentile == ss2->percentile) + { + *format = ss2->format; + *is_ctables_format = ss2->is_ctables_format; + break; + } + } + } + + const struct variable *var = s->nests[pc_a]->vars[pc_a_idx]; + const struct ctables_categories *cats = s->table->categories[ + var_get_dict_index (var)]; + struct ctables_pcexpr_evaluate_ctx ctx = { + .cell = cell, + .section = s, + .cats = cats, + .pc_a = pc_a, + .pc_a_idx = pc_a_idx, + .summary_idx = summary_idx, + .parse_format = pc_cat->parse_format, + }; + return ctables_pcexpr_evaluate (&ctx, pc->expr); +} + +static char * +ctables_format (double d, const struct fmt_spec *format, + const struct fmt_settings *settings) +{ + const union value v = { .f = d }; + char *s = data_out_stretchy (&v, "UTF-8", format, settings, NULL); + + /* The custom-currency specifications for NEQUAL, PAREN, and PCTPAREN don't + produce the results we want for negative numbers, putting the negative + sign in the wrong spot, before the prefix instead of after it. We can't, + in fact, produce the desired results using a custom-currency + specification. Instead, we postprocess the output, moving the negative + sign into place: + + NEQUAL: "-N=3" => "N=-3" + PAREN: "-(3)" => "(-3)" + PCTPAREN: "-(3%)" => "(-3%)" + + This transformation doesn't affect NEGPAREN. */ + char *minus_src = strchr (s, '-'); + if (minus_src && (minus_src == s || minus_src[-1] != 'E')) + { + char *n_equals = strstr (s, "N="); + char *lparen = strchr (s, '('); + char *minus_dst = n_equals ? n_equals + 1 : lparen; + if (minus_dst) + move_element (s, minus_dst - s + 1, 1, minus_src - s, minus_dst - s); + } + return s; +} + +static void +ctables_table_output (struct ctables *ct, struct ctables_table *t) +{ + struct pivot_table *pt = pivot_table_create__ ( + (t->title + ? pivot_value_new_user_text (t->title, SIZE_MAX) + : pivot_value_new_text (N_("Custom Tables"))), + "Custom Tables"); + if (t->caption) + pivot_table_set_caption ( + pt, pivot_value_new_user_text (t->caption, SIZE_MAX)); + if (t->corner) + pivot_table_set_corner_text ( + pt, pivot_value_new_user_text (t->corner, SIZE_MAX)); + + bool summary_dimension = (t->summary_axis != t->slabels_axis + || (!t->slabels_visible + && t->summary_specs.n > 1)); + if (summary_dimension) + { + struct pivot_dimension *d = pivot_dimension_create ( + pt, t->slabels_axis, N_("Statistics")); + const struct ctables_summary_spec_set *specs = &t->summary_specs; + if (!t->slabels_visible) + d->hide_all_labels = true; + for (size_t i = 0; i < specs->n; i++) + pivot_category_create_leaf ( + d->root, ctables_summary_label (&specs->specs[i], t->cilevel)); + } + + bool categories_dimension = t->clabels_example != NULL; + if (categories_dimension) + { + struct pivot_dimension *d = pivot_dimension_create ( + pt, t->label_axis[t->clabels_from_axis], + t->clabels_from_axis == PIVOT_AXIS_ROW + ? N_("Row Categories") + : N_("Column Categories")); + const struct variable *var = t->clabels_example; + const struct ctables_categories *c = t->categories[var_get_dict_index (var)]; + for (size_t i = 0; i < t->n_clabels_values; i++) + { + const struct ctables_value *value = t->clabels_values[i]; + const struct ctables_category *cat = ctables_categories_match (c, &value->value, var); + assert (cat != NULL); + pivot_category_create_leaf (d->root, ctables_category_create_label ( + c, cat, t->clabels_example, + &value->value)); + } + } + + pivot_table_set_look (pt, ct->look); + struct pivot_dimension *d[PIVOT_N_AXES]; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + static const char *names[] = { + [PIVOT_AXIS_ROW] = N_("Rows"), + [PIVOT_AXIS_COLUMN] = N_("Columns"), + [PIVOT_AXIS_LAYER] = N_("Layers"), + }; + d[a] = (t->axes[a] || a == t->summary_axis + ? pivot_dimension_create (pt, a, names[a]) + : NULL); + if (!d[a]) + continue; + + assert (t->axes[a]); + + for (size_t i = 0; i < t->stacks[a].n; i++) + { + struct ctables_nest *nest = &t->stacks[a].nests[i]; + struct ctables_section **sections = xnmalloc (t->n_sections, + sizeof *sections); + size_t n_sections = 0; + + size_t n_total_cells = 0; + size_t max_depth = 0; + for (size_t j = 0; j < t->n_sections; j++) + if (t->sections[j].nests[a] == nest) + { + struct ctables_section *s = &t->sections[j]; + sections[n_sections++] = s; + n_total_cells += hmap_count (&s->cells); + + size_t depth = s->nests[a]->n; + max_depth = MAX (depth, max_depth); + } + + struct ctables_cell **sorted = xnmalloc (n_total_cells, + sizeof *sorted); + size_t n_sorted = 0; + + for (size_t j = 0; j < n_sections; j++) + { + struct ctables_section *s = sections[j]; + + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) + if (!cell->hide) + sorted[n_sorted++] = cell; + assert (n_sorted <= n_total_cells); + } + + struct ctables_cell_sort_aux aux = { .nest = nest, .a = a }; + sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_3way, &aux); + +#if 0 + if (a == PIVOT_AXIS_ROW) + { + size_t ids[N_CTDTS]; + memset (ids, 0, sizeof ids); + for (size_t j = 0; j < n_sorted; j++) + { + struct ctables_cell *cell = sorted[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + struct ctables_domain *domain = cell->domains[dt]; + if (!domain->sequence) + domain->sequence = ++ids[dt]; + } + } + } +#endif + +#if 0 + for (size_t j = 0; j < n_sorted; j++) + { + printf ("%s (%s): %f/%f = %.1f%%\n", sorted[j]->name, sorted[j]->contributes_to_domains ? "y" : "n", sorted[j]->summaries[0].count, sorted[j]->domains[CTDT_COL]->e_count, sorted[j]->summaries[0].count / sorted[j]->domains[CTDT_COL]->e_count * 100.0); + } + printf ("\n"); +#endif + + struct ctables_level + { + enum ctables_level_type + { + CTL_VAR, /* Variable label for nest->vars[var_idx]. */ + CTL_CATEGORY, /* Category for nest->vars[var_idx]. */ + CTL_SUMMARY, /* Summary functions. */ + } + type; + + enum settings_value_show vlabel; /* CTL_VAR only. */ + size_t var_idx; + }; + struct ctables_level *levels = xnmalloc (1 + 2 * max_depth, sizeof *levels); + size_t n_levels = 0; + for (size_t k = 0; k < nest->n; k++) + { + enum ctables_vlabel vlabel = ct->vlabels[var_get_dict_index (nest->vars[k])]; + if (vlabel != CTVL_NONE) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_VAR, + .vlabel = (enum settings_value_show) vlabel, + .var_idx = k, + }; + } + + if (nest->scale_idx != k + && (k != nest->n - 1 || t->label_axis[a] == a)) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_CATEGORY, + .var_idx = k, + }; + } + } + + if (!summary_dimension && a == t->slabels_axis) + { + levels[n_levels++] = (struct ctables_level) { + .type = CTL_SUMMARY, + .var_idx = SIZE_MAX, + }; + } + + /* Pivot categories: + + - variable label for nest->vars[0], if vlabel != CTVL_NONE + - category for nest->vars[0], if nest->scale_idx != 0 + - variable label for nest->vars[1], if vlabel != CTVL_NONE + - category for nest->vars[1], if nest->scale_idx != 1 + ... + - variable label for nest->vars[n - 1], if vlabel != CTVL_NONE + - category for nest->vars[n - 1], if t->label_axis[a] == a && nest->scale_idx != n - 1. + - summary function, if 'a == t->slabels_axis && a == + t->summary_axis'. + + Additional dimensions: + + - If 'a == t->slabels_axis && a != t->summary_axis', add a summary + dimension. + - If 't->label_axis[b] == a' for some 'b != a', add a category + dimension to 'a'. + */ + + + struct pivot_category **groups = xnmalloc (1 + 2 * max_depth, sizeof *groups); + int prev_leaf = 0; + for (size_t j = 0; j < n_sorted; j++) + { + struct ctables_cell *cell = sorted[j]; + struct ctables_cell *prev = j > 0 ? sorted[j - 1] : NULL; + + size_t n_common = 0; + if (j > 0) + { + for (; n_common < n_levels; n_common++) + { + const struct ctables_level *level = &levels[n_common]; + if (level->type == CTL_CATEGORY) + { + size_t var_idx = level->var_idx; + const struct ctables_category *c = cell->axes[a].cvs[var_idx].category; + if (prev->axes[a].cvs[var_idx].category != c) + break; + else if (c->type != CCT_SUBTOTAL + && c->type != CCT_TOTAL + && c->type != CCT_POSTCOMPUTE + && !value_equal (&prev->axes[a].cvs[var_idx].value, + &cell->axes[a].cvs[var_idx].value, + var_get_type (nest->vars[var_idx]))) + break; + } + } + } + + for (size_t k = n_common; k < n_levels; k++) + { + const struct ctables_level *level = &levels[k]; + struct pivot_category *parent = k ? groups[k - 1] : d[a]->root; + if (level->type == CTL_SUMMARY) + { + assert (k == n_levels - 1); + + const struct ctables_summary_spec_set *specs = &t->summary_specs; + for (size_t m = 0; m < specs->n; m++) + { + int leaf = pivot_category_create_leaf ( + parent, ctables_summary_label (&specs->specs[m], + t->cilevel)); + if (!m) + prev_leaf = leaf; + } + } + else + { + const struct variable *var = nest->vars[level->var_idx]; + struct pivot_value *label; + if (level->type == CTL_VAR) + { + label = pivot_value_new_variable (var); + label->variable.show = level->vlabel; + } + else if (level->type == CTL_CATEGORY) + { + const struct ctables_cell_value *cv = &cell->axes[a].cvs[level->var_idx]; + label = ctables_category_create_label ( + t->categories[var_get_dict_index (var)], + cv->category, var, &cv->value); + } + else + NOT_REACHED (); + + if (k == n_levels - 1) + prev_leaf = pivot_category_create_leaf (parent, label); + else + groups[k] = pivot_category_create_group__ (parent, label); + } + } + + cell->axes[a].leaf = prev_leaf; + } + free (sorted); + free (groups); + free (levels); + free (sections); + } + } + + { + size_t n_total_cells = 0; + for (size_t j = 0; j < t->n_sections; j++) + n_total_cells += hmap_count (&t->sections[j].cells); + + struct ctables_cell **sorted = xnmalloc (n_total_cells, sizeof *sorted); + size_t n_sorted = 0; + for (size_t j = 0; j < t->n_sections; j++) + { + const struct ctables_section *s = &t->sections[j]; + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) + if (!cell->hide) + sorted[n_sorted++] = cell; + } + assert (n_sorted <= n_total_cells); + sort (sorted, n_sorted, sizeof *sorted, ctables_cell_compare_leaf_3way, + NULL); + size_t ids[N_CTDTS]; + memset (ids, 0, sizeof ids); + for (size_t j = 0; j < n_sorted; j++) + { + struct ctables_cell *cell = sorted[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + struct ctables_domain *domain = cell->domains[dt]; + if (!domain->sequence) + domain->sequence = ++ids[dt]; + } + } + + free (sorted); + } + + for (size_t i = 0; i < t->n_sections; i++) + { + struct ctables_section *s = &t->sections[i]; + + struct ctables_cell *cell; + HMAP_FOR_EACH (cell, struct ctables_cell, node, &s->cells) + { + if (cell->hide) + continue; + + const struct ctables_nest *specs_nest = s->nests[t->summary_axis]; + const struct ctables_summary_spec_set *specs = &specs_nest->specs[cell->sv]; + for (size_t j = 0; j < specs->n; j++) + { + size_t dindexes[5]; + size_t n_dindexes = 0; + + if (summary_dimension) + dindexes[n_dindexes++] = specs->specs[j].axis_idx; + + if (categories_dimension) + { + const struct ctables_nest *clabels_nest = s->nests[t->clabels_from_axis]; + const struct variable *var = clabels_nest->vars[clabels_nest->n - 1]; + const union value *value = &cell->axes[t->clabels_from_axis].cvs[clabels_nest->n - 1].value; + const struct ctables_value *ctv = ctables_value_find (t, value, var_get_width (var)); + if (!ctv) + continue; + dindexes[n_dindexes++] = ctv->leaf; + } + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (d[a]) + { + int leaf = cell->axes[a].leaf; + if (a == t->summary_axis && !summary_dimension) + leaf += j; + dindexes[n_dindexes++] = leaf; + } + + const struct ctables_summary_spec *ss = &specs->specs[j]; + + struct fmt_spec format = specs->specs[j].format; + bool is_ctables_format = ss->is_ctables_format; + double d = (cell->postcompute + ? ctables_cell_calculate_postcompute ( + s, cell, ss, &format, &is_ctables_format, j) + : ctables_summary_value (cell, &cell->summaries[j], + ss)); + + struct pivot_value *value; + if (ct->hide_threshold != 0 + && d < ct->hide_threshold + && ctables_summary_function_is_count (ss->function)) + { + value = pivot_value_new_user_text_nocopy ( + xasprintf ("<%d", ct->hide_threshold)); + } + else if (d == 0 && ct->zero) + value = pivot_value_new_user_text (ct->zero, SIZE_MAX); + else if (d == SYSMIS && ct->missing) + value = pivot_value_new_user_text (ct->missing, SIZE_MAX); + else if (is_ctables_format) + value = pivot_value_new_user_text_nocopy ( + ctables_format (d, &format, &ct->ctables_formats)); + else + { + value = pivot_value_new_number (d); + value->numeric.format = format; + } + /* XXX should text values be right-justified? */ + pivot_table_put (pt, dindexes, n_dindexes, value); + } + } + } + + pivot_table_submit (pt); +} + +static bool +ctables_check_label_position (struct ctables_table *t, enum pivot_axis_type a) +{ + enum pivot_axis_type label_pos = t->label_axis[a]; + if (label_pos == a) + return true; + + t->clabels_from_axis = a; + + const char *subcommand_name = a == PIVOT_AXIS_ROW ? "ROWLABELS" : "COLLABELS"; + const char *pos_name = label_pos == PIVOT_AXIS_LAYER ? "LAYER" : "OPPOSITE"; + + const struct ctables_stack *stack = &t->stacks[a]; + if (!stack->n) + return true; + + const struct ctables_nest *n0 = &stack->nests[0]; + if (n0->n == 0) + { + assert (stack->n == 1); + return true; + } + + const struct variable *v0 = n0->vars[n0->n - 1]; + struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; + t->clabels_example = v0; + + for (size_t i = 0; i < c0->n_cats; i++) + if (c0->cats[i].type == CCT_FUNCTION) + { + msg (SE, _("%s=%s is not allowed with sorting based " + "on a summary function."), + subcommand_name, pos_name); + return false; + } + if (n0->n - 1 == n0->scale_idx) + { + msg (SE, _("%s=%s requires the variables to be moved to be categorical, " + "but %s is a scale variable."), + subcommand_name, pos_name, var_get_name (v0)); + return false; + } + + for (size_t i = 1; i < stack->n; i++) + { + const struct ctables_nest *ni = &stack->nests[i]; + assert (ni->n > 0); + const struct variable *vi = ni->vars[ni->n - 1]; + struct ctables_categories *ci = t->categories[var_get_dict_index (vi)]; + + if (ni->n - 1 == ni->scale_idx) + { + msg (SE, _("%s=%s requires the variables to be moved to be " + "categorical, but %s is a scale variable."), + subcommand_name, pos_name, var_get_name (vi)); + return false; + } + if (var_get_width (v0) != var_get_width (vi)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same width, but %s has " + "width %d and %s has width %d."), + subcommand_name, pos_name, + var_get_name (v0), var_get_width (v0), + var_get_name (vi), var_get_width (vi)); + return false; + } + if (!val_labs_equal (var_get_value_labels (v0), + var_get_value_labels (vi))) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same value labels, but %s " + "and %s have different value labels."), + subcommand_name, pos_name, + var_get_name (v0), var_get_name (vi)); + return false; + } + if (!ctables_categories_equal (c0, ci)) + { + msg (SE, _("%s=%s requires the variables to be " + "moved to have the same category " + "specifications, but %s and %s have different " + "category specifications."), + subcommand_name, pos_name, + var_get_name (v0), var_get_name (vi)); + return false; + } + } + + return true; +} + +static size_t +add_sum_var (struct variable *var, + struct variable ***sum_vars, size_t *n, size_t *allocated) +{ + for (size_t i = 0; i < *n; i++) + if (var == (*sum_vars)[i]) + return i; + + if (*n >= *allocated) + *sum_vars = x2nrealloc (*sum_vars, allocated, sizeof **sum_vars); + (*sum_vars)[*n] = var; + return (*n)++; +} + +static void +enumerate_sum_vars (const struct ctables_axis *a, + struct variable ***sum_vars, size_t *n, size_t *allocated) +{ + if (!a) + return; + + switch (a->op) + { + case CTAO_VAR: + for (size_t i = 0; i < N_CSVS; i++) + for (size_t j = 0; j < a->specs[i].n; j++) + { + struct ctables_summary_spec *spec = &a->specs[i].specs[j]; + if (ctables_function_is_pctsum (spec->function)) + spec->sum_var_idx = add_sum_var (a->var, sum_vars, n, allocated); + } + break; + + case CTAO_STACK: + case CTAO_NEST: + for (size_t i = 0; i < 2; i++) + enumerate_sum_vars (a->subs[i], sum_vars, n, allocated); + break; + } +} + +static bool +ctables_prepare_table (struct ctables_table *t) +{ + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->axes[a]) + { + t->stacks[a] = enumerate_fts (a, t->axes[a]); + + for (size_t j = 0; j < t->stacks[a].n; j++) + { + struct ctables_nest *nest = &t->stacks[a].nests[j]; + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + nest->domains[dt] = xmalloc (nest->n * sizeof *nest->domains[dt]); + nest->n_domains[dt] = 0; + + for (size_t k = 0; k < nest->n; k++) + { + if (k == nest->scale_idx) + continue; + + switch (dt) + { + case CTDT_TABLE: + continue; + + case CTDT_LAYER: + if (a != PIVOT_AXIS_LAYER) + continue; + break; + + case CTDT_SUBTABLE: + case CTDT_ROW: + case CTDT_COL: + if (dt == CTDT_SUBTABLE ? a != PIVOT_AXIS_LAYER + : dt == CTDT_ROW ? a == PIVOT_AXIS_COLUMN + : a == PIVOT_AXIS_ROW) + { + if (k == nest->n - 1 + || (nest->scale_idx == nest->n - 1 + && k == nest->n - 2)) + continue; + } + break; + + case CTDT_LAYERROW: + if (a == PIVOT_AXIS_COLUMN) + continue; + break; + + case CTDT_LAYERCOL: + if (a == PIVOT_AXIS_ROW) + continue; + break; + } + + nest->domains[dt][nest->n_domains[dt]++] = k; + } + } + } + } + else + { + struct ctables_nest *nest = xmalloc (sizeof *nest); + *nest = (struct ctables_nest) { .n = 0 }; + t->stacks[a] = (struct ctables_stack) { .nests = nest, .n = 1 }; + + /* There's no point in moving labels away from an axis that has no + labels, so avoid dealing with the special cases around that. */ + t->label_axis[a] = a; + } + + struct ctables_stack *stack = &t->stacks[t->summary_axis]; + for (size_t i = 0; i < stack->n; i++) + { + struct ctables_nest *nest = &stack->nests[i]; + if (!nest->specs[CSV_CELL].n) + { + struct ctables_summary_spec_set *specs = &nest->specs[CSV_CELL]; + specs->specs = xmalloc (sizeof *specs->specs); + specs->n = 1; + + enum ctables_summary_function function + = specs->is_scale ? CTSF_MEAN : CTSF_COUNT; + + *specs->specs = (struct ctables_summary_spec) { + .function = function, + .format = ctables_summary_default_format (function, specs->var), + }; + if (!specs->var) + specs->var = nest->vars[0]; + + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + } + else if (!nest->specs[CSV_TOTAL].n) + ctables_summary_spec_set_clone (&nest->specs[CSV_TOTAL], + &nest->specs[CSV_CELL]); + + if (t->ctables->smissing_listwise) + { + struct variable **listwise_vars = NULL; + size_t n = 0; + size_t allocated = 0; + + for (size_t j = nest->group_head; j < stack->n; j++) + { + const struct ctables_nest *other_nest = &stack->nests[j]; + if (other_nest->group_head != nest->group_head) + break; + + if (nest != other_nest && other_nest->scale_idx < other_nest->n) + { + if (n >= allocated) + listwise_vars = x2nrealloc (listwise_vars, &allocated, + sizeof *listwise_vars); + listwise_vars[n++] = other_nest->vars[other_nest->scale_idx]; + } + } + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + if (sv > 0) + listwise_vars = xmemdup (listwise_vars, + n * sizeof *listwise_vars); + nest->specs[sv].listwise_vars = listwise_vars; + nest->specs[sv].n_listwise_vars = n; + } + } + } + + struct ctables_summary_spec_set *merged = &t->summary_specs; + struct merge_item *items = xnmalloc (N_CSVS * stack->n, sizeof *items); + size_t n_left = 0; + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + if (nest->n) + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + items[n_left++] = (struct merge_item) { .set = &nest->specs[sv] }; + } + + while (n_left > 0) + { + struct merge_item min = items[0]; + for (size_t j = 1; j < n_left; j++) + if (merge_item_compare_3way (&items[j], &min) < 0) + min = items[j]; + + if (merged->n >= merged->allocated) + merged->specs = x2nrealloc (merged->specs, &merged->allocated, + sizeof *merged->specs); + merged->specs[merged->n++] = min.set->specs[min.ofs]; + + for (size_t j = 0; j < n_left; ) + { + if (merge_item_compare_3way (&items[j], &min) == 0) + { + struct merge_item *item = &items[j]; + item->set->specs[item->ofs].axis_idx = merged->n - 1; + if (++item->ofs >= item->set->n) + { + items[j] = items[--n_left]; + continue; + } + } + j++; + } + } + free (items); + +#if 0 + for (size_t j = 0; j < merged->n; j++) + printf ("%s\n", ctables_summary_function_name (merged->specs[j].function)); + + for (size_t j = 0; j < stack->n; j++) + { + const struct ctables_nest *nest = &stack->nests[j]; + for (enum ctables_summary_variant sv = 0; sv < N_CSVS; sv++) + { + const struct ctables_summary_spec_set *specs = &nest->specs[sv]; + for (size_t k = 0; k < specs->n; k++) + printf ("(%s, %zu) ", ctables_summary_function_name (specs->specs[k].function), + specs->specs[k].axis_idx); + printf ("\n"); + } + } +#endif + + size_t allocated_sum_vars = 0; + enumerate_sum_vars (t->axes[t->summary_axis], + &t->sum_vars, &t->n_sum_vars, &allocated_sum_vars); + + return (ctables_check_label_position (t, PIVOT_AXIS_ROW) + && ctables_check_label_position (t, PIVOT_AXIS_COLUMN)); +} + +static void +ctables_insert_clabels_values (struct ctables_table *t, const struct ccase *c, + enum pivot_axis_type a) +{ + struct ctables_stack *stack = &t->stacks[a]; + for (size_t i = 0; i < stack->n; i++) + { + const struct ctables_nest *nest = &stack->nests[i]; + const struct variable *var = nest->vars[nest->n - 1]; + const union value *value = case_data (c, var); + + if (var_is_numeric (var) && value->f == SYSMIS) + continue; + + if (ctables_categories_match (t->categories [var_get_dict_index (var)], + value, var)) + ctables_value_insert (t, value, var_get_width (var)); + } +} + +static int +compare_clabels_values_3way (const void *a_, const void *b_, const void *width_) +{ + const struct ctables_value *const *ap = a_; + const struct ctables_value *const *bp = b_; + const struct ctables_value *a = *ap; + const struct ctables_value *b = *bp; + const int *width = width_; + return value_compare_3way (&a->value, &b->value, *width); +} + +static void +ctables_sort_clabels_values (struct ctables_table *t) +{ + const struct variable *v0 = t->clabels_example; + int width = var_get_width (v0); + + struct ctables_categories *c0 = t->categories[var_get_dict_index (v0)]; + if (c0->show_empty) + { + const struct val_labs *val_labs = var_get_value_labels (v0); + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (ctables_categories_match (c0, &vl->value, v0)) + ctables_value_insert (t, &vl->value, width); + } + + size_t n = hmap_count (&t->clabels_values_map); + t->clabels_values = xnmalloc (n, sizeof *t->clabels_values); + + struct ctables_value *clv; + size_t i = 0; + HMAP_FOR_EACH (clv, struct ctables_value, node, &t->clabels_values_map) + t->clabels_values[i++] = clv; + t->n_clabels_values = n; + assert (i == n); + + sort (t->clabels_values, n, sizeof *t->clabels_values, + compare_clabels_values_3way, &width); + + for (size_t i = 0; i < n; i++) + t->clabels_values[i]->leaf = i; +} + +static void +ctables_add_category_occurrences (const struct variable *var, + struct hmap *occurrences, + const struct ctables_categories *cats) +{ + const struct val_labs *val_labs = var_get_value_labels (var); + + for (size_t i = 0; i < cats->n_cats; i++) + { + const struct ctables_category *c = &cats->cats[i]; + switch (c->type) + { + case CCT_NUMBER: + ctables_add_occurrence (var, &(const union value) { .f = c->number }, + occurrences); + break; + + case CCT_STRING: + { + int width = var_get_width (var); + union value value; + value_init (&value, width); + value_copy_buf_rpad (&value, width, + CHAR_CAST (uint8_t *, c->string.string), + c->string.length, ' '); + ctables_add_occurrence (var, &value, occurrences); + value_destroy (&value, width); + } + break; + + case CCT_NRANGE: + assert (var_is_numeric (var)); + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (vl->value.f >= c->nrange[0] && vl->value.f <= c->nrange[1]) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_SRANGE: + assert (var_is_alpha (var)); + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (in_string_range (&vl->value, var, c->srange)) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_MISSING: + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (var_is_value_missing (var, &vl->value)) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_OTHERNM: + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_POSTCOMPUTE: + break; + + case CCT_SUBTOTAL: + case CCT_TOTAL: + break; + + case CCT_VALUE: + case CCT_LABEL: + case CCT_FUNCTION: + for (const struct val_lab *vl = val_labs_first (val_labs); vl; + vl = val_labs_next (val_labs, vl)) + if (c->include_missing || !var_is_value_missing (var, &vl->value)) + ctables_add_occurrence (var, &vl->value, occurrences); + break; + + case CCT_EXCLUDED_MISSING: + break; + } + } +} + +static void +ctables_section_recurse_add_empty_categories ( + struct ctables_section *s, + const struct ctables_category *cats[PIVOT_N_AXES][10], struct ccase *c, + enum pivot_axis_type a, size_t a_idx) +{ + if (a >= PIVOT_N_AXES) + ctables_cell_insert__ (s, c, cats); + else if (!s->nests[a] || a_idx >= s->nests[a]->n) + ctables_section_recurse_add_empty_categories (s, cats, c, a + 1, 0); + else + { + const struct variable *var = s->nests[a]->vars[a_idx]; + const struct ctables_categories *categories = s->table->categories[ + var_get_dict_index (var)]; + int width = var_get_width (var); + const struct hmap *occurrences = &s->occurrences[a][a_idx]; + const struct ctables_occurrence *o; + HMAP_FOR_EACH (o, struct ctables_occurrence, node, occurrences) + { + union value *value = case_data_rw (c, var); + value_destroy (value, width); + value_clone (value, &o->value, width); + cats[a][a_idx] = ctables_categories_match (categories, value, var); + assert (cats[a][a_idx] != NULL); + ctables_section_recurse_add_empty_categories (s, cats, c, a, a_idx + 1); + } + + for (size_t i = 0; i < categories->n_cats; i++) + { + const struct ctables_category *cat = &categories->cats[i]; + if (cat->type == CCT_POSTCOMPUTE) + { + cats[a][a_idx] = cat; + ctables_section_recurse_add_empty_categories (s, cats, c, a, a_idx + 1); + } + } + } +} + +static void +ctables_section_add_empty_categories (struct ctables_section *s) +{ + bool show_empty = false; + for (size_t a = 0; a < PIVOT_N_AXES; a++) + if (s->nests[a]) + for (size_t k = 0; k < s->nests[a]->n; k++) + if (k != s->nests[a]->scale_idx) + { + const struct variable *var = s->nests[a]->vars[k]; + const struct ctables_categories *cats = s->table->categories[ + var_get_dict_index (var)]; + if (cats->show_empty) + { + show_empty = true; + ctables_add_category_occurrences (var, &s->occurrences[a][k], cats); + } + } + if (!show_empty) + return; + + const struct ctables_category *cats[PIVOT_N_AXES][10]; /* XXX */ + struct ccase *c = case_create (dict_get_proto (s->table->ctables->dict)); + ctables_section_recurse_add_empty_categories (s, cats, c, 0, 0); + case_unref (c); +} + +static void +ctables_section_clear (struct ctables_section *s) +{ + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + { + const struct variable *var = nest->vars[i]; + int width = var_get_width (var); + struct ctables_occurrence *o, *next; + struct hmap *map = &s->occurrences[a][i]; + HMAP_FOR_EACH_SAFE (o, next, struct ctables_occurrence, node, map) + { + value_destroy (&o->value, width); + hmap_delete (map, &o->node); + free (o); + } + hmap_shrink (map); + } + } + + struct ctables_cell *cell, *next_cell; + HMAP_FOR_EACH_SAFE (cell, next_cell, struct ctables_cell, node, &s->cells) + { + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + const struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + if (i != nest->scale_idx) + value_destroy (&cell->axes[a].cvs[i].value, + var_get_width (nest->vars[i])); + free (cell->axes[a].cvs); + } + + const struct ctables_nest *ss = s->nests[s->table->summary_axis]; + const struct ctables_summary_spec_set *specs = &ss->specs[cell->sv]; + for (size_t i = 0; i < specs->n; i++) + ctables_summary_uninit (&cell->summaries[i], &specs->specs[i]); + free (cell->summaries); + + hmap_delete (&s->cells, &cell->node); + free (cell); + } + hmap_shrink (&s->cells); + + for (enum ctables_domain_type dt = 0; dt < N_CTDTS; dt++) + { + struct ctables_domain *domain, *next_domain; + HMAP_FOR_EACH_SAFE (domain, next_domain, struct ctables_domain, node, + &s->domains[dt]) + { + free (domain->sums); + hmap_delete (&s->domains[dt], &domain->node); + free (domain); + } + hmap_shrink (&s->domains[dt]); + } +} + +static void +ctables_section_uninit (struct ctables_section *s) +{ + ctables_section_clear (s); + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + struct ctables_nest *nest = s->nests[a]; + for (size_t i = 0; i < nest->n; i++) + hmap_destroy (&s->occurrences[a][i]); + free (s->occurrences[a]); + } + + hmap_destroy (&s->cells); + for (size_t i = 0; i < N_CTDTS; i++) + hmap_destroy (&s->domains[i]); +} + +static void +ctables_table_clear (struct ctables_table *t) +{ + for (size_t i = 0; i < t->n_sections; i++) + ctables_section_clear (&t->sections[i]); + + if (t->clabels_example) + { + int width = var_get_width (t->clabels_example); + struct ctables_value *value, *next_value; + HMAP_FOR_EACH_SAFE (value, next_value, struct ctables_value, node, + &t->clabels_values_map) + { + value_destroy (&value->value, width); + hmap_delete (&t->clabels_values_map, &value->node); + free (value); + } + hmap_shrink (&t->clabels_values_map); + + free (t->clabels_values); + t->clabels_values = NULL; + t->n_clabels_values = 0; + } +} + +static bool +ctables_execute (struct dataset *ds, struct casereader *input, + struct ctables *ct) +{ + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + t->sections = xnmalloc (MAX (1, t->stacks[PIVOT_AXIS_ROW].n) * + MAX (1, t->stacks[PIVOT_AXIS_COLUMN].n) * + MAX (1, t->stacks[PIVOT_AXIS_LAYER].n), + sizeof *t->sections); + size_t ix[PIVOT_N_AXES]; + ctables_table_add_section (t, 0, ix); + } + + struct dictionary *dict = dataset_dict (ds); + struct casegrouper *grouper + = (dict_get_split_type (dict) == SPLIT_SEPARATE + ? casegrouper_create_splits (input, dict) + : casegrouper_create_vars (input, NULL, 0)); + struct casereader *group; + while (casegrouper_get_next_group (grouper, &group)) + { + /* Output SPLIT FILE variables. */ + struct ccase *c = casereader_peek (group, 0); + if (c != NULL) + { + output_split_file_values (ds, c); + case_unref (c); + } + + bool warn_on_invalid = true; + for (c = casereader_read (group); c; + case_unref (c), c = casereader_read (group)) + { + double d_weight = dict_get_case_weight (dict, c, &warn_on_invalid); + double e_weight = (ct->e_weight + ? var_force_valid_weight (ct->e_weight, + case_num (c, ct->e_weight), + &warn_on_invalid) + : d_weight); + + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + + for (size_t j = 0; j < t->n_sections; j++) + ctables_cell_insert (&t->sections[j], c, d_weight, e_weight); + + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (t->label_axis[a] != a) + ctables_insert_clabels_values (t, c, a); + } + } + casereader_destroy (group); + + for (size_t i = 0; i < ct->n_tables; i++) + { + struct ctables_table *t = ct->tables[i]; + + if (t->clabels_example) + ctables_sort_clabels_values (t); + + for (size_t j = 0; j < t->n_sections; j++) + ctables_section_add_empty_categories (&t->sections[j]); + + ctables_table_output (ct, t); + ctables_table_clear (t); + } + } + return casegrouper_destroy (grouper); +} + +/* Postcomputes. */ + +typedef struct ctables_pcexpr *parse_recursively_func (struct lexer *, + struct dictionary *); + +static void +ctables_pcexpr_destroy (struct ctables_pcexpr *e) +{ + if (e) + { + switch (e->op) + { + case CTPO_CAT_STRING: + ss_dealloc (&e->string); + break; + + case CTPO_CAT_SRANGE: + for (size_t i = 0; i < 2; i++) + ss_dealloc (&e->srange[i]); + break; + + case CTPO_ADD: + case CTPO_SUB: + case CTPO_MUL: + case CTPO_DIV: + case CTPO_POW: + case CTPO_NEG: + for (size_t i = 0; i < 2; i++) + ctables_pcexpr_destroy (e->subs[i]); + break; + + case CTPO_CONSTANT: + case CTPO_CAT_NUMBER: + case CTPO_CAT_NRANGE: + case CTPO_CAT_MISSING: + case CTPO_CAT_OTHERNM: + case CTPO_CAT_SUBTOTAL: + case CTPO_CAT_TOTAL: + break; + } + + msg_location_destroy (e->location); + free (e); + } +} + +static struct ctables_pcexpr * +ctables_pcexpr_allocate_binary (enum ctables_postcompute_op op, + struct ctables_pcexpr *sub0, + struct ctables_pcexpr *sub1) +{ + struct ctables_pcexpr *e = xmalloc (sizeof *e); + *e = (struct ctables_pcexpr) { + .op = op, + .subs = { sub0, sub1 }, + .location = msg_location_merged (sub0->location, sub1->location), + }; + return e; +} + +/* How to parse an operator. */ +struct operator + { + enum token_type token; + enum ctables_postcompute_op op; + }; + +static const struct operator * +ctables_pcexpr_match_operator (struct lexer *lexer, + const struct operator ops[], size_t n_ops) +{ + for (const struct operator *op = ops; op < ops + n_ops; op++) + if (lex_token (lexer) == op->token) + { + if (op->token != T_NEG_NUM) + lex_get (lexer); + + return op; + } + + return NULL; +} + +static struct ctables_pcexpr * +ctables_pcexpr_parse_binary_operators__ ( + struct lexer *lexer, struct dictionary *dict, + const struct operator ops[], size_t n_ops, + parse_recursively_func *parse_next_level, + const char *chain_warning, struct ctables_pcexpr *lhs) +{ + for (int op_count = 0; ; op_count++) + { + const struct operator *op + = ctables_pcexpr_match_operator (lexer, ops, n_ops); + if (!op) + { + if (op_count > 1 && chain_warning) + msg_at (SW, lhs->location, "%s", chain_warning); + + return lhs; + } + + struct ctables_pcexpr *rhs = parse_next_level (lexer, dict); + if (!rhs) + { + ctables_pcexpr_destroy (lhs); + return NULL; + } + + lhs = ctables_pcexpr_allocate_binary (op->op, lhs, rhs); + } +} + +static struct ctables_pcexpr * +ctables_pcexpr_parse_binary_operators ( + struct lexer *lexer, struct dictionary *dict, + const struct operator ops[], size_t n_ops, + parse_recursively_func *parse_next_level, const char *chain_warning) +{ + struct ctables_pcexpr *lhs = parse_next_level (lexer, dict); + if (!lhs) + return NULL; + + return ctables_pcexpr_parse_binary_operators__ (lexer, dict, ops, n_ops, + parse_next_level, + chain_warning, lhs); +} + +static struct ctables_pcexpr *ctables_pcexpr_parse_add (struct lexer *, + struct dictionary *); + +static struct ctables_pcexpr +ctpo_cat_nrange (double low, double high) +{ + return (struct ctables_pcexpr) { + .op = CTPO_CAT_NRANGE, + .nrange = { low, high }, + }; +} + +static struct ctables_pcexpr +ctpo_cat_srange (struct substring low, struct substring high) +{ + return (struct ctables_pcexpr) { + .op = CTPO_CAT_SRANGE, + .srange = { low, high }, + }; +} + +static struct ctables_pcexpr * +ctables_pcexpr_parse_primary (struct lexer *lexer, struct dictionary *dict) +{ + int start_ofs = lex_ofs (lexer); + struct ctables_pcexpr e; + if (lex_is_number (lexer)) + { + e = (struct ctables_pcexpr) { .op = CTPO_CONSTANT, + .number = lex_number (lexer) }; + lex_get (lexer); + } + else if (lex_match_id (lexer, "MISSING")) + e = (struct ctables_pcexpr) { .op = CTPO_CAT_MISSING }; + else if (lex_match_id (lexer, "OTHERNM")) + e = (struct ctables_pcexpr) { .op = CTPO_CAT_OTHERNM }; + else if (lex_match_id (lexer, "TOTAL")) + e = (struct ctables_pcexpr) { .op = CTPO_CAT_TOTAL }; + else if (lex_match_id (lexer, "SUBTOTAL")) + { + size_t subtotal_index = 0; + if (lex_match (lexer, T_LBRACK)) + { + if (!lex_force_int_range (lexer, "SUBTOTAL", 1, LONG_MAX)) + return NULL; + subtotal_index = lex_integer (lexer); + lex_get (lexer); + if (!lex_force_match (lexer, T_RBRACK)) + return NULL; + } + e = (struct ctables_pcexpr) { .op = CTPO_CAT_SUBTOTAL, + .subtotal_index = subtotal_index }; + } + else if (lex_match (lexer, T_LBRACK)) + { + if (lex_match_id (lexer, "LO")) + { + if (!lex_force_match_id (lexer, "THRU")) + return false; + + if (lex_is_string (lexer)) + { + struct substring low = { .string = NULL }; + struct substring high = parse_substring (lexer, dict); + e = ctpo_cat_srange (low, high); + } + else + { + if (!lex_force_num (lexer)) + return false; + e = ctpo_cat_nrange (-DBL_MAX, lex_number (lexer)); + lex_get (lexer); + } + } + else if (lex_is_number (lexer)) + { + double number = lex_number (lexer); + lex_get (lexer); + if (lex_match_id (lexer, "THRU")) + { + if (lex_match_id (lexer, "HI")) + e = ctpo_cat_nrange (number, DBL_MAX); + else + { + if (!lex_force_num (lexer)) + return false; + e = ctpo_cat_nrange (number, lex_number (lexer)); + lex_get (lexer); + } + } + else + e = (struct ctables_pcexpr) { .op = CTPO_CAT_NUMBER, + .number = number }; + } + else if (lex_is_string (lexer)) + { + struct substring s = parse_substring (lexer, dict); + + if (lex_match_id (lexer, "THRU")) + { + struct substring high; + + if (lex_match_id (lexer, "HI")) + high = (struct substring) { .string = NULL }; + else + { + if (!lex_force_string (lexer)) + { + ss_dealloc (&s); + return false; + } + high = parse_substring (lexer, dict); + } + + e = ctpo_cat_srange (s, high); + } + else + e = (struct ctables_pcexpr) { .op = CTPO_CAT_STRING, .string = s }; + } + else + { + lex_error (lexer, NULL); + return NULL; + } + + if (!lex_force_match (lexer, T_RBRACK)) + { + if (e.op == CTPO_CAT_STRING) + ss_dealloc (&e.string); + else if (e.op == CTPO_CAT_SRANGE) + { + ss_dealloc (&e.srange[0]); + ss_dealloc (&e.srange[1]); + } + return NULL; + } + } + else if (lex_match (lexer, T_LPAREN)) + { + struct ctables_pcexpr *ep = ctables_pcexpr_parse_add (lexer, dict); + if (!ep) + return NULL; + if (!lex_force_match (lexer, T_RPAREN)) + { + ctables_pcexpr_destroy (ep); + return NULL; + } + return ep; + } + else + { + lex_error (lexer, NULL); + return NULL; + } + + e.location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1); + return xmemdup (&e, sizeof e); +} + +static struct ctables_pcexpr * +ctables_pcexpr_allocate_neg (struct ctables_pcexpr *sub, + struct lexer *lexer, int start_ofs) +{ + struct ctables_pcexpr *e = xmalloc (sizeof *e); + *e = (struct ctables_pcexpr) { + .op = CTPO_NEG, + .subs = { sub }, + .location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer) - 1), + }; + return e; +} + +static struct ctables_pcexpr * +ctables_pcexpr_parse_exp (struct lexer *lexer, struct dictionary *dict) +{ + static const struct operator op = { T_EXP, CTPO_POW }; + + const char *chain_warning = + _("The exponentiation operator (`**') is left-associative: " + "`a**b**c' equals `(a**b)**c', not `a**(b**c)'. " + "To disable this warning, insert parentheses."); + + if (lex_token (lexer) != T_NEG_NUM || lex_next_token (lexer, 1) != T_EXP) + return ctables_pcexpr_parse_binary_operators (lexer, dict, &op, 1, + ctables_pcexpr_parse_primary, + chain_warning); + + /* Special case for situations like "-5**6", which must be parsed as + -(5**6). */ + + int start_ofs = lex_ofs (lexer); + struct ctables_pcexpr *lhs = xmalloc (sizeof *lhs); + *lhs = (struct ctables_pcexpr) { + .op = CTPO_CONSTANT, + .number = -lex_tokval (lexer), + .location = lex_ofs_location (lexer, start_ofs, lex_ofs (lexer)), + }; + lex_get (lexer); + + struct ctables_pcexpr *node = ctables_pcexpr_parse_binary_operators__ ( + lexer, dict, &op, 1, + ctables_pcexpr_parse_primary, chain_warning, lhs); + if (!node) + return NULL; + + return ctables_pcexpr_allocate_neg (node, lexer, start_ofs); +} + +/* Parses the unary minus level. */ +static struct ctables_pcexpr * +ctables_pcexpr_parse_neg (struct lexer *lexer, struct dictionary *dict) +{ + int start_ofs = lex_ofs (lexer); + if (!lex_match (lexer, T_DASH)) + return ctables_pcexpr_parse_exp (lexer, dict); + + struct ctables_pcexpr *inner = ctables_pcexpr_parse_neg (lexer, dict); + if (!inner) + return NULL; + + return ctables_pcexpr_allocate_neg (inner, lexer, start_ofs); +} + +/* Parses the multiplication and division level. */ +static struct ctables_pcexpr * +ctables_pcexpr_parse_mul (struct lexer *lexer, struct dictionary *dict) +{ + static const struct operator ops[] = + { + { T_ASTERISK, CTPO_MUL }, + { T_SLASH, CTPO_DIV }, + }; + + return ctables_pcexpr_parse_binary_operators (lexer, dict, ops, + sizeof ops / sizeof *ops, + ctables_pcexpr_parse_neg, NULL); +} + +/* Parses the addition and subtraction level. */ +static struct ctables_pcexpr * +ctables_pcexpr_parse_add (struct lexer *lexer, struct dictionary *dict) +{ + static const struct operator ops[] = + { + { T_PLUS, CTPO_ADD }, + { T_DASH, CTPO_SUB }, + { T_NEG_NUM, CTPO_ADD }, + }; + + return ctables_pcexpr_parse_binary_operators (lexer, dict, + ops, sizeof ops / sizeof *ops, + ctables_pcexpr_parse_mul, NULL); +} + +static struct ctables_postcompute * +ctables_find_postcompute (struct ctables *ct, const char *name) +{ + struct ctables_postcompute *pc; + HMAP_FOR_EACH_WITH_HASH (pc, struct ctables_postcompute, hmap_node, + utf8_hash_case_string (name, 0), &ct->postcomputes) + if (!utf8_strcasecmp (pc->name, name)) + return pc; + return NULL; +} + +static bool +ctables_parse_pcompute (struct lexer *lexer, struct dictionary *dict, + struct ctables *ct) +{ + int pcompute_start = lex_ofs (lexer) - 1; + + if (!lex_match (lexer, T_AND)) + { + lex_error_expecting (lexer, "&"); + return false; + } + if (!lex_force_id (lexer)) + return false; + + char *name = ss_xstrdup (lex_tokss (lexer)); + + lex_get (lexer); + if (!lex_force_match (lexer, T_EQUALS) + || !lex_force_match_id (lexer, "EXPR") + || !lex_force_match (lexer, T_LPAREN)) + { + free (name); + return false; + } + + int expr_start = lex_ofs (lexer); + struct ctables_pcexpr *expr = ctables_pcexpr_parse_add (lexer, dict); + int expr_end = lex_ofs (lexer) - 1; + if (!expr || !lex_force_match (lexer, T_RPAREN)) + { + ctables_pcexpr_destroy (expr); + free (name); + return false; + } + int pcompute_end = lex_ofs (lexer) - 1; + + struct msg_location *location = lex_ofs_location (lexer, pcompute_start, + pcompute_end); + + struct ctables_postcompute *pc = ctables_find_postcompute (ct, name); + if (pc) + { + msg_at (SW, location, _("New definition of &%s will override the " + "previous definition."), + pc->name); + msg_at (SN, pc->location, _("This is the previous definition.")); + + ctables_pcexpr_destroy (pc->expr); + msg_location_destroy (pc->location); + free (name); + } + else + { + pc = xmalloc (sizeof *pc); + *pc = (struct ctables_postcompute) { .name = name }; + hmap_insert (&ct->postcomputes, &pc->hmap_node, + utf8_hash_case_string (pc->name, 0)); + } + pc->expr = expr; + pc->location = location; + if (!pc->label) + pc->label = lex_ofs_representation (lexer, expr_start, expr_end); + return true; +} + +static bool +ctables_parse_pproperties_format (struct lexer *lexer, + struct ctables_summary_spec_set *sss) +{ + *sss = (struct ctables_summary_spec_set) { .n = 0 }; + + while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH + && !(lex_token (lexer) == T_ID + && (lex_id_match (ss_cstr ("LABEL"), lex_tokss (lexer)) + || lex_id_match (ss_cstr ("HIDESOURCECATS"), + lex_tokss (lexer))))) + { + /* Parse function. */ + enum ctables_summary_function function; + if (!parse_ctables_summary_function (lexer, &function)) + goto error; + + /* Parse percentile. */ + double percentile = 0; + if (function == CTSF_PTILE) + { + if (!lex_force_num_range_closed (lexer, "PTILE", 0, 100)) + goto error; + percentile = lex_number (lexer); + lex_get (lexer); + } + + /* Parse format. */ + struct fmt_spec format; + bool is_ctables_format; + if (!parse_ctables_format_specifier (lexer, &format, &is_ctables_format)) + goto error; + + if (sss->n >= sss->allocated) + sss->specs = x2nrealloc (sss->specs, &sss->allocated, + sizeof *sss->specs); + sss->specs[sss->n++] = (struct ctables_summary_spec) { + .function = function, + .percentile = percentile, + .format = format, + .is_ctables_format = is_ctables_format, + }; + } + return true; + +error: + ctables_summary_spec_set_uninit (sss); + return false; +} + +static bool +ctables_parse_pproperties (struct lexer *lexer, struct ctables *ct) +{ + struct ctables_postcompute **pcs = NULL; + size_t n_pcs = 0; + size_t allocated_pcs = 0; + + while (lex_match (lexer, T_AND)) + { + if (!lex_force_id (lexer)) + goto error; + struct ctables_postcompute *pc + = ctables_find_postcompute (ct, lex_tokcstr (lexer)); + if (!pc) + { + msg (SE, _("Unknown computed category &%s."), lex_tokcstr (lexer)); + goto error; + } + lex_get (lexer); + + if (n_pcs >= allocated_pcs) + pcs = x2nrealloc (pcs, &allocated_pcs, sizeof *pcs); + pcs[n_pcs++] = pc; + } + + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "LABEL")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + goto error; + + for (size_t i = 0; i < n_pcs; i++) + { + free (pcs[i]->label); + pcs[i]->label = ss_xstrdup (lex_tokss (lexer)); + } + + lex_get (lexer); + } + else if (lex_match_id (lexer, "FORMAT")) + { + lex_match (lexer, T_EQUALS); + + struct ctables_summary_spec_set sss; + if (!ctables_parse_pproperties_format (lexer, &sss)) + goto error; + + for (size_t i = 0; i < n_pcs; i++) + { + if (pcs[i]->specs) + ctables_summary_spec_set_uninit (pcs[i]->specs); + else + pcs[i]->specs = xmalloc (sizeof *pcs[i]->specs); + ctables_summary_spec_set_clone (pcs[i]->specs, &sss); + } + ctables_summary_spec_set_uninit (&sss); + } + else if (lex_match_id (lexer, "HIDESOURCECATS")) + { + lex_match (lexer, T_EQUALS); + bool hide_source_cats; + if (!parse_bool (lexer, &hide_source_cats)) + goto error; + for (size_t i = 0; i < n_pcs; i++) + pcs[i]->hide_source_cats = hide_source_cats; + } + else + { + lex_error_expecting (lexer, "LABEL", "FORMAT", "HIDESOURCECATS"); + goto error; + } + } + free (pcs); + return true; + +error: + free (pcs); + return false; +} + +static void +put_strftime (struct string *out, time_t now, const char *format) +{ + const struct tm *tm = localtime (&now); + char value[128]; + strftime (value, sizeof value, format, tm); + ds_put_cstr (out, value); +} + +static bool +skip_prefix (struct substring *s, struct substring prefix) +{ + if (ss_starts_with (*s, prefix)) + { + ss_advance (s, prefix.length); + return true; + } + else + return false; +} + +static void +put_table_expression (struct string *out, struct lexer *lexer, + struct dictionary *dict, int expr_start, int expr_end) +{ + size_t nest = 0; + for (int ofs = expr_start; ofs < expr_end; ofs++) + { + const struct token *t = lex_ofs_token (lexer, ofs); + if (t->type == T_LBRACK) + nest++; + else if (t->type == T_RBRACK && nest > 0) + nest--; + else if (nest > 0) + { + /* Nothing. */ + } + else if (t->type == T_ID) + { + const struct variable *var + = dict_lookup_var (dict, t->string.string); + const char *label = var ? var_get_label (var) : NULL; + ds_put_cstr (out, label ? label : t->string.string); + } + else + { + if (ofs != expr_start && t->type != T_RPAREN && ds_last (out) != ' ') + ds_put_byte (out, ' '); + + char *repr = lex_ofs_representation (lexer, ofs, ofs); + ds_put_cstr (out, repr); + free (repr); + + if (ofs + 1 != expr_end && t->type != T_LPAREN) + ds_put_byte (out, ' '); + } + } +} + +static void +put_title_text (struct string *out, struct substring in, time_t now, + struct lexer *lexer, struct dictionary *dict, + int expr_start, int expr_end) +{ + for (;;) + { + size_t chunk = ss_find_byte (in, ')'); + ds_put_substring (out, ss_head (in, chunk)); + ss_advance (&in, chunk); + if (ss_is_empty (in)) + return; + + if (skip_prefix (&in, ss_cstr (")DATE"))) + put_strftime (out, now, "%x"); + else if (skip_prefix (&in, ss_cstr (")TIME"))) + put_strftime (out, now, "%X"); + else if (skip_prefix (&in, ss_cstr (")TABLE"))) + put_table_expression (out, lexer, dict, expr_start, expr_end); + else + { + ds_put_byte (out, ')'); + ss_advance (&in, 1); + } + } +} + +int +cmd_ctables (struct lexer *lexer, struct dataset *ds) +{ + struct casereader *input = NULL; + + struct measure_guesser *mg = measure_guesser_create (ds); + if (mg) + { + input = proc_open (ds); + measure_guesser_run (mg, input); + measure_guesser_destroy (mg); + } + + size_t n_vars = dict_get_n_vars (dataset_dict (ds)); + enum ctables_vlabel *vlabels = xnmalloc (n_vars, sizeof *vlabels); + enum settings_value_show tvars = settings_get_show_variables (); + for (size_t i = 0; i < n_vars; i++) + vlabels[i] = (enum ctables_vlabel) tvars; + + struct pivot_table_look *look = pivot_table_look_unshare ( + pivot_table_look_ref (pivot_table_look_get_default ())); + look->omit_empty = false; + + struct ctables *ct = xmalloc (sizeof *ct); + *ct = (struct ctables) { + .dict = dataset_dict (ds), + .look = look, + .ctables_formats = FMT_SETTINGS_INIT, + .vlabels = vlabels, + .postcomputes = HMAP_INITIALIZER (ct->postcomputes), + }; + + time_t now = time (NULL); + + struct ctf + { + enum fmt_type type; + const char *dot_string; + const char *comma_string; + }; + static const struct ctf ctfs[4] = { + { CTEF_NEGPAREN, "(,,,)", "(...)" }, + { CTEF_NEQUAL, "-,N=,,", "-.N=.." }, + { CTEF_PAREN, "-,(,),", "-.(.)." }, + { CTEF_PCTPAREN, "-,(,%),", "-.(.%)." }, + }; + bool is_dot = settings_get_fmt_settings ()->decimal == '.'; + for (size_t i = 0; i < 4; i++) + { + const char *s = is_dot ? ctfs[i].dot_string : ctfs[i].comma_string; + fmt_settings_set_cc (&ct->ctables_formats, ctfs[i].type, + fmt_number_style_from_string (s)); + } + + if (!lex_force_match (lexer, T_SLASH)) + goto error; + + while (!lex_match_id (lexer, "TABLE")) + { + if (lex_match_id (lexer, "FORMAT")) + { + double widths[2] = { SYSMIS, SYSMIS }; + double units_per_inch = 72.0; + + while (lex_token (lexer) != T_SLASH) + { + if (lex_match_id (lexer, "MINCOLWIDTH")) + { + if (!parse_col_width (lexer, "MINCOLWIDTH", &widths[0])) + goto error; + } + else if (lex_match_id (lexer, "MAXCOLWIDTH")) + { + if (!parse_col_width (lexer, "MAXCOLWIDTH", &widths[1])) + goto error; + } + else if (lex_match_id (lexer, "UNITS")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "POINTS")) + units_per_inch = 72.0; + else if (lex_match_id (lexer, "INCHES")) + units_per_inch = 1.0; + else if (lex_match_id (lexer, "CM")) + units_per_inch = 2.54; + else + { + lex_error_expecting (lexer, "POINTS", "INCHES", "CM"); + goto error; + } + } + else if (lex_match_id (lexer, "EMPTY")) + { + free (ct->zero); + ct->zero = NULL; + + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ZERO")) + { + /* Nothing to do. */ + } + else if (lex_match_id (lexer, "BLANK")) + ct->zero = xstrdup (""); + else if (lex_force_string (lexer)) + { + ct->zero = ss_xstrdup (lex_tokss (lexer)); + lex_get (lexer); + } + else + goto error; + } + else if (lex_match_id (lexer, "MISSING")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_string (lexer)) + goto error; + + free (ct->missing); + ct->missing = (strcmp (lex_tokcstr (lexer), ".") + ? ss_xstrdup (lex_tokss (lexer)) + : NULL); + lex_get (lexer); + } + else + { + lex_error_expecting (lexer, "MINCOLWIDTH", "MAXCOLWIDTH", + "UNITS", "EMPTY", "MISSING"); + goto error; + } + } + + if (widths[0] != SYSMIS && widths[1] != SYSMIS + && widths[0] > widths[1]) + { + msg (SE, _("MINCOLWIDTH must not be greater than MAXCOLWIDTH.")); + goto error; + } + + for (size_t i = 0; i < 2; i++) + if (widths[i] != SYSMIS) + { + int *wr = ct->look->width_ranges[TABLE_HORZ]; + wr[i] = widths[i] / units_per_inch * 96.0; + if (wr[0] > wr[1]) + wr[!i] = wr[i]; + } + } + else if (lex_match_id (lexer, "VLABELS")) + { + if (!lex_force_match_id (lexer, "VARIABLES")) + goto error; + lex_match (lexer, T_EQUALS); + + struct variable **vars; + size_t n_vars; + if (!parse_variables (lexer, dataset_dict (ds), &vars, &n_vars, + PV_NO_SCRATCH)) + goto error; + + if (!lex_force_match_id (lexer, "DISPLAY")) + { + free (vars); + goto error; + } + lex_match (lexer, T_EQUALS); + + enum ctables_vlabel vlabel; + if (lex_match_id (lexer, "DEFAULT")) + vlabel = (enum ctables_vlabel) settings_get_show_variables (); + else if (lex_match_id (lexer, "NAME")) + vlabel = CTVL_NAME; + else if (lex_match_id (lexer, "LABEL")) + vlabel = CTVL_LABEL; + else if (lex_match_id (lexer, "BOTH")) + vlabel = CTVL_BOTH; + else if (lex_match_id (lexer, "NONE")) + vlabel = CTVL_NONE; + else + { + lex_error_expecting (lexer, "DEFAULT", "NAME", "LABEL", + "BOTH", "NONE"); + free (vars); + goto error; + } + + for (size_t i = 0; i < n_vars; i++) + ct->vlabels[var_get_dict_index (vars[i])] = vlabel; + free (vars); + } + else if (lex_match_id (lexer, "MRSETS")) + { + if (!lex_force_match_id (lexer, "COUNTDUPLICATES")) + goto error; + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &ct->mrsets_count_duplicates)) + goto error; + } + else if (lex_match_id (lexer, "SMISSING")) + { + if (lex_match_id (lexer, "VARIABLE")) + ct->smissing_listwise = false; + else if (lex_match_id (lexer, "LISTWISE")) + ct->smissing_listwise = true; + else + { + lex_error_expecting (lexer, "VARIABLE", "LISTWISE"); + goto error; + } + } + else if (lex_match_id (lexer, "PCOMPUTE")) + { + if (!ctables_parse_pcompute (lexer, dataset_dict (ds), ct)) + goto error; + } + else if (lex_match_id (lexer, "PPROPERTIES")) + { + if (!ctables_parse_pproperties (lexer, ct)) + goto error; + } + else if (lex_match_id (lexer, "WEIGHT")) + { + if (!lex_force_match_id (lexer, "VARIABLE")) + goto error; + lex_match (lexer, T_EQUALS); + ct->e_weight = parse_variable (lexer, dataset_dict (ds)); + if (!ct->e_weight) + goto error; + } + else if (lex_match_id (lexer, "HIDESMALLCOUNTS")) + { + if (lex_match_id (lexer, "COUNT")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_int_range (lexer, "HIDESMALLCOUNTS COUNT", + 2, INT_MAX)) + goto error; + ct->hide_threshold = lex_integer (lexer); + lex_get (lexer); + } + else if (ct->hide_threshold == 0) + ct->hide_threshold = 5; + } + else + { + lex_error_expecting (lexer, "FORMAT", "VLABELS", "MRSETS", + "SMISSING", "PCOMPUTE", "PPROPERTIES", + "WEIGHT", "HIDESMALLCOUNTS", "TABLE"); + goto error; + } + + if (!lex_force_match (lexer, T_SLASH)) + goto error; + } + + size_t allocated_tables = 0; + do + { + if (ct->n_tables >= allocated_tables) + ct->tables = x2nrealloc (ct->tables, &allocated_tables, + sizeof *ct->tables); + + struct ctables_category *cat = xmalloc (sizeof *cat); + *cat = (struct ctables_category) { + .type = CCT_VALUE, + .include_missing = false, + .sort_ascending = true, + }; + + struct ctables_categories *c = xmalloc (sizeof *c); + size_t n_vars = dict_get_n_vars (dataset_dict (ds)); + *c = (struct ctables_categories) { + .n_refs = n_vars, + .cats = cat, + .n_cats = 1, + .show_empty = true, + }; + + struct ctables_categories **categories = xnmalloc (n_vars, + sizeof *categories); + for (size_t i = 0; i < n_vars; i++) + categories[i] = c; + + struct ctables_table *t = xmalloc (sizeof *t); + *t = (struct ctables_table) { + .ctables = ct, + .slabels_axis = PIVOT_AXIS_COLUMN, + .slabels_visible = true, + .clabels_values_map = HMAP_INITIALIZER (t->clabels_values_map), + .label_axis = { + [PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW, + [PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN, + [PIVOT_AXIS_LAYER] = PIVOT_AXIS_LAYER, + }, + .clabels_from_axis = PIVOT_AXIS_LAYER, + .categories = categories, + .n_categories = n_vars, + .cilevel = 95, + }; + ct->tables[ct->n_tables++] = t; + + lex_match (lexer, T_EQUALS); + int expr_start = lex_ofs (lexer); + if (!ctables_axis_parse (lexer, dataset_dict (ds), ct, t, PIVOT_AXIS_ROW)) + goto error; + if (lex_match (lexer, T_BY)) + { + if (!ctables_axis_parse (lexer, dataset_dict (ds), + ct, t, PIVOT_AXIS_COLUMN)) + goto error; + + if (lex_match (lexer, T_BY)) + { + if (!ctables_axis_parse (lexer, dataset_dict (ds), + ct, t, PIVOT_AXIS_LAYER)) + goto error; + } + } + int expr_end = lex_ofs (lexer); + + if (!t->axes[PIVOT_AXIS_ROW] && !t->axes[PIVOT_AXIS_COLUMN] + && !t->axes[PIVOT_AXIS_LAYER]) + { + lex_error (lexer, _("At least one variable must be specified.")); + goto error; + } + + const struct ctables_axis *scales[PIVOT_N_AXES]; + size_t n_scales = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + scales[a] = find_scale (t->axes[a]); + if (scales[a]) + n_scales++; + } + if (n_scales > 1) + { + msg (SE, _("Scale variables may appear only on one axis.")); + if (scales[PIVOT_AXIS_ROW]) + msg_at (SN, scales[PIVOT_AXIS_ROW]->loc, + _("This scale variable appears on the rows axis.")); + if (scales[PIVOT_AXIS_COLUMN]) + msg_at (SN, scales[PIVOT_AXIS_COLUMN]->loc, + _("This scale variable appears on the columns axis.")); + if (scales[PIVOT_AXIS_LAYER]) + msg_at (SN, scales[PIVOT_AXIS_LAYER]->loc, + _("This scale variable appears on the layer axis.")); + goto error; + } + + const struct ctables_axis *summaries[PIVOT_N_AXES]; + size_t n_summaries = 0; + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + { + summaries[a] = (scales[a] + ? scales[a] + : find_categorical_summary_spec (t->axes[a])); + if (summaries[a]) + n_summaries++; + } + if (n_summaries > 1) + { + msg (SE, _("Summaries may appear only on one axis.")); + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (summaries[a]) + { + msg_at (SN, summaries[a]->loc, + a == PIVOT_AXIS_ROW + ? _("This variable on the rows axis has a summary.") + : a == PIVOT_AXIS_COLUMN + ? _("This variable on the columns axis has a summary.") + : _("This variable on the layers axis has a summary.")); + if (scales[a]) + msg_at (SN, summaries[a]->loc, + _("This is a scale variable, so it always has a " + "summary even if the syntax does not explicitly " + "specify one.")); + } + goto error; + } + for (enum pivot_axis_type a = 0; a < PIVOT_N_AXES; a++) + if (n_summaries ? summaries[a] : t->axes[a]) + { + t->summary_axis = a; + break; + } + + if (lex_token (lexer) == T_ENDCMD) + { + if (!ctables_prepare_table (t)) + goto error; + break; + } + if (!lex_force_match (lexer, T_SLASH)) + goto error; + + while (!lex_match_id (lexer, "TABLE") && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "SLABELS")) + { + while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD) + { + if (lex_match_id (lexer, "POSITION")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "COLUMN")) + t->slabels_axis = PIVOT_AXIS_COLUMN; + else if (lex_match_id (lexer, "ROW")) + t->slabels_axis = PIVOT_AXIS_ROW; + else if (lex_match_id (lexer, "LAYER")) + t->slabels_axis = PIVOT_AXIS_LAYER; + else + { + lex_error_expecting (lexer, "COLUMN", "ROW", "LAYER"); + goto error; + } + } + else if (lex_match_id (lexer, "VISIBLE")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->slabels_visible)) + goto error; + } + else + { + lex_error_expecting (lexer, "POSITION", "VISIBLE"); + goto error; + } + } + } + else if (lex_match_id (lexer, "CLABELS")) + { + if (lex_match_id (lexer, "AUTO")) + { + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_ROW; + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_COLUMN; + } + else if (lex_match_id (lexer, "ROWLABELS")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "OPPOSITE")) + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_COLUMN; + else if (lex_match_id (lexer, "LAYER")) + t->label_axis[PIVOT_AXIS_ROW] = PIVOT_AXIS_LAYER; + else + { + lex_error_expecting (lexer, "OPPOSITE", "LAYER"); + goto error; + } + } + else if (lex_match_id (lexer, "COLLABELS")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "OPPOSITE")) + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_ROW; + else if (lex_match_id (lexer, "LAYER")) + t->label_axis[PIVOT_AXIS_COLUMN] = PIVOT_AXIS_LAYER; + else + { + lex_error_expecting (lexer, "OPPOSITE", "LAYER"); + goto error; + } + } + else + { + lex_error_expecting (lexer, "AUTO", "ROWLABELS", + "COLLABELS"); + goto error; + } + } + else if (lex_match_id (lexer, "CRITERIA")) + { + if (!lex_force_match_id (lexer, "CILEVEL")) + goto error; + lex_match (lexer, T_EQUALS); + + if (!lex_force_num_range_halfopen (lexer, "CILEVEL", 0, 100)) + goto error; + t->cilevel = lex_number (lexer); + lex_get (lexer); + } + else if (lex_match_id (lexer, "CATEGORIES")) + { + if (!ctables_table_parse_categories (lexer, dataset_dict (ds), + ct, t)) + goto error; + } + else if (lex_match_id (lexer, "TITLES")) + { + do + { + char **textp; + if (lex_match_id (lexer, "CAPTION")) + textp = &t->caption; + else if (lex_match_id (lexer, "CORNER")) + textp = &t->corner; + else if (lex_match_id (lexer, "TITLE")) + textp = &t->title; + else + { + lex_error_expecting (lexer, "CAPTION", "CORNER", "TITLE"); + goto error; + } + lex_match (lexer, T_EQUALS); + + struct string s = DS_EMPTY_INITIALIZER; + while (lex_is_string (lexer)) + { + if (!ds_is_empty (&s)) + ds_put_byte (&s, ' '); + put_title_text (&s, lex_tokss (lexer), now, + lexer, dataset_dict (ds), + expr_start, expr_end); + lex_get (lexer); + } + free (*textp); + *textp = ds_steal_cstr (&s); + } + while (lex_token (lexer) != T_SLASH + && lex_token (lexer) != T_ENDCMD); + } + else if (lex_match_id (lexer, "SIGTEST")) + { + if (!t->chisq) + { + t->chisq = xmalloc (sizeof *t->chisq); + *t->chisq = (struct ctables_chisq) { + .alpha = .05, + .include_mrsets = true, + .all_visible = true, + }; + } + + do + { + if (lex_match_id (lexer, "TYPE")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_match_id (lexer, "CHISQUARE")) + goto error; + } + else if (lex_match_id (lexer, "ALPHA")) + { + lex_match (lexer, T_EQUALS); + if (!lex_force_num_range_halfopen (lexer, "ALPHA", 0, 1)) + goto error; + t->chisq->alpha = lex_number (lexer); + lex_get (lexer); + } + else if (lex_match_id (lexer, "INCLUDEMRSETS")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->chisq->include_mrsets)) + goto error; + } + else if (lex_match_id (lexer, "CATEGORIES")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ALLVISIBLE")) + t->chisq->all_visible = true; + else if (lex_match_id (lexer, "SUBTOTALS")) + t->chisq->all_visible = false; + else + { + lex_error_expecting (lexer, + "ALLVISIBLE", "SUBTOTALS"); + goto error; + } + } + else + { + lex_error_expecting (lexer, "TYPE", "ALPHA", + "INCLUDEMRSETS", "CATEGORIES"); + goto error; + } + } + while (lex_token (lexer) != T_SLASH + && lex_token (lexer) != T_ENDCMD); + } + else if (lex_match_id (lexer, "COMPARETEST")) + { + if (!t->pairwise) + { + t->pairwise = xmalloc (sizeof *t->pairwise); + *t->pairwise = (struct ctables_pairwise) { + .type = PROP, + .alpha = { .05, .05 }, + .adjust = BONFERRONI, + .include_mrsets = true, + .meansvariance_allcats = true, + .all_visible = true, + .merge = false, + .apa_style = true, + .show_sig = false, + }; + } + + do + { + if (lex_match_id (lexer, "TYPE")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "PROP")) + t->pairwise->type = PROP; + else if (lex_match_id (lexer, "MEAN")) + t->pairwise->type = MEAN; + else + { + lex_error_expecting (lexer, "PROP", "MEAN"); + goto error; + } + } + else if (lex_match_id (lexer, "ALPHA")) + { + lex_match (lexer, T_EQUALS); + + if (!lex_force_num_range_open (lexer, "ALPHA", 0, 1)) + goto error; + double a0 = lex_number (lexer); + lex_get (lexer); + + lex_match (lexer, T_COMMA); + if (lex_is_number (lexer)) + { + if (!lex_force_num_range_open (lexer, "ALPHA", 0, 1)) + goto error; + double a1 = lex_number (lexer); + lex_get (lexer); + + t->pairwise->alpha[0] = MIN (a0, a1); + t->pairwise->alpha[1] = MAX (a0, a1); + } + else + t->pairwise->alpha[0] = t->pairwise->alpha[1] = a0; + } + else if (lex_match_id (lexer, "ADJUST")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "BONFERRONI")) + t->pairwise->adjust = BONFERRONI; + else if (lex_match_id (lexer, "BH")) + t->pairwise->adjust = BH; + else if (lex_match_id (lexer, "NONE")) + t->pairwise->adjust = 0; + else + { + lex_error_expecting (lexer, "BONFERRONI", "BH", + "NONE"); + goto error; + } + } + else if (lex_match_id (lexer, "INCLUDEMRSETS")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->pairwise->include_mrsets)) + goto error; + } + else if (lex_match_id (lexer, "MEANSVARIANCE")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ALLCATS")) + t->pairwise->meansvariance_allcats = true; + else if (lex_match_id (lexer, "TESTEDCATS")) + t->pairwise->meansvariance_allcats = false; + else + { + lex_error_expecting (lexer, "ALLCATS", "TESTEDCATS"); + goto error; + } + } + else if (lex_match_id (lexer, "CATEGORIES")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "ALLVISIBLE")) + t->pairwise->all_visible = true; + else if (lex_match_id (lexer, "SUBTOTALS")) + t->pairwise->all_visible = false; + else + { + lex_error_expecting (lexer, "ALLVISIBLE", + "SUBTOTALS"); + goto error; + } + } + else if (lex_match_id (lexer, "MERGE")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->pairwise->merge)) + goto error; + } + else if (lex_match_id (lexer, "STYLE")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "APA")) + t->pairwise->apa_style = true; + else if (lex_match_id (lexer, "SIMPLE")) + t->pairwise->apa_style = false; + else + { + lex_error_expecting (lexer, "APA", "SIMPLE"); + goto error; + } + } + else if (lex_match_id (lexer, "SHOWSIG")) + { + lex_match (lexer, T_EQUALS); + if (!parse_bool (lexer, &t->pairwise->show_sig)) + goto error; + } + else + { + lex_error_expecting (lexer, "TYPE", "ALPHA", "ADJUST", + "INCLUDEMRSETS", "MEANSVARIANCE", + "CATEGORIES", "MERGE", "STYLE", + "SHOWSIG"); + goto error; + } + } + while (lex_token (lexer) != T_SLASH + && lex_token (lexer) != T_ENDCMD); + } + else + { + lex_error_expecting (lexer, "TABLE", "SLABELS", "CLABELS", + "CRITERIA", "CATEGORIES", "TITLES", + "SIGTEST", "COMPARETEST"); + goto error; + } + + if (!lex_match (lexer, T_SLASH)) + break; + } + + if (t->label_axis[PIVOT_AXIS_ROW] != PIVOT_AXIS_ROW + && t->label_axis[PIVOT_AXIS_COLUMN] != PIVOT_AXIS_COLUMN) + { + msg (SE, _("ROWLABELS and COLLABELS may not both be specified.")); + goto error; + } + + if (!ctables_prepare_table (t)) + goto error; + } + while (lex_token (lexer) != T_ENDCMD); + + if (!input) + input = proc_open (ds); + bool ok = ctables_execute (ds, input, ct); + ok = proc_commit (ds) && ok; + + ctables_destroy (ct); + return ok ? CMD_SUCCESS : CMD_FAILURE; + +error: + if (input) + proc_commit (ds); + ctables_destroy (ct); + return CMD_FAILURE; +} + diff --git a/src/language/stats/ctables.inc b/src/language/stats/ctables.inc new file mode 100644 index 0000000000..e039cfd3ce --- /dev/null +++ b/src/language/stats/ctables.inc @@ -0,0 +1,129 @@ +/* -*- c -*- */ + +/* Summary functions for all variables. */ +S(CTSF_COUNT, "COUNT", N_("Count"), CTF_COUNT, CTFA_ALL) +S(CTSF_ECOUNT, "ECOUNT", N_("Adjusted Count"), CTF_COUNT, CTFA_ALL) +S(CTSF_ROWPCT_COUNT, "ROWPCT.COUNT", N_("Row %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_COLPCT_COUNT, "COLPCT.COUNT", N_("Column %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_TABLEPCT_COUNT, "TABLEPCT.COUNT", N_("Table %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_SUBTABLEPCT_COUNT, "SUBTABLEPCT.COUNT", N_("Subtable %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERPCT_COUNT, "LAYERPCT.COUNT", N_("Layer %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERROWPCT_COUNT, "LAYERROWPCT.COUNT", N_("Layer Row %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERCOLPCT_COUNT, "LAYERCOLPCT.COUNT", N_("Layer Column %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ROWPCT_VALIDN, "ROWPCT.VALIDN", N_("Row Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_COLPCT_VALIDN, "COLPCT.VALIDN", N_("Column Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_TABLEPCT_VALIDN, "TABLEPCT.VALIDN", N_("Table Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_SUBTABLEPCT_VALIDN, "SUBTABLEPCT.VALIDN", N_("Subtable Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERPCT_VALIDN, "LAYERPCT.VALIDN", N_("Layer Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERROWPCT_VALIDN, "LAYERROWPCT.VALIDN", N_("Layer Row Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERCOLPCT_VALIDN, "LAYERCOLPCT.VALIDN", N_("Layer Column Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ROWPCT_TOTALN, "ROWPCT.TOTALN", N_("Row Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_COLPCT_TOTALN, "COLPCT.TOTALN", N_("Column Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_TABLEPCT_TOTALN, "TABLEPCT.TOTALN", N_("Table Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_SUBTABLEPCT_TOTALN, "SUBTABLEPCT.TOTALN", N_("Subtable Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERPCT_TOTALN, "LAYERPCT.TOTALN", N_("Layer Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERROWPCT_TOTALN, "LAYERROWPCT.TOTALN", N_("Layer Row Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_LAYERCOLPCT_TOTALN, "LAYERCOLPCT.TOTALN", N_("Layer Column Total N %"), CTF_PERCENT, CTFA_ALL) + +/* All variables (unweighted.) */ +S(CTSF_UCOUNT, "UCOUNT", N_("Unweighted Count"), CTF_COUNT, CTFA_ALL) +S(CTSF_UROWPCT_COUNT, "UROWPCT.COUNT", N_("Unweighted Row %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UCOLPCT_COUNT, "UCOLPCT.COUNT", N_("Unweighted Column %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UTABLEPCT_COUNT, "UTABLEPCT.COUNT", N_("Unweighted Table %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_USUBTABLEPCT_COUNT, "USUBTABLEPCT.COUNT", N_("Unweighted Subtable %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERPCT_COUNT, "ULAYERPCT.COUNT", N_("Unweighted Layer %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERROWPCT_COUNT, "ULAYERROWPCT.COUNT", N_("Unweighted Layer Row %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERCOLPCT_COUNT, "ULAYERCOLPCT.COUNT", N_("Unweighted Layer Column %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UROWPCT_VALIDN, "UROWPCT.VALIDN", N_("Unweighted Row Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UCOLPCT_VALIDN, "UCOLPCT.VALIDN", N_("Unweighted Column Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UTABLEPCT_VALIDN, "UTABLEPCT.VALIDN", N_("Unweighted Table Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_USUBTABLEPCT_VALIDN, "USUBTABLEPCT.VALIDN", N_("Unweighted Subtable Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERPCT_VALIDN, "ULAYERPCT.VALIDN", N_("Unweighted Layer Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERROWPCT_VALIDN, "ULAYERROWPCT.VALIDN", N_("Unweighted Layer Row Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERCOLPCT_VALIDN, "ULAYERCOLPCT.VALIDN", N_("Unweighted Layer Column Valid N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UROWPCT_TOTALN, "UROWPCT.TOTALN", N_("Unweighted Row Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UCOLPCT_TOTALN, "UCOLPCT.TOTALN", N_("Unweighted Column Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_UTABLEPCT_TOTALN, "UTABLEPCT.TOTALN", N_("Unweighted Table Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_USUBTABLEPCT_TOTALN, "USUBTABLEPCT.TOTALN", N_("Unweighted Subtable Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERPCT_TOTALN, "ULAYERPCT.TOTALN", N_("Unweighted Layer Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERROWPCT_TOTALN, "ULAYERROWPCT.TOTALN", N_("Unweighted Layer Row Total N %"), CTF_PERCENT, CTFA_ALL) +S(CTSF_ULAYERCOLPCT_TOTALN, "ULAYERCOLPCT.TOTALN", N_("Unweighted Layer Column Total N %"), CTF_PERCENT, CTFA_ALL) + +/* Scale variables, totals, and subtotals. */ +S(CTSF_MAXIMUM, "MAXIMUM", N_("Maximum"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_MEAN, "MEAN", N_("Mean"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_MEDIAN, "MEDIAN", N_("Median"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_MINIMUM, "MINIMUM", N_("Minimum"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_MISSING, "MISSING", N_("Missing"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_MODE, "MODE", N_("Mode"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_PTILE, "PTILE", N_("Percentile"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_RANGE, "RANGE", N_("Range"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_SEMEAN, "SEMEAN", N_("Std Error of Mean"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_STDDEV, "STDDEV", N_("Std Deviation"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_SUM, "SUM", N_("Sum"), CTF_GENERAL, CTFA_SCALE) +S(CSTF_TOTALN, "TOTALN", N_("Total N"), CTF_COUNT, CTFA_SCALE) +S(CTSF_ETOTALN, "ETOTALN", N_("Adjusted Total N"), CTF_COUNT, CTFA_SCALE) +S(CTSF_VALIDN, "VALIDN", N_("Valid N"), CTF_COUNT, CTFA_SCALE) +S(CTSF_EVALIDN, "EVALIDN", N_("Adjusted Valid N"), CTF_COUNT, CTFA_SCALE) +S(CTSF_VARIANCE, "VARIANCE", N_("Variance"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_ROWPCT_SUM, "ROWPCT.SUM", N_("Row Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_COLPCT_SUM, "COLPCT.SUM", N_("Column Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_TABLEPCT_SUM, "TABLEPCT.SUM", N_("Table Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_SUBTABLEPCT_SUM, "SUBTABLEPCT.SUM", N_("Subtable Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_LAYERPCT_SUM, "LAYERPCT.SUM", N_("Layer Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_LAYERROWPCT_SUM, "LAYERROWPCT.SUM", N_("Layer Row Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_LAYERCOLPCT_SUM, "LAYERCOLPCT.SUM", N_("Layer Column Sum %"), CTF_PERCENT, CTFA_SCALE) + +/* Scale variables, totals, and subtotals (unweighted). */ +S(CTSF_UMEAN, "UMEAN", N_("Unweighted Mean"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_UMEDIAN, "UMEDIAN", N_("Unweighted Median"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_UMISSING, "UMISSING", N_("Unweighted Missing"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_UMODE, "UMODE", N_("Unweighted Mode"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_UPTILE, "UPTILE", N_("Unweighted Percentile"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_USEMEAN, "USEMEAN", N_("Unweighted Std Error of Mean"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_USTDDEV, "USTDDEV", N_("Unweighted Std Deviation"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_USUM, "USUM", N_("Unweighted Sum"), CTF_GENERAL, CTFA_SCALE) +S(CSTF_UTOTALN, "UTOTALN", N_("Unweighted Total N"), CTF_COUNT, CTFA_SCALE) +S(CTSF_UVALIDN, "UVALIDN", N_("Unweighted Valid N"), CTF_COUNT, CTFA_SCALE) +S(CTSF_UVARIANCE, "UVARIANCE", N_("Unweighted Variance"), CTF_GENERAL, CTFA_SCALE) +S(CTSF_UROWPCT_SUM, "UROWPCT.SUM", N_("Unweighted Row Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_UCOLPCT_SUM, "UCOLPCT.SUM", N_("Unweighted Column Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_UTABLEPCT_SUM, "UTABLEPCT.SUM", N_("Unweighted Table Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_USUBTABLEPCT_SUM, "USUBTABLEPCT.SUM", N_("Unweighted Subtable Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_ULAYERPCT_SUM, "ULAYERPCT.SUM", N_("Unweighted Layer Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_ULAYERROWPCT_SUM, "ULAYERROWPCT.SUM", N_("Unweighted Layer Row Sum %"), CTF_PERCENT, CTFA_SCALE) +S(CTSF_ULAYERCOLPCT_SUM, "ULAYERCOLPCT.SUM", N_("Unweighted Layer Column Sum %"), CTF_PERCENT, CTFA_SCALE) + +/* Debugging and troubleshooting. */ +S(CTSF_ROW_ID, "ROW.ID", N_("Row ID"), CTF_COUNT, CTFA_ALL) +S(CTSF_COL_ID, "COL.ID", N_("Column ID"), CTF_COUNT, CTFA_ALL) +S(CTSF_TABLE_ID, "TABLE.ID", N_("Table ID"), CTF_COUNT, CTFA_ALL) +S(CTSF_SUBTABLE_ID, "SUBTABLE.ID", N_("Subtable ID"), CTF_COUNT, CTFA_ALL) +S(CTSF_LAYER_ID, "LAYER.ID", N_("Layer ID"), CTF_COUNT, CTFA_ALL) +S(CTSF_LAYERROW_ID, "LAYERROW.ID", N_("Layer Row ID"), CTF_COUNT, CTFA_ALL) +S(CTSF_LAYERCOL_ID, "LAYERCOL.ID", N_("Layer Column ID"), CTF_COUNT, CTFA_ALL) + +#if 0 /* Multiple response sets not yet implemented. */ +S(CTSF_RESPONSES, "RESPONSES", N_("Responses"), CTF_COUNT, CTFA_MRSETS) +S(CTSF_ROWPCT_RESPONSES, "ROWPCT.RESPONSES", N_("Row Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_COLPCT_RESPONSES, "COLPCT.RESPONSES", N_("Column Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_TABLEPCT_RESPONSES, "TABLEPCT.RESPONSES", N_("Table Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_SUBTABLEPCT_RESPONSES, "SUBTABLEPCT.RESPONSES", N_("Subtable Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERPCT_RESPONSES, "LAYERPCT.RESPONSES", N_("Layer Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERROWPCT_RESPONSES, "LAYERROWPCT.RESPONSES", N_("Layer Row Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERCOLPCT_RESPONSES, "LAYERCOLPCT.RESPONSES", N_("Layer Column Responses %"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_ROWPCT_RESPONSES_COUNT, "ROWPCT.RESPONSES.COUNT", N_("Row Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_COLPCT_RESPONSES_COUNT, "COLPCT.RESPONSES.COUNT", N_("Column Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_TABLEPCT_RESPONSES_COUNT, "TABLEPCT.RESPONSES.COUNT", N_("Table Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_SUBTABLEPCT_RESPONSES_COUNT, "SUBTABLEPCT.RESPONSES.COUNT", N_("Subtable Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERPCT_RESPONSES_COUNT, "LAYERPCT.RESPONSES.COUNT", N_("Layer Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERROWPCT_RESPONSES_COUNT, "LAYERROWPCT.RESPONSES.COUNT", N_("Layer Row Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERCOLPCT_RESPONSES_COUNT, "LAYERCOLPCT.RESPONSES.COUNT", N_("Layer Column Responses % (Base: Count)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_ROWPCT_COUNT_RESPONSES, "ROWPCT.COUNT.RESPONSES", N_("Row Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_COLPCT_COUNT_RESPONSES, "COLPCT.COUNT.RESPONSES", N_("Column Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_TABLEPCT_COUNT_RESPONSES, "TABLEPCT.COUNT.RESPONSES", N_("Table Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_SUBTABLEPCT_COUNT_RESPONSES, "SUBTABLEPCT.COUNT.RESPONSES", N_("Subtable Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERPCT_COUNT_RESPONSES, "LAYERPCT.COUNT.RESPONSES", N_("Layer Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERROWPCT_COUNT_RESPONSES, "LAYERROWPCT.COUNT.RESPONSES", N_("Layer Row Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +S(CTSF_LAYERCOLPCT_COUNT_RESPONSES, "LAYERCOLPCT.RESPONSES.COUNT", N_("Layer Column Count % (Base: Responses)"), CTF_PERCENT, CTFA_MRSETS) +#endif diff --git a/src/libpspp/message.c b/src/libpspp/message.c index 83c7320168..38726d9f5b 100644 --- a/src/libpspp/message.c +++ b/src/libpspp/message.c @@ -174,6 +174,16 @@ msg_location_merge (struct msg_location **dstp, const struct msg_location *src) dst->end = src->end; } +struct msg_location * +msg_location_merged (const struct msg_location *a, + const struct msg_location *b) +{ + struct msg_location *new = msg_location_dup (a); + if (b) + msg_location_merge (&new, b); + return new; +} + struct msg_location * msg_location_dup (const struct msg_location *src) { diff --git a/src/libpspp/message.h b/src/libpspp/message.h index 813febe82a..11e5b9d98e 100644 --- a/src/libpspp/message.h +++ b/src/libpspp/message.h @@ -118,6 +118,8 @@ struct msg_location *msg_location_dup (const struct msg_location *); void msg_location_remove_columns (struct msg_location *); void msg_location_merge (struct msg_location **, const struct msg_location *); +struct msg_location *msg_location_merged (const struct msg_location *, + const struct msg_location *); bool msg_location_is_empty (const struct msg_location *); void msg_location_format (const struct msg_location *, struct string *); diff --git a/src/output/pivot-table.c b/src/output/pivot-table.c index 009e829613..f8f917d9dd 100644 --- a/src/output/pivot-table.c +++ b/src/output/pivot-table.c @@ -2777,7 +2777,7 @@ pivot_value_new_text (const char *text) } /* Same as pivot_value_new_text() but its argument is a printf()-like format - string. */ + string. The format string should generally be enclosed in N_(). */ struct pivot_value * PRINTF_FORMAT (1, 2) pivot_value_new_text_format (const char *format, ...) { diff --git a/src/output/pivot-table.h b/src/output/pivot-table.h index 88edb62031..e374596184 100644 --- a/src/output/pivot-table.h +++ b/src/output/pivot-table.h @@ -177,9 +177,8 @@ enum pivot_axis_type { PIVOT_AXIS_LAYER, PIVOT_AXIS_ROW, - PIVOT_AXIS_COLUMN, - - PIVOT_N_AXES + PIVOT_AXIS_COLUMN +#define PIVOT_N_AXES 3 }; const char *pivot_axis_type_to_string (enum pivot_axis_type); diff --git a/tests/automake.mk b/tests/automake.mk index f9bea8fa51..095ed03579 100644 --- a/tests/automake.mk +++ b/tests/automake.mk @@ -398,6 +398,7 @@ TESTSUITE_AT = \ tests/language/stats/autorecode.at \ tests/language/stats/correlations.at \ tests/language/stats/crosstabs.at \ + tests/language/stats/ctables.at \ tests/language/stats/descriptives.at \ tests/language/stats/examine.at \ tests/language/stats/graph.at \ @@ -487,8 +488,16 @@ $(srcdir)/tests/testsuite.at: tests/testsuite.in tests/automake.mk EXTRA_DIST += tests/testsuite.at +# Generate a TableLook that prints all layers of pivot tables. +check_DATA = tests/all-layers.stt +tests/all-layers.stt: utilities/pspp-output + $(AM_V_GEN)$< get-table-look - $@.tmp + $(AM_V_at)if grep 'printAllLayers="false"' $@.tmp >/dev/null; then :; else \ + echo >&2 "$<: expected printAllLayers=\"false\""; exit 1; fi + $(AM_v_at)sed 's/printAllLayers="false"/printAllLayers="true"/' < $@.tmp > $@ + CHECK_LOCAL += tests_check -tests_check: tests/atconfig tests/atlocal $(TESTSUITE) $(check_PROGRAMS) +tests_check: tests/atconfig tests/atlocal $(TESTSUITE) $(check_PROGRAMS) $(check_DATA) XTERM_LOCALE='' $(SHELL) '$(TESTSUITE)' -C tests AUTOTEST_PATH=$(AUTOTEST_PATH) RUNNER='$(RUNNER)' $(TESTSUITEFLAGS) CLEAN_LOCAL += tests_clean diff --git a/tests/language/stats/ctables.at b/tests/language/stats/ctables.at new file mode 100644 index 0000000000..0b6e769af1 --- /dev/null +++ b/tests/language/stats/ctables.at @@ -0,0 +1,2788 @@ +AT_BANNER([CTABLES]) + +dnl Features not yet tested: +dnl - Preprocessing to distinguish categorical from scale. +dnl - Testing details of missing value handling in summaries. +dnl - Test WEIGHT and adjustment weights. +dnl - Summary functions: +dnl * Separate summary functions for totals and subtotals. +dnl * )CILEVEL in summary label specification +dnl - CATEGORIES: +dnl * Date values +dnl * THRU (numeric ranges) +dnl * OTHERNM +dnl - Date/time variables and values +dnl - Test PCOMPUTE: +dnl * PCOMPUTE for more than one kind of summary (e.g. [COUNT, ROWPCT]). +dnl * MISSING, OTHERNM +dnl * multi-dimensional (multiple CCT_POSTCOMPUTE in one cell) +dnl * dates +dnl - PPROPERTIES: +dnl * )LABEL[N]. +dnl - Summary functions: +dnl * U-prefix for unweighted summaries. +dnl * areaPCT.SUM and UareaPCT.SUM functions. +dnl - SPLIT FILE with SEPARATE splits +dnl - Definition of columns/rows when labels are rotated from one axis to another. +dnl +dnl Not for v1: +dnl - Multiple response sets +dnl - MRSETS subcommand. +dnl - CATEGORIES: Special case for explicit category specifications and multiple dichotomy sets. +dnl - SIGTEST +dnl - COMPARETEST +dnl - Summary functions: +dnl * .LCL and .UCL suffixes. +dnl * .SE suffixes. +dnl - CATEGORIES: +dnl * Data-dependent sorting. + +AT_SETUP([CTABLES parsing]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES + /FORMAT MINCOLWIDTH=10 MAXCOLWIDTH=20 UNITS=POINTS EMPTY=ZERO MISSING="x" + /FORMAT MINCOLWIDTH=DEFAULT MAXCOLWIDTH=DEFAULT UNITS=INCHES EMPTY=BLANK MISSING="." + /FORMAT UNITS=CM EMPTY="(-)" + /VLABELS VARIABLES=qn1 DISPLAY=DEFAULT + /VLABELS VARIABLES=qn17 DISPLAY=NAME + /VLABELS VARIABLES=qns3a DISPLAY=LABEL + /VLABELS VARIABLES=qnd1 DISPLAY=BOTH + /VLABELS VARIABLES=qn20 DISPLAY=NONE + /MRSETS COUNTDUPLICATES=NO + /MRSETS COUNTDUPLICATES=YES + /SMISSING VARIABLE + /SMISSING LISTWISE + /WEIGHT VARIABLE=qns3a + /HIDESMALLCOUNTS + /HIDESMALLCOUNTS COUNT=10 + /TABLE qnsa1 + /SLABELS POSITION=COLUMN VISIBLE=YES + /SLABELS VISIBLE=NO POSITION=ROW + /SLABELS POSITION=LAYER + /CLABELS AUTO + /CLABELS ROWLABELS=OPPOSITE + /CRITERIA CILEVEL=50 + /CATEGORIES VARIABLES=qn1 qn17 + ORDER=A KEY=VALUE MISSING=INCLUDE TOTAL=YES LABEL="xyzzy" + POSITION=BEFORE EMPTY=INCLUDE. +CTABLES /TABLE qnsa1 /CLABELS ROWLABELS=LAYER. +CTABLES /TABLE qnsa1 /CLABELS COLLABELS=OPPOSITE. +CTABLES /TABLE qnsa1 /CLABELS COLLABELS=LAYER. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +Count +╭───────────────────┬────┬────╮ +│ │ RDD│CELL│ +├───────────────────┼────┼────┤ +│Sa1. SAMPLE SOURCE:│5392│1607│ +╰───────────────────┴────┴────╯ + + Custom Tables +RDD +╭───────────────────┬─────╮ +│ │Count│ +├───────────────────┼─────┤ +│Sa1. SAMPLE SOURCE:│ 5392│ +╰───────────────────┴─────╯ + + Custom Tables +╭────────────────────────┬─────╮ +│ │Count│ +├────────────────────────┼─────┤ +│Sa1. SAMPLE SOURCE: RDD │ 5392│ +│ CELL│ 1607│ +╰────────────────────────┴─────╯ + + Custom Tables +╭────────────────────────┬─────╮ +│ │Count│ +├────────────────────────┼─────┤ +│Sa1. SAMPLE SOURCE: RDD │ 5392│ +│ CELL│ 1607│ +╰────────────────────────┴─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES parsing - negative]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES. +CTABLES /FORMAT MINCOLWIDTH='foo'. +CTABLES /TABLE qn1 [**]. +CTABLES /TABLE qn1 [NOTAFUNCTION]. +CTABLES /TABLE (qn1. +CTABLES /TABLE **. +CTABLES /TABLE NOTAVAR. +STRING string(A8). +CTABLES /TABLE string[S]. +CTABLES /TABLE qn1 [PTILE 101]. +CTABLES /TABLE qn1 [MEAN F0.1]. +CTABLES /TABLE qn1 [MEAN NEGPAREN1.2]. +CTABLES /TABLE qn1 [MEAN NEGPAREN3.4]. +CTABLES /TABLE qn1 [MEAN TOTALS]. +CTABLES /TABLE qn1 [MEAN TOTALS[STDDEV]%]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [SUBTOTAL=x]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [LO **]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [LO THRU x]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [1 THRU **]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 ['x' THRU **]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [&**]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [&x]. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 KEY=PTILE(qn1, 101). +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 KEY=MEAN(qn1. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 KEY=MEAN. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 MISSING=**. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 TOTAL=**. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 LABEL=**. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 POSITION=**. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 EMPTY=**. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 **. +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [1,2,3] **. +CTABLES /PCOMPUTE &k=EXPR(SUBTOTAL[0]). +CTABLES /PCOMPUTE &k=EXPR(SUBTOTAL[1**]). +CTABLES /PCOMPUTE &k=EXPR([LO **]). +CTABLES /PCOMPUTE &k=EXPR([LO THRU **]). +CTABLES /PCOMPUTE &k=EXPR([1 THRU **]). +CTABLES /PCOMPUTE &k=EXPR([1**]). +CTABLES /PCOMPUTE &k=EXPR((1x)). +CTABLES /PCOMPUTE **k. +CTABLES /PCOMPUTE &1. +CTABLES /PCOMPUTE &k**. +CTABLES /PCOMPUTE &k=**. +CTABLES /PCOMPUTE &k=EXPR**. +CTABLES /PCOMPUTE &k=EXPR(1x). +CTABLES /PCOMPUTE &k=EXPR(1) /PCOMPUTE &k=EXPR(2). +CTABLES /PCOMPUTE &k=EXPR(1) /PPROPERTIES &k FORMAT=NOTAFUNCTION. +CTABLES /PCOMPUTE &k=EXPR(1) /PPROPERTIES &k FORMAT=PTILE **. +CTABLES /PCOMPUTE &k=EXPR(1) /PPROPERTIES &k LABEL=**. +CTABLES /PCOMPUTE &k=EXPR(1) /PPROPERTIES &k HIDESOURCECATS=**. +CTABLES /PCOMPUTE &k=EXPR(1) /PPROPERTIES &k **. +CTABLES /FORMAT EMPTY=**. +CTABLES /FORMAT MISSING=**. +CTABLES /FORMAT **. +CTABLES /FORMAT MINCOLWIDTH=20 MAXCOLWIDTH=10/. +CTABLES /VLABELS **. +CTABLES /VLABELS VARIABLES=NOTAVAR. +CTABLES /VLABELS VARIABLES=qn1 **. +CTABLES /VLABELS VARIABLES=qn1 DISPLAY=**. +CTABLES /MRSETS **. +CTABLES /MRSETS COUNTDUPLICATES=**. +CTABLES /SMISSING **. +CTABLES /WEIGHT **. +CTABLES /WEIGHT VARIABLE=NOTAVAR. +CTABLES /HIDESMALLCOUNTS COUNT=1. +CTABLES /QUUX. +CTABLES /HIDESMALLCOUNTS COUNT=2. +CTABLES /TABLE qn1**. +CTABLES /TABLE qn1 /SLABELS POSITION=**. +CTABLES /TABLE qn1 /SLABELS VISIBLE=**. +CTABLES /TABLE qn1 /SLABELS **. +CTABLES /TABLE qn1 /CLABELS ROWLABELS=**. +CTABLES /TABLE qn1 /CLABELS COLLABELS=**. +CTABLES /TABLE qn1 /CLABELS **. +CTABLES /TABLE qn1 /CRITERIA **. +CTABLES /TABLE qn1 /CRITERIA CILEVEL=101. +CTABLES /TABLE qn1 /TITLES **. +CTABLES /TABLE qn1 /SIGTEST TYPE=**. +CTABLES /TABLE qn1 /SIGTEST ALPHA=**. +CTABLES /TABLE qn1 /SIGTEST INCLUDEMRSETS=**. +CTABLES /TABLE qn1 /SIGTEST CATEGORIES=**. +CTABLES /TABLE qn1 /SIGTEST **. +CTABLES /TABLE qn1 /COMPARETEST TYPE=**. +CTABLES /TABLE qn1 /COMPARETEST ALPHA=**. +CTABLES /TABLE qn1 /COMPARETEST ALPHA=0,5. +CTABLES /TABLE qn1 /COMPARETEST ADJUST=**. +CTABLES /TABLE qn1 /COMPARETEST INCLUDEMRSETS=**. +CTABLES /TABLE qn1 /COMPARETEST MEANSVARIANCE=**. +CTABLES /TABLE qn1 /COMPARETEST CATEGORIES=**. +CTABLES /TABLE qn1 /COMPARETEST MERGE=**. +CTABLES /TABLE qn1 /COMPARETEST STYLE=**. +CTABLES /TABLE qn1 /COMPARETEST SHOWSIG=**. +CTABLES /TABLE qn1 /COMPARETEST **. +CTABLES /TABLE qn1 / **. +CTABLES /TABLE qn1 /CLABELS ROWLABELS=OPPOSITE /CLABELS COLLABELS=OPPOSITE. +CTABLES /TABLE qn20 > qnd1. +CTABLES /TABLE qn1 [ROWPCT] > qnsa1. +NUMERIC datetime (DATETIME17.0). +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=datetime ['123']. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [1], +[[ctables.sps:2.8: error: CTABLES: Syntax error at end of command: expecting `/'. + +ctables.sps:3.29-3.33: error: CTABLES: Syntax error at `'foo'': Expected non- +negative number for MINCOLWIDTH. + +ctables.sps:4.21-4.22: error: CTABLES: Syntax error at `**': expecting +identifier. + +ctables.sps:5.21-5.32: error: CTABLES: Syntax error at `NOTAFUNCTION': Expecting +summary function name. + +ctables.sps:6.20: error: CTABLES: Syntax error at end of command: expecting `@:}@'. + +ctables.sps:7.16-7.17: error: CTABLES: Syntax error at `**': expecting +identifier. + +ctables.sps:8: error: CTABLES: NOTAVAR is not a variable name. + +ctables.sps:10.16-10.24: error: CTABLES: Cannot use string variable string as a +scale variable. + 10 | CTABLES /TABLE string[S]. + | ^~~~~~~~~ + +ctables.sps:11.27-11.29: error: CTABLES: Syntax error at `101': Expected number +between 0 and 100 for PTILE. + +ctables.sps:12: error: CTABLES: Output format F0.1 specifies width 0, but F +requires a width between 1 and 40. + +ctables.sps:13.26-13.36: error: CTABLES: Syntax error at `NEGPAREN1.2': Output +format NEGPAREN requires width 2 or greater. + +ctables.sps:14.26-14.36: error: CTABLES: Syntax error at `NEGPAREN3.4': Output +format NEGPAREN requires width greater than decimals. + +ctables.sps:15.21-15.24: error: CTABLES: Summary function MEAN applies only to +scale variables. + 15 | CTABLES /TABLE qn1 [MEAN TOTALS]. + | ^~~~ + +ctables.sps:15.16-15.18: note: CTABLES: 'QN1' is not a scale variable. + 15 | CTABLES /TABLE qn1 [MEAN TOTALS]. + | ^~~ + +ctables.sps:15.32: error: CTABLES: Syntax error at `@:>@': expecting `@<:@'. + +ctables.sps:16.21-16.24: error: CTABLES: Summary function MEAN applies only to +scale variables. + 16 | CTABLES /TABLE qn1 [MEAN TOTALS[STDDEV]%]. + | ^~~~ + +ctables.sps:16.16-16.18: note: CTABLES: 'QN1' is not a scale variable. + 16 | CTABLES /TABLE qn1 [MEAN TOTALS[STDDEV]%]. + | ^~~ + +ctables.sps:16.40: error: CTABLES: Syntax error at `%': expecting `@:>@'. + +ctables.sps:17.56: error: CTABLES: Syntax error at `x': expecting string. + +ctables.sps:18.50-18.51: error: CTABLES: Syntax error at `**': expecting THRU. + +ctables.sps:19.55: error: CTABLES: Syntax error at `x': expecting number. + +ctables.sps:20.54-20.55: error: CTABLES: Syntax error at `**': expecting number. + +ctables.sps:21.56-21.57: error: CTABLES: Syntax error at `**': expecting string. + +ctables.sps:22.48-22.49: error: CTABLES: Syntax error at `**': expecting +identifier. + +ctables.sps:23.47-23.48: error: CTABLES: Unknown postcompute &x. + 23 | CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 [&x]. + | ^~ + +ctables.sps:24.61-24.63: error: CTABLES: Syntax error at `101': Expected number +between 0 and 100 for PTILE. + +ctables.sps:25.58: error: CTABLES: Syntax error at end of command: expecting +`@:}@'. + +ctables.sps:26.54: error: CTABLES: Syntax error at end of command: expecting +`@{:@'. + +ctables.sps:27.54-27.55: error: CTABLES: Syntax error at `**': expecting INCLUDE +or EXCLUDE. + +ctables.sps:28.52-28.53: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:29.52-29.53: error: CTABLES: Syntax error at `**': expecting string. + +ctables.sps:30.55-30.56: error: CTABLES: Syntax error at `**': expecting BEFORE +or AFTER. + +ctables.sps:31.52-31.53: error: CTABLES: Syntax error at `**': expecting INCLUDE +or EXCLUDE. + +ctables.sps:32.46-32.47: error: CTABLES: Syntax error at `**': expecting ORDER, +KEY, MISSING, TOTAL, LABEL, POSITION, or EMPTY. + +ctables.sps:33.54-33.55: error: CTABLES: Syntax error at `**': expecting TOTAL, +LABEL, POSITION, or EMPTY. + +ctables.sps:34.36: error: CTABLES: Syntax error at `0': Expected positive +integer for SUBTOTAL. + +ctables.sps:35.37-35.38: error: CTABLES: Syntax error at `**': expecting `@:>@'. + +ctables.sps:36.31-36.32: error: CTABLES: Syntax error at `**': expecting THRU. + +ctables.sps:37.36-37.37: error: CTABLES: Syntax error at `**': expecting number. + +ctables.sps:38.35-38.36: error: CTABLES: Syntax error at `**': expecting number. + +ctables.sps:39.29-39.30: error: CTABLES: Syntax error at `**': expecting `@:>@'. + +ctables.sps:40.29: error: CTABLES: Syntax error at `x': expecting `@:}@'. + +ctables.sps:41.19-41.20: error: CTABLES: Syntax error at `**': expecting &. + +ctables.sps:42.20: error: CTABLES: Syntax error at `1': expecting identifier. + +ctables.sps:43.21-43.22: error: CTABLES: Syntax error at `**': expecting `='. + +ctables.sps:44.22-44.23: error: CTABLES: Syntax error at `**': expecting EXPR. + +ctables.sps:45.26-45.27: error: CTABLES: Syntax error at `**': expecting `('. + +ctables.sps:46.28: error: CTABLES: Syntax error at `x': expecting `)'. + +ctables.sps:47.31-47.49: warning: CTABLES: New definition of &k will override +the previous definition. + 47 | CTABLES /PCOMPUTE &k=EXPR(1) /PCOMPUTE &k=EXPR(2). + | ^~~~~~~~~~~~~~~~~~~ + +ctables.sps:47.10-47.28: note: CTABLES: This is the previous definition. + 47 | CTABLES /PCOMPUTE &k=EXPR(1) /PCOMPUTE &k=EXPR(2). + | ^~~~~~~~~~~~~~~~~~~ + +ctables.sps:47.50: error: CTABLES: Syntax error at end of command: expecting +`/'. + +ctables.sps:48.53-48.64: error: CTABLES: Syntax error at `NOTAFUNCTION': +Expecting summary function name. + +ctables.sps:49.59-49.60: error: CTABLES: Syntax error at `**': Expected number +between 0 and 100 for PTILE. + +ctables.sps:50.52-50.53: error: CTABLES: Syntax error at `**': expecting string. + +ctables.sps:51.61-51.62: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:52.46-52.47: error: CTABLES: Syntax error at `**': expecting LABEL, +FORMAT, or HIDESOURCECATS. + +ctables.sps:53.23-53.24: error: CTABLES: Syntax error at `**': expecting string. + +ctables.sps:54.25-54.26: error: CTABLES: Syntax error at `**': expecting string. + +ctables.sps:55.17-55.18: error: CTABLES: Syntax error at `**': expecting +MINCOLWIDTH, MAXCOLWIDTH, UNITS, EMPTY, or MISSING. + +ctables.sps:56: error: CTABLES: MINCOLWIDTH must not be greater than +MAXCOLWIDTH. + +ctables.sps:57.18-57.19: error: CTABLES: Syntax error at `**': expecting +VARIABLES. + +ctables.sps:58: error: CTABLES: NOTAVAR is not a variable name. + +ctables.sps:59.32-59.33: error: CTABLES: Syntax error at `**': expecting +DISPLAY. + +ctables.sps:60.40-60.41: error: CTABLES: Syntax error at `**': expecting +DEFAULT, NAME, LABEL, BOTH, or NONE. + +ctables.sps:61.17-61.18: error: CTABLES: Syntax error at `**': expecting +COUNTDUPLICATES. + +ctables.sps:62.33-62.34: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:63.19-63.20: error: CTABLES: Syntax error at `**': expecting +VARIABLE or LISTWISE. + +ctables.sps:64.17-64.18: error: CTABLES: Syntax error at `**': expecting +VARIABLE. + +ctables.sps:65: error: CTABLES: NOTAVAR is not a variable name. + +ctables.sps:66.32: error: CTABLES: Syntax error at `1': Expected integer 2 or +greater for HIDESMALLCOUNTS COUNT. + +ctables.sps:67.10-67.13: error: CTABLES: Syntax error at `QUUX': expecting +FORMAT, VLABELS, MRSETS, SMISSING, PCOMPUTE, PPROPERTIES, WEIGHT, +HIDESMALLCOUNTS, or TABLE. + +ctables.sps:68.33: error: CTABLES: Syntax error at end of command: expecting +`/'. + +ctables.sps:69.19-69.20: error: CTABLES: Syntax error at `**': expecting `/'. + +ctables.sps:70.38-70.39: error: CTABLES: Syntax error at `**': expecting COLUMN, +ROW, or LAYER. + +ctables.sps:71.37-71.38: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:72.29-72.30: error: CTABLES: Syntax error at `**': expecting +POSITION or VISIBLE. + +ctables.sps:73.39-73.40: error: CTABLES: Syntax error at `**': expecting +OPPOSITE or LAYER. + +ctables.sps:74.39-74.40: error: CTABLES: Syntax error at `**': expecting +OPPOSITE or LAYER. + +ctables.sps:75.29-75.30: error: CTABLES: Syntax error at `**': expecting AUTO, +ROWLABELS, or COLLABELS. + +ctables.sps:76.30-76.31: error: CTABLES: Syntax error at `**': expecting +CILEVEL. + +ctables.sps:77.38-77.40: error: CTABLES: Syntax error at `101': Expected number +in @<:@0,100@:}@ for CILEVEL. + +ctables.sps:78.28-78.29: error: CTABLES: Syntax error at `**': expecting +CAPTION, CORNER, or TITLE. + +ctables.sps:79.34-79.35: error: CTABLES: Syntax error at `**': expecting +CHISQUARE. + +ctables.sps:80.35-80.36: error: CTABLES: Syntax error at `**': Expected number +in @<:@0,1@:}@ for ALPHA. + +ctables.sps:81.43-81.44: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:82.40-82.41: error: CTABLES: Syntax error at `**': expecting +ALLVISIBLE or SUBTOTALS. + +ctables.sps:83.29-83.30: error: CTABLES: Syntax error at `**': expecting TYPE, +ALPHA, INCLUDEMRSETS, or CATEGORIES. + +ctables.sps:84.38-84.39: error: CTABLES: Syntax error at `**': expecting PROP or +MEAN. + +ctables.sps:85.39-85.40: error: CTABLES: Syntax error at `**': Expected number +in (0,1) for ALPHA. + +ctables.sps:86.39: error: CTABLES: Syntax error at `0': Expected number in (0,1) +for ALPHA. + +ctables.sps:87.40-87.41: error: CTABLES: Syntax error at `**': expecting +BONFERRONI, BH, or NONE. + +ctables.sps:88.47-88.48: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:89.47-89.48: error: CTABLES: Syntax error at `**': expecting ALLCATS +or TESTEDCATS. + +ctables.sps:90.44-90.45: error: CTABLES: Syntax error at `**': expecting +ALLVISIBLE or SUBTOTALS. + +ctables.sps:91.39-91.40: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:92.39-92.40: error: CTABLES: Syntax error at `**': expecting APA or +SIMPLE. + +ctables.sps:93.41-93.42: error: CTABLES: Syntax error at `**': expecting YES or +NO. + +ctables.sps:94.33-94.34: error: CTABLES: Syntax error at `**': expecting TYPE, +ALPHA, ADJUST, INCLUDEMRSETS, MEANSVARIANCE, CATEGORIES, MERGE, STYLE, or +SHOWSIG. + +ctables.sps:95.22-95.23: error: CTABLES: Syntax error at `**': expecting TABLE, +SLABELS, CLABELS, CRITERIA, CATEGORIES, TITLES, SIGTEST, or COMPARETEST. + +ctables.sps:96: error: CTABLES: ROWLABELS and COLLABELS may not both be +specified. + +ctables.sps:97.16-97.26: error: CTABLES: Cannot nest scale variables. + 97 | CTABLES /TABLE qn20 > qnd1. + | ^~~~~~~~~~~ + +ctables.sps:97.16-97.19: note: CTABLES: This is an outer scale variable. + 97 | CTABLES /TABLE qn20 > qnd1. + | ^~~~ + +ctables.sps:97.23-97.26: note: CTABLES: This is an inner scale variable. + 97 | CTABLES /TABLE qn20 > qnd1. + | ^~~~ + +ctables.sps:98.16-98.35: error: CTABLES: Summaries may only be requested for +categorical variables at the innermost nesting level. + 98 | CTABLES /TABLE qn1 [ROWPCT] > qnsa1. + | ^~~~~~~~~~~~~~~~~~~~ + +ctables.sps:98.16-98.18: note: CTABLES: This outer categorical variable has a +summary. + 98 | CTABLES /TABLE qn1 [ROWPCT] > qnsa1. + | ^~~ + +ctables.sps:100.52-100.56: error: CTABLES: Failed to parse category +specification as format DATETIME: Day (123) must be between 1 and 31.. + 100 | CTABLES /TABLE qn1 /CATEGORIES VARIABLES=datetime ['123']. + | ^~~~~ +]]) +AT_CLEANUP + +AT_SETUP([CTABLES parsing - more negative]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES VARIABLES=qn1 [&pc]. +CTABLES /PCOMPUTE &pc=EXPR(TOTAL) /TABLE qn1 /CATEGORIES VARIABLES=qn1 [&pc]. +CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES VARIABLES=qn1 [&pc, SUBTOTAL, SUBTOTAL]. + +STRING string(A8). +CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 ['string']. +CTABLES /TABLE string /CATEGORIES VARIABLES=string [1]. + +CTABLES /TABLE qn1 /CLABELS ROWLABELS=OPPOSITE /CATEGORIES VARIABLES=qn1 KEY=MEAN(qn1). + +CTABLES /TABLE qnd1 /CLABELS ROWLABELS=OPPOSITE. +CTABLES /TABLE qn1 + string /CLABELS ROWLABELS=OPPOSITE. +CTABLES /TABLE qn1 + qnsa1 /CLABELS ROWLABELS=OPPOSITE. +CTABLES /TABLE qn105ba + qn105bb /CLABELS ROWLABELS=OPPOSITE /CATEGORIES VARIABLES=qn105ba [1,2,3]. + +CTABLES /PCOMPUTE &x=EXPR(1**2**3). +CTABLES /PCOMPUTE &x=EXPR([**]). +CTABLES /PCOMPUTE &x=EXPR(**). + +CTABLES /TABLE. + +CTABLES /TABLE qn113 [COUNT] BY qn114 [COUNT] BY qn116 [COUNT]. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [1], +[[ctables.sps:2.76-2.78: error: CTABLES: Computed category &pc references a +category not included in the category list. + 2 | CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES +VARIABLES=qn1 [&pc]. + | +^~~ + +ctables.sps:2.28-2.35: note: CTABLES: This is the missing category. + 2 | CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES +VARIABLES=qn1 [&pc]. + | ^~~~~~~~ + +ctables.sps:2.76-2.79: note: CTABLES: To fix the problem, add subtotals to the +list of categories here. + 2 | CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES +VARIABLES=qn1 [&pc]. + | +^~~~ + +ctables.sps:3.73-3.75: error: CTABLES: Computed category &pc references a +category not included in the category list. + 3 | CTABLES /PCOMPUTE &pc=EXPR(TOTAL) /TABLE qn1 /CATEGORIES VARIABLES=qn1 +[&pc]. + | +^~~ + +ctables.sps:3.28-3.32: note: CTABLES: This is the missing category. + 3 | CTABLES /PCOMPUTE &pc=EXPR(TOTAL) /TABLE qn1 /CATEGORIES VARIABLES=qn1 +[&pc]. + | ^~~~~ + +ctables.sps:3: note: CTABLES: To fix the problem, add TOTAL=YES to the +variable's CATEGORIES specification. + +ctables.sps:4.76-4.99: error: CTABLES: These categories include 2 instances of +SUBTOTAL or HSUBTOTAL, so references from computed categories must refer to +subtotals by position, e.g. SUBTOTAL[1]. + 4 | CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES +VARIABLES=qn1 [&pc, SUBTOTAL, SUBTOTAL]. + | +^~~~~~~~~~~~~~~~~~~~~~~~ + +ctables.sps:4.28-4.35: note: CTABLES: This is the reference that lacks a +position. + 4 | CTABLES /PCOMPUTE &pc=EXPR(SUBTOTAL) /TABLE qn1 /CATEGORIES +VARIABLES=qn1 [&pc, SUBTOTAL, SUBTOTAL]. + | ^~~~~~~~ + +ctables.sps:7.47-7.54: error: CTABLES: This category specification may be +applied only to string variables, but this subcommand tries to apply it to +numeric variable QN1. + 7 | CTABLES /TABLE qn1 /CATEGORIES VARIABLES=qn1 ['string']. + | ^~~~~~~~ + +ctables.sps:8.53: error: CTABLES: This category specification may be applied +only to numeric variables, but this subcommand tries to apply it to string +variable string. + 8 | CTABLES /TABLE string /CATEGORIES VARIABLES=string [1]. + | ^ + +ctables.sps:10: error: CTABLES: ROWLABELS=OPPOSITE is not allowed with sorting +based on a summary function. + +ctables.sps:12: error: CTABLES: ROWLABELS=OPPOSITE requires the variables to be +moved to be categorical, but qnd1 is a scale variable. + +ctables.sps:13: error: CTABLES: ROWLABELS=OPPOSITE requires the variables to be +moved to have the same width, but QN1 has width 0 and string has width 8. + +ctables.sps:14: error: CTABLES: ROWLABELS=OPPOSITE requires the variables to be +moved to have the same value labels, but QN1 and QNSA1 have different value +labels. + +ctables.sps:15: error: CTABLES: ROWLABELS=OPPOSITE requires the variables to be +moved to have the same category specifications, but QN105BA and QN105BB have +different category specifications. + +ctables.sps:17.27-17.33: warning: CTABLES: The exponentiation operator (`**') is +left-associative: `a**b**c' equals `(a**b)**c', not `a**(b**c)'. To disable +this warning, insert parentheses. + 17 | CTABLES /PCOMPUTE &x=EXPR(1**2**3). + | ^~~~~~~ + +ctables.sps:17.35: error: CTABLES: Syntax error at end of command: expecting +`/'. + +ctables.sps:18.28-18.29: error: CTABLES: Syntax error at `**'. + +ctables.sps:19.27-19.28: error: CTABLES: Syntax error at `**'. + +ctables.sps:21.15: error: CTABLES: Syntax error at end of command: At least one +variable must be specified. + +ctables.sps:23: error: CTABLES: Summaries may appear only on one axis. + +ctables.sps:23.50-23.54: note: CTABLES: This variable on the layers axis has a +summary. + 23 | CTABLES /TABLE qn113 [COUNT] BY qn114 [COUNT] BY qn116 [COUNT]. + | ^~~~~ + +ctables.sps:23.16-23.20: note: CTABLES: This variable on the rows axis has a +summary. + 23 | CTABLES /TABLE qn113 [COUNT] BY qn114 [COUNT] BY qn116 [COUNT]. + | ^~~~~ + +ctables.sps:23.33-23.37: note: CTABLES: This variable on the columns axis has a +summary. + 23 | CTABLES /TABLE qn113 [COUNT] BY qn114 [COUNT] BY qn116 [COUNT]. + | ^~~~~ + +ctables.sps:23.33-23.37: note: CTABLES: This is a scale variable, so it always +has a summary even if the syntax does not explicitly specify one. + 23 | CTABLES /TABLE qn113 [COUNT] BY qn114 [COUNT] BY qn116 [COUNT]. + | ^~~~~ +]]) +AT_CLEANUP + +AT_SETUP([CTABLES one categorical variable]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE qn1. +CTABLES /TABLE BY qn1. +CTABLES /TABLE BY BY qn1. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ │Count│ +├────────────────────────────────────────────────────────────────────────┼─────┤ +│ 1. How often do you usually drive a car or other Every day │ 4667│ +│motor vehicle? Several days a week │ 1274│ +│ Once a week or less │ 361│ +│ Only certain times a │ 130│ +│ year │ │ +│ Never │ 540│ +╰────────────────────────────────────────────────────────────────────────┴─────╯ + + Custom Tables +╭──────────────────────────────────────────────────────────────────────────────╮ +│ 1. How often do you usually drive a car or other motor vehicle? │ +├─────────┬──────────────────┬──────────────────┬────────────────────────┬─────┤ +│ │ Several days a │ Once a week or │ Only certain times a │ │ +│Every day│ week │ less │ year │Never│ +├─────────┼──────────────────┼──────────────────┼────────────────────────┼─────┤ +│ Count │ Count │ Count │ Count │Count│ +├─────────┼──────────────────┼──────────────────┼────────────────────────┼─────┤ +│ 4667│ 1274│ 361│ 130│ 540│ +╰─────────┴──────────────────┴──────────────────┴────────────────────────┴─────╯ + +Custom Tables +Every day +╭─────╮ +│Count│ +├─────┤ +│ 4667│ +╰─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES one string variable]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +STRING licensed(A8). +MISSING VALUES licensed('DontKnow', 'Refused'). +RECODE qnd7a(1='Yes')(2='No')(3='DontKnow')(4='Refused') INTO licensed. +CTABLES /TABLE licensed. +CTABLES /TABLE licensed [COUNT, TOTALS[COUNT, VALIDN]] /CATEGORIES VARIABLES=ALL TOTAL=YES MISSING=INCLUDE. +CTABLES /TABLE licensed /CATEGORIES VARIABLES=licensed ['Yes', 'No'] TOTAL=YES. +* Notice that the string matching is case-sensitive. +CTABLES /TABLE licensed /CATEGORIES VARIABLES=licensed ['Yes', 'no'] TOTAL=YES. +CTABLES /TABLE licensed /CATEGORIES VARIABLES=licensed ['No' THRU 'yes'] TOTAL=YES. +CTABLES + /PCOMPUTE ¬yes=EXPR(['No']+['DontKnow']+['Refused']) + /PPROPERTIES ¬yes LABEL='Not Yes' HIDESOURCECATS=YES + /TABLE licensed + /CATEGORIES VARIABLES=licensed ['Yes', ¬yes, 'No', 'DontKnow', 'Refused']. +CTABLES + /PCOMPUTE ¬yes=EXPR(['DontKnow' THRU 'No'] + ['Refused']) + /PPROPERTIES ¬yes LABEL='Not Yes' HIDESOURCECATS=YES + /TABLE licensed + /CATEGORIES VARIABLES=licensed ['Yes', ¬yes, 'DontKnow' THRU 'No', 'Refused']. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭────────────┬─────╮ +│ │Count│ +├────────────┼─────┤ +│licensed No │ 572│ +│ Yes│ 6379│ +╰────────────┴─────╯ + + Custom Tables +╭─────────────────┬─────┬───────╮ +│ │Count│Valid N│ +├─────────────────┼─────┼───────┤ +│licensed DontKnow│ 4│ │ +│ No │ 572│ │ +│ Refused │ 44│ │ +│ Yes │ 6379│ │ +│ Total │ 6999│ 6951│ +╰─────────────────┴─────┴───────╯ + + Custom Tables +╭──────────────┬─────╮ +│ │Count│ +├──────────────┼─────┤ +│licensed Yes │ 6379│ +│ No │ 572│ +│ Total│ 6951│ +╰──────────────┴─────╯ + + Custom Tables +╭──────────────┬─────╮ +│ │Count│ +├──────────────┼─────┤ +│licensed Yes │ 6379│ +│ no │ 0│ +│ Total│ 6379│ +╰──────────────┴─────╯ + + Custom Tables +╭────────────────┬─────╮ +│ │Count│ +├────────────────┼─────┤ +│licensed No │ 572│ +│ Refused│ 44│ +│ Yes │ 6379│ +│ Total │ 6995│ +╰────────────────┴─────╯ + + Custom Tables +╭────────────────┬─────╮ +│ │Count│ +├────────────────┼─────┤ +│licensed Yes │ 6379│ +│ Not Yes│ 620│ +╰────────────────┴─────╯ + + Custom Tables +╭────────────────┬─────╮ +│ │Count│ +├────────────────┼─────┤ +│licensed Yes │ 6379│ +│ Not Yes│ 620│ +╰────────────────┴─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES one scale variable]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE qnd1[COUNT, VALIDN, TOTALN, MEAN, STDDEV, MINIMUM, MAXIMUM]. +CTABLES /TABLE BY qnd1. +CTABLES /TABLE BY BY qnd1. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭──────────────────────┬─────┬───────┬───────┬────┬────────────┬───────┬───────╮ +│ │ │ │ │ │ Std │ │ │ +│ │Count│Valid N│Total N│Mean│ Deviation │Minimum│Maximum│ +├──────────────────────┼─────┼───────┼───────┼────┼────────────┼───────┼───────┤ +│D1. AGE: What is your │ 6999│ 6930│ 6999│ 48│ 19│ 16│ 86│ +│age? │ │ │ │ │ │ │ │ +╰──────────────────────┴─────┴───────┴───────┴────┴────────────┴───────┴───────╯ + + Custom Tables +╭──────────────────────────╮ +│D1. AGE: What is your age?│ +├──────────────────────────┤ +│ Mean │ +├──────────────────────────┤ +│ 48│ +╰──────────────────────────╯ + +Custom Tables +D1. AGE: What is your age? +╭────╮ +│Mean│ +├────┤ +│ 48│ +╰────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES simple stacking]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE qn105ba + qn105bb + qn105bc + qn105bd BY qns3a [COLPCT PCT8.0]. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭───────────────────────────────────────────────────────────────┬──────────────╮ +│ │ S3a. GENDER: │ +│ ├──────┬───────┤ +│ │ Male │ Female│ +│ ├──────┼───────┤ +│ │Column│ Column│ +│ │ % │ % │ +├───────────────────────────────────────────────────────────────┼──────┼───────┤ +│105b. How likely is it that drivers who have had Almost │ 10%│ 11%│ +│too much to drink to drive safely will A. Get certain │ │ │ +│stopped by the police? Very likely │ 21%│ 22%│ +│ Somewhat │ 38%│ 42%│ +│ likely │ │ │ +│ Somewhat │ 21%│ 18%│ +│ unlikely │ │ │ +│ Very │ 10%│ 8%│ +│ unlikely │ │ │ +├───────────────────────────────────────────────────────────────┼──────┼───────┤ +│105b. How likely is it that drivers who have had Almost │ 14%│ 18%│ +│too much to drink to drive safely will B. Have an certain │ │ │ +│accident? Very likely │ 36%│ 45%│ +│ Somewhat │ 39%│ 32%│ +│ likely │ │ │ +│ Somewhat │ 9%│ 4%│ +│ unlikely │ │ │ +│ Very │ 3%│ 2%│ +│ unlikely │ │ │ +├───────────────────────────────────────────────────────────────┼──────┼───────┤ +│105b. How likely is it that drivers who have had Almost │ 18%│ 16%│ +│too much to drink to drive safely will C. Be certain │ │ │ +│convicted for drunk driving? Very likely │ 32%│ 28%│ +│ Somewhat │ 27%│ 32%│ +│ likely │ │ │ +│ Somewhat │ 15%│ 15%│ +│ unlikely │ │ │ +│ Very │ 9%│ 9%│ +│ unlikely │ │ │ +├───────────────────────────────────────────────────────────────┼──────┼───────┤ +│105b. How likely is it that drivers who have had Almost │ 16%│ 16%│ +│too much to drink to drive safely will D. Be certain │ │ │ +│arrested for drunk driving? Very likely │ 26%│ 27%│ +│ Somewhat │ 32%│ 35%│ +│ likely │ │ │ +│ Somewhat │ 17%│ 15%│ +│ unlikely │ │ │ +│ Very │ 9%│ 7%│ +│ unlikely │ │ │ +╰───────────────────────────────────────────────────────────────┴──────┴───────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES show or hide empty categories]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +IF (qn105ba = 2) qn105ba = 1. +IF (qns3a = 1) qns3a = 2. +CTABLES /TABLE qn105ba BY qns3a [COLPCT PCT8.0]. +CTABLES /TABLE qn105ba BY qns3a [COLPCT PCT8.0] + /CATEGORIES VAR=qn105ba EMPTY=EXCLUDE. +CTABLES /TABLE qn105ba BY qns3a [COLPCT PCT8.0] + /CATEGORIES VAR=qns3a EMPTY=EXCLUDE. +CTABLES /TABLE qn105ba BY qns3a [COLPCT PCT8.0] + /CATEGORIES VAR=ALL EMPTY=EXCLUDE. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭──────────────────────────────────────────────────────────────┬───────────────╮ +│ │ S3a. GENDER: │ +│ ├───────┬───────┤ +│ │ Male │ Female│ +│ ├───────┼───────┤ +│ │ Column│ Column│ +│ │ % │ % │ +├──────────────────────────────────────────────────────────────┼───────┼───────┤ +│105b. How likely is it that drivers who have had Almost │ .│ 32%│ +│too much to drink to drive safely will A. Get certain │ │ │ +│stopped by the police? Very likely│ .│ 0%│ +│ Somewhat │ .│ 40%│ +│ likely │ │ │ +│ Somewhat │ .│ 19%│ +│ unlikely │ │ │ +│ Very │ .│ 9%│ +│ unlikely │ │ │ +╰──────────────────────────────────────────────────────────────┴───────┴───────╯ + + Custom Tables +╭──────────────────────────────────────────────────────────────┬───────────────╮ +│ │ S3a. GENDER: │ +│ ├───────┬───────┤ +│ │ Male │ Female│ +│ ├───────┼───────┤ +│ │ Column│ Column│ +│ │ % │ % │ +├──────────────────────────────────────────────────────────────┼───────┼───────┤ +│105b. How likely is it that drivers who have had Almost │ .│ 32%│ +│too much to drink to drive safely will A. Get certain │ │ │ +│stopped by the police? Somewhat │ .│ 40%│ +│ likely │ │ │ +│ Somewhat │ .│ 19%│ +│ unlikely │ │ │ +│ Very │ .│ 9%│ +│ unlikely │ │ │ +╰──────────────────────────────────────────────────────────────┴───────┴───────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────┬─────────╮ +│ │ S3a. │ +│ │ GENDER: │ +│ ├─────────┤ +│ │ Female │ +│ ├─────────┤ +│ │ Column %│ +├────────────────────────────────────────────────────────────────────┼─────────┤ +│105b. How likely is it that drivers who have had too Almost │ 32%│ +│much to drink to drive safely will A. Get stopped by certain │ │ +│the police? Very likely │ 0%│ +│ Somewhat │ 40%│ +│ likely │ │ +│ Somewhat │ 19%│ +│ unlikely │ │ +│ Very │ 9%│ +│ unlikely │ │ +╰────────────────────────────────────────────────────────────────────┴─────────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────┬─────────╮ +│ │ S3a. │ +│ │ GENDER: │ +│ ├─────────┤ +│ │ Female │ +│ ├─────────┤ +│ │ Column %│ +├────────────────────────────────────────────────────────────────────┼─────────┤ +│105b. How likely is it that drivers who have had too Almost │ 32%│ +│much to drink to drive safely will A. Get stopped by certain │ │ +│the police? Somewhat │ 40%│ +│ likely │ │ +│ Somewhat │ 19%│ +│ unlikely │ │ +│ Very │ 9%│ +│ unlikely │ │ +╰────────────────────────────────────────────────────────────────────┴─────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES sorting categories]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +IF (QND5A=6) QND5A=-1. +IF (QND5A=5) QND5A=-2. +CTABLES /TABLE qnd5a /CATEGORIES VARIABLES=qnd5a KEY=VALUE ORDER=A + /TABLE qnd5a /CATEGORIES VARIABLES=qnd5a KEY=VALUE ORDER=D + /TABLE qnd5a /CATEGORIES VARIABLES=qnd5a KEY=LABEL ORDER=A + /TABLE qnd5a /CATEGORIES VARIABLES=qnd5a KEY=LABEL ORDER=D. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ │Count│ +├────────────────────────────────────────────────────────────────────────┼─────┤ +│D5a. What would you say is your primary ethnic -2.00 │ 52│ +│background? -1.00 │ 78│ +│ Cuban │ 20│ +│ Mexican │ 311│ +│ Spanish │ 48│ +│ South American │ 34│ +│ Central American │ 0│ +│ Puerto Rican, OR │ 0│ +│ Something else │ 68│ +│ Multiple - cannot choose│ 7│ +│ one │ │ +╰────────────────────────────────────────────────────────────────────────┴─────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ │Count│ +├────────────────────────────────────────────────────────────────────────┼─────┤ +│D5a. What would you say is your primary ethnic Multiple - cannot choose│ 7│ +│background? one │ │ +│ Something else │ 68│ +│ Puerto Rican, OR │ 0│ +│ Central American │ 0│ +│ South American │ 34│ +│ Spanish │ 48│ +│ Mexican │ 311│ +│ Cuban │ 20│ +│ -1.00 │ 78│ +│ -2.00 │ 52│ +╰────────────────────────────────────────────────────────────────────────┴─────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ │Count│ +├────────────────────────────────────────────────────────────────────────┼─────┤ +│D5a. What would you say is your primary ethnic Central American │ 0│ +│background? Cuban │ 20│ +│ Mexican │ 311│ +│ Multiple - cannot choose│ 7│ +│ one │ │ +│ Puerto Rican, OR │ 0│ +│ Something else │ 68│ +│ South American │ 34│ +│ Spanish │ 48│ +│ -2.00 │ 52│ +│ -1.00 │ 78│ +╰────────────────────────────────────────────────────────────────────────┴─────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ │Count│ +├────────────────────────────────────────────────────────────────────────┼─────┤ +│D5a. What would you say is your primary ethnic Spanish │ 48│ +│background? South American │ 34│ +│ Something else │ 68│ +│ Puerto Rican, OR │ 0│ +│ Multiple - cannot choose│ 7│ +│ one │ │ +│ Mexican │ 311│ +│ Cuban │ 20│ +│ Central American │ 0│ +│ -1.00 │ 78│ +│ -2.00 │ 52│ +╰────────────────────────────────────────────────────────────────────────┴─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES simple nesting]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE (qn105ba + qn105bb + qn105bc + qn105bd) > qns3a [COUNT, TABLEPCT PCT8.0] + /CATEGORIES VARIABLES=qns3a TOTAL=YES. +CTABLES /TABLE qns3a > (qn105ba + qn105bb + qn105bc + qn105bd) [TABLEPCT PCT8.0] + /CATEGORIES VARIABLES=qns3a TOTAL=YES + /CLABELS ROW=OPPOSITE. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭─────────────────────────────────────────────────────────────────┬─────┬──────╮ +│ │ │ Table│ +│ │Count│ % │ +├─────────────────────────────────────────────────────────────────┼─────┼──────┤ +│105b. How likely is it that drivers Almost S3a. Male │ 297│ 4%│ +│who have had too much to drink to certain GENDER: Female│ 403│ 6%│ +│drive safely will A. Get stopped by Total │ 700│ 10%│ +│the police? ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 660│ 10%│ +│ likely GENDER: Female│ 842│ 12%│ +│ Total │ 1502│ 22%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 1174│ 17%│ +│ likely GENDER: Female│ 1589│ 23%│ +│ Total │ 2763│ 40%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 640│ 9%│ +│ unlikely GENDER: Female│ 667│ 10%│ +│ Total │ 1307│ 19%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 311│ 5%│ +│ unlikely GENDER: Female│ 298│ 4%│ +│ Total │ 609│ 9%│ +├─────────────────────────────────────────────────────────────────┼─────┼──────┤ +│105b. How likely is it that drivers Almost S3a. Male │ 429│ 6%│ +│who have had too much to drink to certain GENDER: Female│ 671│ 10%│ +│drive safely will B. Have an accident? Total │ 1100│ 16%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 1104│ 16%│ +│ likely GENDER: Female│ 1715│ 25%│ +│ Total │ 2819│ 41%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 1203│ 17%│ +│ likely GENDER: Female│ 1214│ 18%│ +│ Total │ 2417│ 35%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 262│ 4%│ +│ unlikely GENDER: Female│ 168│ 2%│ +│ Total │ 430│ 6%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 81│ 1%│ +│ unlikely GENDER: Female│ 59│ 1%│ +│ Total │ 140│ 2%│ +├─────────────────────────────────────────────────────────────────┼─────┼──────┤ +│105b. How likely is it that drivers Almost S3a. Male │ 539│ 8%│ +│who have had too much to drink to certain GENDER: Female│ 610│ 9%│ +│drive safely will C. Be convicted for Total │ 1149│ 17%│ +│drunk driving? ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 988│ 14%│ +│ likely GENDER: Female│ 1049│ 15%│ +│ Total │ 2037│ 30%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 822│ 12%│ +│ likely GENDER: Female│ 1210│ 18%│ +│ Total │ 2032│ 30%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 446│ 7%│ +│ unlikely GENDER: Female│ 548│ 8%│ +│ Total │ 994│ 15%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 268│ 4%│ +│ unlikely GENDER: Female│ 354│ 5%│ +│ Total │ 622│ 9%│ +├─────────────────────────────────────────────────────────────────┼─────┼──────┤ +│105b. How likely is it that drivers Almost S3a. Male │ 498│ 7%│ +│who have had too much to drink to certain GENDER: Female│ 603│ 9%│ +│drive safely will D. Be arrested for Total │ 1101│ 16%│ +│drunk driving? ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 805│ 12%│ +│ likely GENDER: Female│ 1029│ 15%│ +│ Total │ 1834│ 27%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 975│ 14%│ +│ likely GENDER: Female│ 1332│ 19%│ +│ Total │ 2307│ 34%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Somewhat S3a. Male │ 535│ 8%│ +│ unlikely GENDER: Female│ 560│ 8%│ +│ Total │ 1095│ 16%│ +│ ╶──────────────────────────┼─────┼──────┤ +│ Very S3a. Male │ 270│ 4%│ +│ unlikely GENDER: Female│ 279│ 4%│ +│ Total │ 549│ 8%│ +╰─────────────────────────────────────────────────────────────────┴─────┴──────╯ + + Custom Tables +╭─────────────────────────────────┬────────┬──────┬─────────┬─────────┬────────╮ +│ │ Almost │ Very │ Somewhat│ Somewhat│ Very │ +│ │ certain│likely│ likely │ unlikely│unlikely│ +│ ├────────┼──────┼─────────┼─────────┼────────┤ +│ │ │ Table│ │ │ │ +│ │ Table %│ % │ Table % │ Table % │ Table %│ +├─────────────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│S3a. Male 105b. How likely │ 4%│ 10%│ 17%│ 9%│ 5%│ +│GENDER: is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ A. Get stopped by │ │ │ │ │ │ +│ the police? │ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Female 105b. How likely │ 6%│ 12%│ 23%│ 10%│ 4%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ A. Get stopped by │ │ │ │ │ │ +│ the police? │ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Total 105b. How likely │ 10%│ 22%│ 40%│ 19%│ 9%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ A. Get stopped by │ │ │ │ │ │ +│ the police? │ │ │ │ │ │ +├─────────────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│S3a. Male 105b. How likely │ 6%│ 16%│ 17%│ 4%│ 1%│ +│GENDER: is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ B. Have an │ │ │ │ │ │ +│ accident? │ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Female 105b. How likely │ 10%│ 25%│ 18%│ 2%│ 1%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ B. Have an │ │ │ │ │ │ +│ accident? │ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Total 105b. How likely │ 16%│ 41%│ 35%│ 6%│ 2%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ B. Have an │ │ │ │ │ │ +│ accident? │ │ │ │ │ │ +├─────────────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│S3a. Male 105b. How likely │ 8%│ 14%│ 12%│ 7%│ 4%│ +│GENDER: is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ C. Be convicted │ │ │ │ │ │ +│ for drunk driving?│ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Female 105b. How likely │ 9%│ 15%│ 18%│ 8%│ 5%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ C. Be convicted │ │ │ │ │ │ +│ for drunk driving?│ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Total 105b. How likely │ 17%│ 30%│ 30%│ 15%│ 9%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ C. Be convicted │ │ │ │ │ │ +│ for drunk driving?│ │ │ │ │ │ +├─────────────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│S3a. Male 105b. How likely │ 7%│ 12%│ 14%│ 8%│ 4%│ +│GENDER: is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ D. Be arrested for│ │ │ │ │ │ +│ drunk driving? │ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Female 105b. How likely │ 9%│ 15%│ 19%│ 8%│ 4%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ D. Be arrested for│ │ │ │ │ │ +│ drunk driving? │ │ │ │ │ │ +│ ╶─────────────────────────┼────────┼──────┼─────────┼─────────┼────────┤ +│ Total 105b. How likely │ 16%│ 27%│ 34%│ 16%│ 8%│ +│ is it that drivers│ │ │ │ │ │ +│ who have had too │ │ │ │ │ │ +│ much to drink to │ │ │ │ │ │ +│ drive safely will │ │ │ │ │ │ +│ D. Be arrested for│ │ │ │ │ │ +│ drunk driving? │ │ │ │ │ │ +╰─────────────────────────────────┴────────┴──────┴─────────┴─────────┴────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES nesting and scale variables]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE=qnd1 > qn1 BY qns3a. +CTABLES /TABLE=qnd1 [MINIMUM, MAXIMUM, MEAN] > qns3a > (qn26 + qn27). +CTABLES /TABLE=qnsa1 > qn105ba [COLPCT] BY qns1 + /CATEGORIES VAR=qnsa1 EMPTY=EXCLUDE. +CTABLES /TABLE=AgeGroup > qn20 [MEAN F8.1, STDDEV F8.1]. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭─────────────────────────────────────────────────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │ Mean│ Mean │ +├─────────────────────────────────────────────────────────────────┼─────┼──────┤ +│D1. AGE: What 1. How often do you usually drive Every day │ 46│ 46│ +│is your age? a car or other motor vehicle? Several days a │ 51│ 59│ +│ week │ │ │ +│ Once a week or │ 44│ 54│ +│ less │ │ │ +│ Only certain │ 34│ 41│ +│ times a year │ │ │ +│ Never │ 39│ 55│ +╰─────────────────────────────────────────────────────────────────┴─────┴──────╯ + + Custom Tables +╭─────────────────────────────────────────────────────────┬───────┬───────┬────╮ +│ │Minimum│Maximum│Mean│ +├─────────────────────────────────────────────────────────┼───────┼───────┼────┤ +│D1. AGE: S3a. Male 26. During the last 12 Yes│ 16│ 86│ 42│ +│What is GENDER: months, has there been a │ │ │ │ +│your time when you felt you │ │ │ │ +│age? should cut down on your No │ 16│ 86│ 46│ +│ drinking? │ │ │ │ +│ ╶───────────────────────────────────────┼───────┼───────┼────┤ +│ Female 26. During the last 12 Yes│ 16│ 86│ 43│ +│ months, has there been a │ │ │ │ +│ time when you felt you │ │ │ │ +│ should cut down on your No │ 16│ 86│ 48│ +│ drinking? │ │ │ │ +├─────────────────────────────────────────────────────────┼───────┼───────┼────┤ +│D1. AGE: S3a. Male 27. During the last 12 Yes│ 16│ 86│ 38│ +│What is GENDER: months, has there been a │ │ │ │ +│your time when people criticized No │ 16│ 86│ 46│ +│age? your drinking? │ │ │ │ +│ ╶───────────────────────────────────────┼───────┼───────┼────┤ +│ Female 27. During the last 12 Yes│ 17│ 69│ 37│ +│ months, has there been a │ │ │ │ +│ time when people criticized No │ 16│ 86│ 48│ +│ your drinking? │ │ │ │ +╰─────────────────────────────────────────────────────────┴───────┴───────┴────╯ + + Custom Tables +╭─────────────────────────────┬────────────────────────────────────────────────╮ +│ │S1. Including yourself, how many members of this│ +│ │ household are age 16 or older? │ +│ ├──────┬──────┬──────┬──────┬──────┬──────┬──────┤ +│ │ │ │ │ │ │ │ 6 or │ +│ │ None │ 1 │ 2 │ 3 │ 4 │ 5 │ more │ +│ ├──────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│ │Column│Column│Column│Column│Column│Column│Column│ +│ │ % │ % │ % │ % │ % │ % │ % │ +├─────────────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│Sa1. RDD 105b. Almost │ .│ 9.5%│ 8.2%│ 12.4%│ 9.9%│ 20.0%│ 23.8%│ +│SAMPLE How certain │ │ │ │ │ │ │ │ +│SOURCE: likely │ │ │ │ │ │ │ │ +│ is it Very │ .│ 24.9%│ 18.5%│ 24.0%│ 26.6%│ 25.5%│ 33.3%│ +│ that likely │ │ │ │ │ │ │ │ +│ drivers │ │ │ │ │ │ │ │ +│ who have │ │ │ │ │ │ │ │ +│ had too Somewhat│ .│ 38.3%│ 41.9%│ 38.6%│ 37.5%│ 36.4%│ 23.8%│ +│ much to likely │ │ │ │ │ │ │ │ +│ drink to │ │ │ │ │ │ │ │ +│ drive │ │ │ │ │ │ │ │ +│ safely Somewhat│ .│ 18.1%│ 21.7%│ 16.8%│ 16.7%│ 10.9%│ 9.5%│ +│ will A. unlikely│ │ │ │ │ │ │ │ +│ Get │ │ │ │ │ │ │ │ +│ stopped Very │ .│ 9.2%│ 9.7%│ 8.2%│ 9.4%│ 7.3%│ 9.5%│ +│ by the unlikely│ │ │ │ │ │ │ │ +│ police? │ │ │ │ │ │ │ │ +╰─────────────────────────────┴──────┴──────┴──────┴──────┴──────┴──────┴──────╯ + + Custom Tables +╭──────────────────────────────────────────────────────────────┬────┬──────────╮ +│ │ │ Std │ +│ │Mean│ Deviation│ +├──────────────────────────────────────────────────────────────┼────┼──────────┤ +│Age 16 to 25 20. On how many of the thirty days in this │ 5.2│ 6.0│ +│group typical month did you have one or more │ │ │ +│ alcoholic beverages to drink? │ │ │ +│ ╶───────────────────────────────────────────────────────┼────┼──────────┤ +│ 26 to 35 20. On how many of the thirty days in this │ 4.7│ 5.9│ +│ typical month did you have one or more │ │ │ +│ alcoholic beverages to drink? │ │ │ +│ ╶───────────────────────────────────────────────────────┼────┼──────────┤ +│ 36 to 45 20. On how many of the thirty days in this │ 5.5│ 6.8│ +│ typical month did you have one or more │ │ │ +│ alcoholic beverages to drink? │ │ │ +│ ╶───────────────────────────────────────────────────────┼────┼──────────┤ +│ 46 to 55 20. On how many of the thirty days in this │ 5.8│ 7.7│ +│ typical month did you have one or more │ │ │ +│ alcoholic beverages to drink? │ │ │ +│ ╶───────────────────────────────────────────────────────┼────┼──────────┤ +│ 56 to 65 20. On how many of the thirty days in this │ 6.3│ 8.2│ +│ typical month did you have one or more │ │ │ +│ alcoholic beverages to drink? │ │ │ +│ ╶───────────────────────────────────────────────────────┼────┼──────────┤ +│ 66 or 20. On how many of the thirty days in this │ 7.1│ 9.2│ +│ older typical month did you have one or more │ │ │ +│ alcoholic beverages to drink? │ │ │ +╰──────────────────────────────────────────────────────────────┴────┴──────────╯ +]) +AT_CLEANUP + + +AT_SETUP([CTABLES SLABELS]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE qn1 [COUNT COLPCT]. +CTABLES /TABLE qn1 [COUNT COLPCT] + /SLABELS POSITION=ROW. +CTABLES /TABLE qn1 [COUNT COLPCT] + /SLABELS POSITION=ROW VISIBLE=NO. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭────────────────────────────────────────────────────────────────┬─────┬───────╮ +│ │ │ Column│ +│ │Count│ % │ +├────────────────────────────────────────────────────────────────┼─────┼───────┤ +│ 1. How often do you usually drive a car or Every day │ 4667│ 66.9%│ +│other motor vehicle? Several days a week│ 1274│ 18.3%│ +│ Once a week or less│ 361│ 5.2%│ +│ Only certain times │ 130│ 1.9%│ +│ a year │ │ │ +│ Never │ 540│ 7.7%│ +╰────────────────────────────────────────────────────────────────┴─────┴───────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ 1. How often do you usually drive a car or Every day Count │ 4667│ +│other motor vehicle? Column │66.9%│ +│ % │ │ +│ ╶───────────────────────────┼─────┤ +│ Several days a week Count │ 1274│ +│ Column │18.3%│ +│ % │ │ +│ ╶───────────────────────────┼─────┤ +│ Once a week or less Count │ 361│ +│ Column │ 5.2%│ +│ % │ │ +│ ╶───────────────────────────┼─────┤ +│ Only certain times Count │ 130│ +│ a year Column │ 1.9%│ +│ % │ │ +│ ╶───────────────────────────┼─────┤ +│ Never Count │ 540│ +│ Column │ 7.7%│ +│ % │ │ +╰────────────────────────────────────────────────────────────────────────┴─────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ 1. How often do you usually drive a car or other Every day │ 4667│ +│motor vehicle? │66.9%│ +│ Several days a week │ 1274│ +│ │18.3%│ +│ Once a week or less │ 361│ +│ │ 5.2%│ +│ Only certain times a │ 130│ +│ year │ 1.9%│ +│ Never │ 540│ +│ │ 7.7%│ +╰────────────────────────────────────────────────────────────────────────┴─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES simple totals]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE=qn17 + /CATEGORIES VARIABLES=qn17 TOTAL=YES LABEL='Number responding'. +DESCRIPTIVES qn18/STATISTICS=MEAN. +CTABLES /TABLE=region > qn18 [MEAN, COUNT, VALIDN, TOTALN] + /CATEGORIES VARIABLES=region TOTAL=YES LABEL='All regions'. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=80], [0], [dnl + Custom Tables +╭────────────────────────────────────────────────────────────────────────┬─────╮ +│ │Count│ +├────────────────────────────────────────────────────────────────────────┼─────┤ +│17. When you drink alcoholic beverages, which ONE of OR, something else│ 2│ +│the following beverages do you drink MOST OFTEN? Beer │ 1073│ +│ Light beer │ 620│ +│ Wine │ 1418│ +│ Wine coolers │ 137│ +│ Hard liquor or │ 888│ +│ mixed drinks │ │ +│ Flavored malt │ 83│ +│ drinks │ │ +│ Number responding │ 4221│ +╰────────────────────────────────────────────────────────────────────────┴─────╯ + + Descriptive Statistics +╭────────────────────────────────────────────────────────────────────┬────┬────╮ +│ │ N │Mean│ +├────────────────────────────────────────────────────────────────────┼────┼────┤ +│18. When you drink ANSWERFROM(QN17R1), about how many │4218│4.62│ +│ANSWERFROM(QN17R2) do you usually drink per sitting? │ │ │ +│Valid N (listwise) │6999│ │ +│Missing N (listwise) │2781│ │ +╰────────────────────────────────────────────────────────────────────┴────┴────╯ + + Custom Tables +╭──────────────────────────────────────────────────────┬────┬─────┬──────┬─────╮ +│ │ │ │ Valid│Total│ +│ │Mean│Count│ N │ N │ +├──────────────────────────────────────────────────────┼────┼─────┼──────┼─────┤ +│Region NE 18. When you drink ANSWERFROM(QN17R1),│4.36│ 1409│ 949│ 1409│ +│ about how many ANSWERFROM(QN17R2) do │ │ │ │ │ +│ you usually drink per sitting? │ │ │ │ │ +│ ╶───────────────────────────────────────────────┼────┼─────┼──────┼─────┤ +│ MW 18. When you drink ANSWERFROM(QN17R1),│4.67│ 1654│ 1027│ 1654│ +│ about how many ANSWERFROM(QN17R2) do │ │ │ │ │ +│ you usually drink per sitting? │ │ │ │ │ +│ ╶───────────────────────────────────────────────┼────┼─────┼──────┼─────┤ +│ S 18. When you drink ANSWERFROM(QN17R1),│4.71│ 2390│ 1287│ 2390│ +│ about how many ANSWERFROM(QN17R2) do │ │ │ │ │ +│ you usually drink per sitting? │ │ │ │ │ +│ ╶───────────────────────────────────────────────┼────┼─────┼──────┼─────┤ +│ W 18. When you drink ANSWERFROM(QN17R1),│4.69│ 1546│ 955│ 1546│ +│ about how many ANSWERFROM(QN17R2) do │ │ │ │ │ +│ you usually drink per sitting? │ │ │ │ │ +│ ╶───────────────────────────────────────────────┼────┼─────┼──────┼─────┤ +│ All 18. When you drink ANSWERFROM(QN17R1),│4.62│ 6999│ 4218│ 6999│ +│ regions about how many ANSWERFROM(QN17R2) do │ │ │ │ │ +│ you usually drink per sitting? │ │ │ │ │ +╰──────────────────────────────────────────────────────┴────┴─────┴──────┴─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES subtotals]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE=qn105ba BY qns1 + /CATEGORIES VARIABLES=qns1 [1, 2, SUBTOTAL, 3, 4, 5, SUBTOTAL]. +CTABLES /TABLE=qn105ba [COLPCT] BY qns1 + /CATEGORIES VARIABLES=qn105ba [1, 2, 3, SUBTOTAL, 4, 5, SUBTOTAL]. +CTABLES /TABLE=qn105ba BY qns1 + /CATEGORIES VARIABLES=qn105ba [1, 2, 3, SUBTOTAL, 4, 5, SUBTOTAL] + /CATEGORIES VARIABLES=qns1 [1, 2, SUBTOTAL, 3, 4, 5, SUBTOTAL]. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=120], [0], [dnl + Custom Tables +╭─────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────────╮ +│ │ S1. Including yourself, how many members of this household │ +│ │ are age 16 or older? │ +│ ├───────┬───────┬─────────┬───────┬────────┬──────┬──────────┤ +│ │ 1 │ 2 │ Subtotal│ 3 │ 4 │ 5 │ Subtotal │ +│ ├───────┼───────┼─────────┼───────┼────────┼──────┼──────────┤ +│ │ Count │ Count │ Count │ Count │ Count │ Count│ Count │ +├─────────────────────────────────────────────────────────┼───────┼───────┼─────────┼───────┼────────┼──────┼──────────┤ +│105b. How likely is it that drivers who have Almost │ 147│ 246│ 393│ 62│ 19│ 11│ 92│ +│had too much to drink to drive safely will A. certain │ │ │ │ │ │ │ │ +│Get stopped by the police? Very likely│ 384│ 552│ 936│ 120│ 51│ 14│ 185│ +│ Somewhat │ 590│ 1249│ 1839│ 193│ 72│ 20│ 285│ +│ likely │ │ │ │ │ │ │ │ +│ Somewhat │ 278│ 647│ 925│ 84│ 32│ 6│ 122│ +│ unlikely │ │ │ │ │ │ │ │ +│ Very │ 141│ 290│ 431│ 41│ 18│ 4│ 63│ +│ unlikely │ │ │ │ │ │ │ │ +╰─────────────────────────────────────────────────────────┴───────┴───────┴─────────┴───────┴────────┴──────┴──────────╯ + + Custom Tables +╭────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────╮ +│ │ S1. Including yourself, how many members of this household │ +│ │ are age 16 or older? │ +│ ├────────┬────────┬────────┬────────┬───────┬────────┬────────┤ +│ │ │ │ │ │ │ │ 6 or │ +│ │ None │ 1 │ 2 │ 3 │ 4 │ 5 │ more │ +│ ├────────┼────────┼────────┼────────┼───────┼────────┼────────┤ +│ │ │ │ │ │ Column│ │ │ +│ │Column %│Column %│Column %│Column %│ % │Column %│Column %│ +├────────────────────────────────────────────────────────┼────────┼────────┼────────┼────────┼───────┼────────┼────────┤ +│105b. How likely is it that drivers who have Almost │ .│ 9.5%│ 8.2%│ 12.4%│ 9.9%│ 20.0%│ 23.8%│ +│had too much to drink to drive safely will certain │ │ │ │ │ │ │ │ +│A. Get stopped by the police? Very likely│ .│ 24.9%│ 18.5%│ 24.0%│ 26.6%│ 25.5%│ 33.3%│ +│ Somewhat │ .│ 38.3%│ 41.9%│ 38.6%│ 37.5%│ 36.4%│ 23.8%│ +│ likely │ │ │ │ │ │ │ │ +│ Subtotal │ │ 72.8%│ 68.6%│ 75.0%│ 74.0%│ 81.8%│ 81.0%│ +│ Somewhat │ .│ 18.1%│ 21.7%│ 16.8%│ 16.7%│ 10.9%│ 9.5%│ +│ unlikely │ │ │ │ │ │ │ │ +│ Very │ .│ 9.2%│ 9.7%│ 8.2%│ 9.4%│ 7.3%│ 9.5%│ +│ unlikely │ │ │ │ │ │ │ │ +│ Subtotal │ │ 27.2%│ 31.4%│ 25.0%│ 26.0%│ 18.2%│ 19.0%│ +╰────────────────────────────────────────────────────────┴────────┴────────┴────────┴────────┴───────┴────────┴────────╯ + + Custom Tables +╭─────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────────╮ +│ │ S1. Including yourself, how many members of this household │ +│ │ are age 16 or older? │ +│ ├───────┬───────┬─────────┬───────┬────────┬──────┬──────────┤ +│ │ 1 │ 2 │ Subtotal│ 3 │ 4 │ 5 │ Subtotal │ +│ ├───────┼───────┼─────────┼───────┼────────┼──────┼──────────┤ +│ │ Count │ Count │ Count │ Count │ Count │ Count│ Count │ +├─────────────────────────────────────────────────────────┼───────┼───────┼─────────┼───────┼────────┼──────┼──────────┤ +│105b. How likely is it that drivers who have Almost │ 147│ 246│ 393│ 62│ 19│ 11│ 92│ +│had too much to drink to drive safely will A. certain │ │ │ │ │ │ │ │ +│Get stopped by the police? Very likely│ 384│ 552│ 936│ 120│ 51│ 14│ 185│ +│ Somewhat │ 590│ 1249│ 1839│ 193│ 72│ 20│ 285│ +│ likely │ │ │ │ │ │ │ │ +│ Subtotal │ 1121│ 2047│ 3168│ 375│ 142│ 45│ 562│ +│ Somewhat │ 278│ 647│ 925│ 84│ 32│ 6│ 122│ +│ unlikely │ │ │ │ │ │ │ │ +│ Very │ 141│ 290│ 431│ 41│ 18│ 4│ 63│ +│ unlikely │ │ │ │ │ │ │ │ +│ Subtotal │ 419│ 937│ 1356│ 125│ 50│ 10│ 185│ +╰─────────────────────────────────────────────────────────┴───────┴───────┴─────────┴───────┴────────┴──────┴──────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES PCOMPUTE]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES + /PCOMPUTE &x=EXPR([3] + [4]) + /PCOMPUTE &y=EXPR([4] + [5]) + /PPROPERTIES &x LABEL='3+4' HIDESOURCECATS=YES FORMAT=COUNT F8.2 + /PPROPERTIES &y LABEL='4+5' + /TABLE=qn105ba BY qns1 + /CATEGORIES VARIABLES=qns1 [1, 2, SUBTOTAL, 3, 4, 5, &x, &y, SUBTOTAL] +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=120], [0], [dnl + Custom Tables +╭────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────╮ +│ │ S1. Including yourself, how many members of this household │ +│ │ are age 16 or older? │ +│ ├───────┬───────┬──────────┬───────┬────────┬──────┬──────────┤ +│ │ 1 │ 2 │ Subtotal │ 5 │ 3+4 │ 4+5 │ Subtotal │ +│ ├───────┼───────┼──────────┼───────┼────────┼──────┼──────────┤ +│ │ Count │ Count │ Count │ Count │ Count │ Count│ Count │ +├────────────────────────────────────────────────────────┼───────┼───────┼──────────┼───────┼────────┼──────┼──────────┤ +│105b. How likely is it that drivers who have Almost │ 147│ 246│ 393│ 11│ 81.00│ 30│ 92│ +│had too much to drink to drive safely will certain │ │ │ │ │ │ │ │ +│A. Get stopped by the police? Very likely│ 384│ 552│ 936│ 14│ 171.00│ 65│ 185│ +│ Somewhat │ 590│ 1249│ 1839│ 20│ 265.00│ 92│ 285│ +│ likely │ │ │ │ │ │ │ │ +│ Somewhat │ 278│ 647│ 925│ 6│ 116.00│ 38│ 122│ +│ unlikely │ │ │ │ │ │ │ │ +│ Very │ 141│ 290│ 431│ 4│ 59.00│ 22│ 63│ +│ unlikely │ │ │ │ │ │ │ │ +╰────────────────────────────────────────────────────────┴───────┴───────┴──────────┴───────┴────────┴──────┴──────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES CLABELS]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE AgeGroup BY qns3a. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS ROWLABELS=OPPOSITE. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS COLLABELS=OPPOSITE. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS ROWLABELS=LAYER. +CTABLES /TABLE AgeGroup BY qns3a /CLABELS COLLABELS=LAYER. +]]) +pwd +AT_CHECK([pspp ctables.sps --table-look="$builddir"/all-layers.stt -O box=unicode -O width=120], [0], [dnl + Custom Tables +╭───────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├───────────────────────┼─────┼──────┤ +│Age group 15 or younger│ 0│ 0│ +│ 16 to 25 │ 594│ 505│ +│ 26 to 35 │ 476│ 491│ +│ 36 to 45 │ 489│ 548│ +│ 46 to 55 │ 526│ 649│ +│ 56 to 65 │ 516│ 731│ +│ 66 or older │ 531│ 943│ +╰───────────────────────┴─────┴──────╯ + + Custom Tables +╭───────┬──────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ │ S3a. GENDER: │ +│ ├──────────────────────────────────────────────────────┬───────────────────────────────────────────────────────┤ +│ │ Male │ Female │ +│ ├─────────┬───────┬──────┬──────┬──────┬───────┬───────┼──────────┬──────┬───────┬──────┬──────┬──────┬────────┤ +│ │ 15 or │ 16 to │ 26 to│ 36 to│ 46 to│ 56 to │ 66 or │ 15 or │ 16 to│ 26 to │ 36 to│ 46 to│ 56 to│ 66 or │ +│ │ younger │ 25 │ 35 │ 45 │ 55 │ 65 │ older │ younger │ 25 │ 35 │ 45 │ 55 │ 65 │ older │ +│ ├─────────┼───────┼──────┼──────┼──────┼───────┼───────┼──────────┼──────┼───────┼──────┼──────┼──────┼────────┤ +│ │ Count │ Count │ Count│ Count│ Count│ Count │ Count │ Count │ Count│ Count │ Count│ Count│ Count│ Count │ +├───────┼─────────┼───────┼──────┼──────┼──────┼───────┼───────┼──────────┼──────┼───────┼──────┼──────┼──────┼────────┤ +│Age │ 0│ 594│ 476│ 489│ 526│ 516│ 531│ 0│ 505│ 491│ 548│ 649│ 731│ 943│ +│group │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ +╰───────┴─────────┴───────┴──────┴──────┴──────┴───────┴───────┴──────────┴──────┴───────┴──────┴──────┴──────┴────────╯ + + Custom Tables +╭──────────────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├────────────┤ +│ │ Count │ +├──────────────────────────────┼────────────┤ +│Age group 15 or younger Male │ 0│ +│ Female│ 0│ +│ ╶────────────────────┼────────────┤ +│ 16 to 25 Male │ 594│ +│ Female│ 505│ +│ ╶────────────────────┼────────────┤ +│ 26 to 35 Male │ 476│ +│ Female│ 491│ +│ ╶────────────────────┼────────────┤ +│ 36 to 45 Male │ 489│ +│ Female│ 548│ +│ ╶────────────────────┼────────────┤ +│ 46 to 55 Male │ 526│ +│ Female│ 649│ +│ ╶────────────────────┼────────────┤ +│ 56 to 65 Male │ 516│ +│ Female│ 731│ +│ ╶────────────────────┼────────────┤ +│ 66 or older Male │ 531│ +│ Female│ 943│ +╰──────────────────────────────┴────────────╯ + + Custom Tables +15 or younger +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 0│ 0│ +╰─────────┴─────┴──────╯ + + Custom Tables +16 to 25 +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 594│ 505│ +╰─────────┴─────┴──────╯ + + Custom Tables +26 to 35 +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 476│ 491│ +╰─────────┴─────┴──────╯ + + Custom Tables +36 to 45 +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 489│ 548│ +╰─────────┴─────┴──────╯ + + Custom Tables +46 to 55 +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 526│ 649│ +╰─────────┴─────┴──────╯ + + Custom Tables +56 to 65 +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 516│ 731│ +╰─────────┴─────┴──────╯ + + Custom Tables +66 or older +╭─────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├─────────┼─────┼──────┤ +│Age group│ 531│ 943│ +╰─────────┴─────┴──────╯ + + Custom Tables +Male +╭───────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├────────────┤ +│ │ Count │ +├───────────────────────┼────────────┤ +│Age group 15 or younger│ 0│ +│ 16 to 25 │ 594│ +│ 26 to 35 │ 476│ +│ 36 to 45 │ 489│ +│ 46 to 55 │ 526│ +│ 56 to 65 │ 516│ +│ 66 or older │ 531│ +╰───────────────────────┴────────────╯ + + Custom Tables +Female +╭───────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├────────────┤ +│ │ Count │ +├───────────────────────┼────────────┤ +│Age group 15 or younger│ 0│ +│ 16 to 25 │ 505│ +│ 26 to 35 │ 491│ +│ 36 to 45 │ 548│ +│ 46 to 55 │ 649│ +│ 56 to 65 │ 731│ +│ 66 or older │ 943│ +╰───────────────────────┴────────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES missing values]) +AT_DATA([ctables.sps], +[[DATA LIST LIST NOTABLE/x y. +BEGIN DATA. +1 1 +1 2 +1 3 +1 4 +1 5 +1 . +2 1 +2 2 +2 3 +2 4 +2 5 +2 . +3 1 +3 2 +3 3 +3 4 +3 5 +3 . +4 1 +4 2 +4 3 +4 4 +4 5 +4 . +5 1 +5 2 +5 3 +5 4 +5 5 +5 . +. 1 +. 2 +. 3 +. 4 +. 5 +. . +END DATA. +MISSING VALUES x (1, 2) y (2, 3). +VARIABLE LEVEL ALL (NOMINAL). + +CTABLES /TABLE x[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, + TOTALS[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, VALIDN, TOTALN]] + /CATEGORIES VARIABLES=ALL TOTAL=YES. +CTABLES /TABLE x[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, + TOTALS[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, VALIDN, TOTALN]] + /CATEGORIES VARIABLES=ALL TOTAL=YES MISSING=INCLUDE. +CTABLES /TABLE x BY y[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, + TOTALS[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, VALIDN, TOTALN]] + /CATEGORIES VARIABLES=ALL TOTAL=YES + /SLABELS POSITION=ROW. +CTABLES /TABLE x BY y[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, + TOTALS[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, VALIDN, TOTALN]] + /CATEGORIES VARIABLES=ALL TOTAL=YES MISSING=INCLUDE + /SLABELS POSITION=ROW. +CTABLES /TABLE x BY y[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, + TOTALS[COUNT, COLPCT, COLPCT.VALIDN, COLPCT.TOTALN, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, VALIDN, TOTALN]] + /CATEGORIES VARIABLES=x [1, 2, 3, 4] TOTAL=YES + /CATEGORIES VARIABLES=y [1, 3, 4, 5] TOTAL=YES + /SLABELS POSITION=ROW. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=120], [0], [dnl + Custom Tables +╭───────┬─────┬────────┬────────────────┬────────────────┬───────┬───────╮ +│ │Count│Column %│Column Valid N %│Column Total N %│Valid N│Total N│ +├───────┼─────┼────────┼────────────────┼────────────────┼───────┼───────┤ +│x 3.00 │ 6│ 33.3%│ 33.3%│ 16.7%│ │ │ +│ 4.00 │ 6│ 33.3%│ 33.3%│ 16.7%│ │ │ +│ 5.00 │ 6│ 33.3%│ 33.3%│ 16.7%│ │ │ +│ Total│ 18│ 100.0%│ 100.0%│ 100.0%│ 18│ 36│ +╰───────┴─────┴────────┴────────────────┴────────────────┴───────┴───────╯ +dnl Note that Column Total N % doesn't add up to 100 because missing +dnl values are included in the total but not shown as a category and this +dnl is expected behavior. + + Custom Tables +╭───────┬─────┬────────┬────────────────┬────────────────┬───────┬───────╮ +│ │Count│Column %│Column Valid N %│Column Total N %│Valid N│Total N│ +├───────┼─────┼────────┼────────────────┼────────────────┼───────┼───────┤ +│x 1.00 │ 6│ 20.0%│ .0%│ 16.7%│ │ │ +│ 2.00 │ 6│ 20.0%│ .0%│ 16.7%│ │ │ +│ 3.00 │ 6│ 20.0%│ 33.3%│ 16.7%│ │ │ +│ 4.00 │ 6│ 20.0%│ 33.3%│ 16.7%│ │ │ +│ 5.00 │ 6│ 20.0%│ 33.3%│ 16.7%│ │ │ +│ Total│ 30│ 100.0%│ 100.0%│ 100.0%│ 18│ 36│ +╰───────┴─────┴────────┴────────────────┴────────────────┴───────┴───────╯ +dnl Note that Column Total N % doesn't add up to 100 because system-missing +dnl values are included in the total but not shown as a category and this +dnl is expected behavior. + + Custom Tables +╭────────────────────────┬───────────────────────────╮ +│ │ y │ +│ ├──────┬──────┬──────┬──────┤ +│ │ 1.00 │ 4.00 │ 5.00 │ Total│ +├────────────────────────┼──────┼──────┼──────┼──────┤ +│x 3.00 Count │ 1│ 1│ 1│ 3│ +│ Column % │ 33.3%│ 33.3%│ 33.3%│ .│ +│ Column Valid N %│ 33.3%│ 33.3%│ 33.3%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 33.3%│ 33.3%│ 33.3%│100.0%│ +│ Row Valid N % │ 33.3%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ 3│ +│ Total N │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┤ +│ 4.00 Count │ 1│ 1│ 1│ 3│ +│ Column % │ 33.3%│ 33.3%│ 33.3%│ .│ +│ Column Valid N %│ 33.3%│ 33.3%│ 33.3%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 33.3%│ 33.3%│ 33.3%│100.0%│ +│ Row Valid N % │ 33.3%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ 3│ +│ Total N │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┤ +│ 5.00 Count │ 1│ 1│ 1│ 3│ +│ Column % │ 33.3%│ 33.3%│ 33.3%│ .│ +│ Column Valid N %│ 33.3%│ 33.3%│ 33.3%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 33.3%│ 33.3%│ 33.3%│100.0%│ +│ Row Valid N % │ 33.3%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ 3│ +│ Total N │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┤ +│ Total Count │ 3│ 3│ 3│ 9│ +│ Column % │100.0%│100.0%│100.0%│ .│ +│ Column Valid N %│100.0%│100.0%│100.0%│ .│ +│ Column Total N %│100.0%│100.0%│100.0%│ .│ +│ Row % │ .│ .│ .│ .│ +│ Row Valid N % │ .│ .│ .│ .│ +│ Row Total N % │ .│ .│ .│ .│ +│ Valid N │ 3│ 3│ 3│ 9│ +│ Total N │ 6│ 6│ 6│ 36│ +╰────────────────────────┴──────┴──────┴──────┴──────╯ + + Custom Tables +╭────────────────────────┬─────────────────────────────────────────╮ +│ │ y │ +│ ├──────┬──────┬──────┬──────┬──────┬──────┤ +│ │ 1.00 │ 2.00 │ 3.00 │ 4.00 │ 5.00 │ Total│ +├────────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│x 1.00 Count │ 1│ 1│ 1│ 1│ 1│ 5│ +│ Column % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Column Valid N %│ .0%│ .│ .│ .0%│ .0%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│100.0%│ +│ Row Valid N % │ .│ .│ .│ .│ .│ .│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ │ 0│ +│ Total N │ │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│ 2.00 Count │ 1│ 1│ 1│ 1│ 1│ 5│ +│ Column % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Column Valid N %│ .0%│ .│ .│ .0%│ .0%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│100.0%│ +│ Row Valid N % │ .│ .│ .│ .│ .│ .│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ │ 0│ +│ Total N │ │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│ 3.00 Count │ 1│ 1│ 1│ 1│ 1│ 5│ +│ Column % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Column Valid N %│ 33.3%│ .│ .│ 33.3%│ 33.3%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│100.0%│ +│ Row Valid N % │ 33.3%│ .0%│ .0%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ │ 3│ +│ Total N │ │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│ 4.00 Count │ 1│ 1│ 1│ 1│ 1│ 5│ +│ Column % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Column Valid N %│ 33.3%│ .│ .│ 33.3%│ 33.3%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│100.0%│ +│ Row Valid N % │ 33.3%│ .0%│ .0%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ │ 3│ +│ Total N │ │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│ 5.00 Count │ 1│ 1│ 1│ 1│ 1│ 5│ +│ Column % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Column Valid N %│ 33.3%│ .│ .│ 33.3%│ 33.3%│ .│ +│ Column Total N %│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│ .│ +│ Row % │ 20.0%│ 20.0%│ 20.0%│ 20.0%│ 20.0%│100.0%│ +│ Row Valid N % │ 33.3%│ .0%│ .0%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ │ 3│ +│ Total N │ │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┼──────┤ +│ Total Count │ 5│ 5│ 5│ 5│ 5│ 25│ +│ Column % │100.0%│100.0%│100.0%│100.0%│100.0%│ .│ +│ Column Valid N %│100.0%│ .│ .│100.0%│100.0%│ .│ +│ Column Total N %│100.0%│100.0%│100.0%│100.0%│100.0%│ .│ +│ Row % │ .│ .│ .│ .│ .│ .│ +│ Row Valid N % │ .│ .│ .│ .│ .│ .│ +│ Row Total N % │ .│ .│ .│ .│ .│ .│ +│ Valid N │ 3│ 0│ 0│ 3│ 3│ 9│ +│ Total N │ 6│ 6│ 6│ 6│ 6│ 36│ +╰────────────────────────┴──────┴──────┴──────┴──────┴──────┴──────╯ + + Custom Tables +╭────────────────────────┬──────────────────────────────────╮ +│ │ y │ +│ ├──────┬──────┬──────┬──────┬──────┤ +│ │ 1.00 │ 3.00 │ 4.00 │ 5.00 │ Total│ +├────────────────────────┼──────┼──────┼──────┼──────┼──────┤ +│x 1.00 Count │ 1│ 1│ 1│ 1│ 4│ +│ Column % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│ .│ +│ Column Valid N %│ .0%│ .│ .0%│ .0%│ .│ +│ Column Total N %│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Row % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│100.0%│ +│ Row Valid N % │ .│ .│ .│ .│ .│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ 0│ +│ Total N │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┤ +│ 2.00 Count │ 1│ 1│ 1│ 1│ 4│ +│ Column % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│ .│ +│ Column Valid N %│ .0%│ .│ .0%│ .0%│ .│ +│ Column Total N %│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Row % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│100.0%│ +│ Row Valid N % │ .│ .│ .│ .│ .│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ 0│ +│ Total N │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┤ +│ 3.00 Count │ 1│ 1│ 1│ 1│ 4│ +│ Column % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│ .│ +│ Column Valid N %│ 50.0%│ .│ 50.0%│ 50.0%│ .│ +│ Column Total N %│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Row % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│100.0%│ +│ Row Valid N % │ 33.3%│ .0%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ 3│ +│ Total N │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┤ +│ 4.00 Count │ 1│ 1│ 1│ 1│ 4│ +│ Column % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│ .│ +│ Column Valid N %│ 50.0%│ .│ 50.0%│ 50.0%│ .│ +│ Column Total N %│ 20.0%│ 20.0%│ 20.0%│ 20.0%│ .│ +│ Row % │ 25.0%│ 25.0%│ 25.0%│ 25.0%│100.0%│ +│ Row Valid N % │ 33.3%│ .0%│ 33.3%│ 33.3%│100.0%│ +│ Row Total N % │ 16.7%│ 16.7%│ 16.7%│ 16.7%│100.0%│ +│ Valid N │ │ │ │ │ 3│ +│ Total N │ │ │ │ │ 6│ +│ ╶──────────────────────┼──────┼──────┼──────┼──────┼──────┤ +│ Total Count │ 4│ 4│ 4│ 4│ 16│ +│ Column % │100.0%│100.0%│100.0%│100.0%│ .│ +│ Column Valid N %│100.0%│ .│100.0%│100.0%│ .│ +│ Column Total N %│100.0%│100.0%│100.0%│100.0%│ .│ +│ Row % │ .│ .│ .│ .│ .│ +│ Row Valid N % │ .│ .│ .│ .│ .│ +│ Row Total N % │ .│ .│ .│ .│ .│ +│ Valid N │ 2│ 0│ 2│ 2│ 6│ +│ Total N │ 5│ 5│ 5│ 5│ 30│ +╰────────────────────────┴──────┴──────┴──────┴──────┴──────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES SMISSING=LISTWISE]) +AT_KEYWORDS([SMISSING LISTWISE]) +AT_DATA([ctables.sps], +[[DATA LIST LIST NOTABLE/x y z. +BEGIN DATA. +1 . 40 +1 10 50 +1 20 60 +1 . . +1 30 . +END DATA. +VARIABLE LEVEL x (NOMINAL). + +CTABLES /TABLE (y + z) > x. +CTABLES /SMISSING LISTWISE /TABLE (y + z) > x. + +* The following doesn't come out as listwise because the tables are +separate, not linked by an > operator. +CTABLES /SMISSING LISTWISE /TABLE (y > x) + (z > x). +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=120], [0], [dnl + Custom Tables +╭────────┬─────╮ +│ │ Mean│ +├────────┼─────┤ +│y x 1.00│20.00│ +├────────┼─────┤ +│z x 1.00│50.00│ +╰────────┴─────╯ + + Custom Tables +╭────────┬─────╮ +│ │ Mean│ +├────────┼─────┤ +│y x 1.00│15.00│ +├────────┼─────┤ +│z x 1.00│55.00│ +╰────────┴─────╯ + + Custom Tables +╭────────┬─────╮ +│ │ Mean│ +├────────┼─────┤ +│y x 1.00│20.00│ +├────────┼─────┤ +│z x 1.00│50.00│ +╰────────┴─────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES VLABELS]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /VLABELS VARIABLES=qns3a qnd5a DISPLAY=DEFAULT /TABLE qnd5a BY qns3a. +CTABLES /VLABELS VARIABLES=qns3a qnd5a DISPLAY=NAME /TABLE qnd5a BY qns3a. +CTABLES /VLABELS VARIABLES=qns3a qnd5a DISPLAY=LABEL /TABLE qnd5a BY qns3a. +CTABLES /VLABELS VARIABLES=qns3a qnd5a DISPLAY=BOTH /TABLE qnd5a BY qns3a. +CTABLES /VLABELS VARIABLES=qns3a qnd5a DISPLAY=NONE /TABLE qnd5a BY qns3a. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode], [0], [dnl + Custom Tables +╭────────────────────────────────────────────────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├────────────────────────────────────────────────────────────────┼─────┼──────┤ +│D5a. What would you say is your primary Cuban │ 13│ 7│ +│ethnic background? Mexican │ 175│ 136│ +│ Spanish │ 20│ 28│ +│ South American │ 21│ 13│ +│ Central American │ 27│ 25│ +│ Puerto Rican, OR │ 37│ 41│ +│ Something else │ 35│ 33│ +│ Multiple - cannot │ 2│ 5│ +│ choose one │ │ │ +╰────────────────────────────────────────────────────────────────┴─────┴──────╯ + + Custom Tables +╭──────────────────────────────────┬────────────╮ +│ │ QNS3A │ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├──────────────────────────────────┼─────┼──────┤ +│QND5A Cuban │ 13│ 7│ +│ Mexican │ 175│ 136│ +│ Spanish │ 20│ 28│ +│ South American │ 21│ 13│ +│ Central American │ 27│ 25│ +│ Puerto Rican, OR │ 37│ 41│ +│ Something else │ 35│ 33│ +│ Multiple - cannot choose one│ 2│ 5│ +╰──────────────────────────────────┴─────┴──────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────────┬────────────╮ +│ │S3a. GENDER:│ +│ ├─────┬──────┤ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├────────────────────────────────────────────────────────────────┼─────┼──────┤ +│D5a. What would you say is your primary Cuban │ 13│ 7│ +│ethnic background? Mexican │ 175│ 136│ +│ Spanish │ 20│ 28│ +│ South American │ 21│ 13│ +│ Central American │ 27│ 25│ +│ Puerto Rican, OR │ 37│ 41│ +│ Something else │ 35│ 33│ +│ Multiple - cannot │ 2│ 5│ +│ choose one │ │ │ +╰────────────────────────────────────────────────────────────────┴─────┴──────╯ + + Custom Tables +╭────────────────────────────────────────────────────────────┬────────────────╮ +│ │ QNS3A S3a. │ +│ │ GENDER: │ +│ ├───────┬────────┤ +│ │ Male │ Female │ +│ ├───────┼────────┤ +│ │ Count │ Count │ +├────────────────────────────────────────────────────────────┼───────┼────────┤ +│QND5A D5a. What would you say is your Cuban │ 13│ 7│ +│primary ethnic background? Mexican │ 175│ 136│ +│ Spanish │ 20│ 28│ +│ South American │ 21│ 13│ +│ Central American │ 27│ 25│ +│ Puerto Rican, OR │ 37│ 41│ +│ Something else │ 35│ 33│ +│ Multiple - cannot │ 2│ 5│ +│ choose one │ │ │ +╰────────────────────────────────────────────────────────────┴───────┴────────╯ + + Custom Tables +╭────────────────────────────┬─────┬──────╮ +│ │ Male│Female│ +│ ├─────┼──────┤ +│ │Count│ Count│ +├────────────────────────────┼─────┼──────┤ +│Cuban │ 13│ 7│ +│Mexican │ 175│ 136│ +│Spanish │ 20│ 28│ +│South American │ 21│ 13│ +│Central American │ 27│ 25│ +│Puerto Rican, OR │ 37│ 41│ +│Something else │ 35│ 33│ +│Multiple - cannot choose one│ 2│ 5│ +╰────────────────────────────┴─────┴──────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES FORMAT EMPTY]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /FORMAT EMPTY=ZERO /TABLE qnd5a BY qnd5. +CTABLES /FORMAT EMPTY=BLANK /TABLE qnd5a BY qnd5. +CTABLES /FORMAT EMPTY='n/a' /TABLE qnd5a BY qnd5. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode], [0], [dnl + Custom Tables +╭─────────────────────────────────────────────┬───────────────────────────────╮ +│ │ D5. ETHNICITY: Are you of │ +│ │ Hispanic or Latino origin or │ +│ │ descent? │ +│ ├───────────────┬───────────────┤ +│ │ Yes │ No │ +│ ├───────────────┼───────────────┤ +│ │ Count │ Count │ +├─────────────────────────────────────────────┼───────────────┼───────────────┤ +│D5a. What would you say is Cuban │ 20│ 0│ +│your primary ethnic Mexican │ 311│ 0│ +│background? Spanish │ 48│ 0│ +│ South American │ 34│ 0│ +│ Central American│ 52│ 0│ +│ Puerto Rican, OR│ 78│ 0│ +│ Something else │ 68│ 0│ +│ Multiple - │ 7│ 0│ +│ cannot choose │ │ │ +│ one │ │ │ +╰─────────────────────────────────────────────┴───────────────┴───────────────╯ + + Custom Tables +╭─────────────────────────────────────────────┬───────────────────────────────╮ +│ │ D5. ETHNICITY: Are you of │ +│ │ Hispanic or Latino origin or │ +│ │ descent? │ +│ ├───────────────┬───────────────┤ +│ │ Yes │ No │ +│ ├───────────────┼───────────────┤ +│ │ Count │ Count │ +├─────────────────────────────────────────────┼───────────────┼───────────────┤ +│D5a. What would you say is Cuban │ 20│ │ +│your primary ethnic Mexican │ 311│ │ +│background? Spanish │ 48│ │ +│ South American │ 34│ │ +│ Central American│ 52│ │ +│ Puerto Rican, OR│ 78│ │ +│ Something else │ 68│ │ +│ Multiple - │ 7│ │ +│ cannot choose │ │ │ +│ one │ │ │ +╰─────────────────────────────────────────────┴───────────────┴───────────────╯ + + Custom Tables +╭─────────────────────────────────────────────┬───────────────────────────────╮ +│ │ D5. ETHNICITY: Are you of │ +│ │ Hispanic or Latino origin or │ +│ │ descent? │ +│ ├───────────────┬───────────────┤ +│ │ Yes │ No │ +│ ├───────────────┼───────────────┤ +│ │ Count │ Count │ +├─────────────────────────────────────────────┼───────────────┼───────────────┤ +│D5a. What would you say is Cuban │ 20│n/a │ +│your primary ethnic Mexican │ 311│n/a │ +│background? Spanish │ 48│n/a │ +│ South American │ 34│n/a │ +│ Central American│ 52│n/a │ +│ Puerto Rican, OR│ 78│n/a │ +│ Something else │ 68│n/a │ +│ Multiple - │ 7│n/a │ +│ cannot choose │ │ │ +│ one │ │ │ +╰─────────────────────────────────────────────┴───────────────┴───────────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES FORMAT MISSING]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /FORMAT MISSING='(no data)' /TABLE qnd5a[COLPCT] BY qnd5. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode], [0], [dnl + Custom Tables +╭─────────────────────────────────────────────┬───────────────────────────────╮ +│ │ D5. ETHNICITY: Are you of │ +│ │ Hispanic or Latino origin or │ +│ │ descent? │ +│ ├───────────────┬───────────────┤ +│ │ Yes │ No │ +│ ├───────────────┼───────────────┤ +│ │ Column % │ Column % │ +├─────────────────────────────────────────────┼───────────────┼───────────────┤ +│D5a. What would you say is Cuban │ 3.2%│(no data) │ +│your primary ethnic Mexican │ 50.3%│(no data) │ +│background? Spanish │ 7.8%│(no data) │ +│ South American │ 5.5%│(no data) │ +│ Central American│ 8.4%│(no data) │ +│ Puerto Rican, OR│ 12.6%│(no data) │ +│ Something else │ 11.0%│(no data) │ +│ Multiple - │ 1.1%│(no data) │ +│ cannot choose │ │ │ +│ one │ │ │ +╰─────────────────────────────────────────────┴───────────────┴───────────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES HIDESMALLCOUNTS]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /TABLE qn38[c][COUNT, COLPCT]. +CTABLES /HIDESMALLCOUNTS /TABLE qn38[c][COUNT, COLPCT]. +CTABLES /HIDESMALLCOUNTS COUNT=10 /TABLE qn38[c][COUNT, COLPCT]. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode], [0], [dnl + Custom Tables +╭──────────────────────────────────────────────────────────────┬─────┬────────╮ +│ │Count│Column %│ +├──────────────────────────────────────────────────────────────┼─────┼────────┤ +│38. How many drinks did you have on that Less than one│ 7│ .5%│ +│occasion? 1 │ 491│ 34.9%│ +│ 2 │ 462│ 32.9%│ +│ 3 │ 229│ 16.3%│ +│ 4 │ 82│ 5.8%│ +│ 5 │ 56│ 4.0%│ +│ 6 │ 32│ 2.3%│ +│ 7 │ 9│ .6%│ +│ 8 │ 8│ .6%│ +│ 9 │ 4│ .3%│ +│ 10 │ 6│ .4%│ +│ 11 │ 2│ .1%│ +│ 12 │ 5│ .4%│ +│ 14 │ 1│ .1%│ +│ 15 │ 1│ .1%│ +│ 18 │ 1│ .1%│ +│ 20 │ 4│ .3%│ +│ 25 │ 1│ .1%│ +│ 30 │ 3│ .2%│ +│ 60 │ 1│ .1%│ +│ 99+ │ 0│ .0%│ +╰──────────────────────────────────────────────────────────────┴─────┴────────╯ + + Custom Tables +╭──────────────────────────────────────────────────────────────┬─────┬────────╮ +│ │Count│Column %│ +├──────────────────────────────────────────────────────────────┼─────┼────────┤ +│38. How many drinks did you have on that Less than one│ 7│ .5%│ +│occasion? 1 │ 491│ 34.9%│ +│ 2 │ 462│ 32.9%│ +│ 3 │ 229│ 16.3%│ +│ 4 │ 82│ 5.8%│ +│ 5 │ 56│ 4.0%│ +│ 6 │ 32│ 2.3%│ +│ 7 │ 9│ .6%│ +│ 8 │ 8│ .6%│ +│ 9 │<5 │ .3%│ +│ 10 │ 6│ .4%│ +│ 11 │<5 │ .1%│ +│ 12 │ 5│ .4%│ +│ 14 │<5 │ .1%│ +│ 15 │<5 │ .1%│ +│ 18 │<5 │ .1%│ +│ 20 │<5 │ .3%│ +│ 25 │<5 │ .1%│ +│ 30 │<5 │ .2%│ +│ 60 │<5 │ .1%│ +│ 99+ │<5 │ .0%│ +╰──────────────────────────────────────────────────────────────┴─────┴────────╯ + + Custom Tables +╭──────────────────────────────────────────────────────────────┬─────┬────────╮ +│ │Count│Column %│ +├──────────────────────────────────────────────────────────────┼─────┼────────┤ +│38. How many drinks did you have on that Less than one│<10 │ .5%│ +│occasion? 1 │ 491│ 34.9%│ +│ 2 │ 462│ 32.9%│ +│ 3 │ 229│ 16.3%│ +│ 4 │ 82│ 5.8%│ +│ 5 │ 56│ 4.0%│ +│ 6 │ 32│ 2.3%│ +│ 7 │<10 │ .6%│ +│ 8 │<10 │ .6%│ +│ 9 │<10 │ .3%│ +│ 10 │<10 │ .4%│ +│ 11 │<10 │ .1%│ +│ 12 │<10 │ .4%│ +│ 14 │<10 │ .1%│ +│ 15 │<10 │ .1%│ +│ 18 │<10 │ .1%│ +│ 20 │<10 │ .3%│ +│ 25 │<10 │ .1%│ +│ 30 │<10 │ .2%│ +│ 60 │<10 │ .1%│ +│ 99+ │<10 │ .0%│ +╰──────────────────────────────────────────────────────────────┴─────┴────────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES FORMAT MINCOLWIDTH MAXCOLWIDTH]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES /FORMAT MINCOLWIDTH=1 MAXCOLWIDTH=2 UNITS=INCHES /TABLE BY qns3a. +]]) +AT_CHECK([pspp ctables.sps -o - -O box=unicode -o pspp.spv], [0], [dnl + Custom Tables +╭────────────╮ +│S3a. GENDER:│ +├─────┬──────┤ +│ Male│Female│ +├─────┼──────┤ +│Count│ Count│ +├─────┼──────┤ +│ 3132│ 3867│ +╰─────┴──────╯ +]) +AT_CHECK([pspp-output get-table-look pspp.spv pspp.stt]) +AT_CHECK([sed 's/ /\n/g' pspp.stt | grep ColumnWidth | sort], [0], [dnl +maximumColumnWidth="192" +minimumColumnWidth="96" +]) +AT_CLEANUP + +AT_SETUP([CTABLES special formats]) +AT_KEYWORDS([NEGPAREN NEQUAL PAREN PCTPAREN]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +COMPUTE x = qnd3 - 4. +CTABLES /TABLE x[MINIMUM NEGPAREN8.1, MINIMUM NEQUAL8.1, MINIMUM PAREN8.1, MINIMUM PCTPAREN8.1, MAXIMUM NEGPAREN8.1, MAXIMUM NEQUAL8.1, MAXIMUM PAREN8.1, MAXIMUM PCTPAREN8.1]. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode], [0], [dnl + Custom Tables +╭─┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────╮ +│ │Minimum│Minimum│Minimum│Minimum│Maximum│Maximum│Maximum│Maximum│ +├─┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┤ +│x│(3.0) │N=-3.0 │(-3.0) │(-3.0%)│8.0 │N=8.0 │(8.0) │(8.0%) │ +╰─┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES TITLES]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES + /VLABELS VARIABLES=qn1 DISPLAY=NONE + /TABLE ((qn1[c][COUNT])) BY qns3a[c] > qnd5 + /TITLES TITLE='How often do you drive?' + CAPTION='Generated )TIME on )DATE' + CORNER=')TABLE'. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode | sed 's/..:..:../HH:MM:SS/ +s&../../..&MM/DD/YY&'], [0], [dnl + How often do you drive? +╭───────────────────────────────────┬─────────────────────────────────────────╮ +│ │ S3a. GENDER: │ +│ ├────────────────────┬────────────────────┤ +│ │ Male │ Female │ +│ ├────────────────────┼────────────────────┤ +│ │ D5. ETHNICITY: Are │ D5. ETHNICITY: Are │ +│ │ you of Hispanic or │ you of Hispanic or │ +│ │ Latino origin or │ Latino origin or │ +│( ( 1. How often do you usually │ descent? │ descent? │ +│drive a car or other motor ├─────────┬──────────┼─────────┬──────────┤ +│vehicle?) ) BY S3a. GENDER: > D5. │ Yes │ No │ Yes │ No │ +│ETHNICITY: Are you of Hispanic or ├─────────┼──────────┼─────────┼──────────┤ +│Latino origin or descent? │ Count │ Count │ Count │ Count │ +├───────────────────────────────────┼─────────┼──────────┼─────────┼──────────┤ +│Every day │ 218│ 2066│ 166│ 2175│ +│Several days a week │ 44│ 391│ 45│ 782│ +│Once a week or less │ 16│ 109│ 12│ 223│ +│Only certain times a year │ 15│ 41│ 11│ 61│ +│Never │ 39│ 150│ 56│ 278│ +╰───────────────────────────────────┴─────────┴──────────┴─────────┴──────────╯ +Generated HH:MM:SS on MM/DD/YY +]) +AT_CLEANUP + +AT_SETUP([CTABLES area definitions]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES + /VLABELS VARIABLES=ALL DISPLAY=NAME + /TABLE qn61 > qn57 BY qnd7a > qn86 + qn64b BY qns3a[TABLE.ID, LAYER.ID, SUBTABLE.ID] + /SLABELS POSITION=ROW + /TABLE qn61 > qn57 BY qnd7a > qn86 + qn64b BY qns3a[ROW.ID, LAYERROW.ID] + /SLABELS POSITION=ROW + /TABLE qn61 > qn57 BY qnd7a > qn86 + qn64b BY qns3a[COL.ID, LAYERCOL.ID] + /SLABELS POSITION=ROW. +]]) +AT_CHECK([pspp ctables.sps --table-look="$builddir"/all-layers.stt -O box=unicode -O width=80], [0], [dnl + Custom Tables +Male +╭─────────────────────────────┬─────────────┬──────╮ +│ │ QND7A │ QN64B│ +│ ├──────┬──────┼───┬──┤ +│ │ Yes │ No │ │ │ +│ ├──────┼──────┤ │ │ +│ │ QN86 │ QN86 │ │ │ +│ ├───┬──┼───┬──┤ │ │ +│ │Yes│No│Yes│No│Yes│No│ +├─────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│QN61 Yes QN57 Yes Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Subtable ID│ 1│ 1│ 2│ 2│ 3│ 3│ +│ ╶───────────────┼───┼──┼───┼──┼───┼──┤ +│ No Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Subtable ID│ 1│ 1│ 2│ 2│ 3│ 3│ +│ ╶────────────────────────┼───┼──┼───┼──┼───┼──┤ +│ No QN57 Yes Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Subtable ID│ 4│ 4│ 5│ 5│ 6│ 6│ +│ ╶───────────────┼───┼──┼───┼──┼───┼──┤ +│ No Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Subtable ID│ 4│ 4│ 5│ 5│ 6│ 6│ +╰─────────────────────────────┴───┴──┴───┴──┴───┴──╯ + + Custom Tables +Female +╭─────────────────────────────┬─────────────┬──────╮ +│ │ QND7A │ QN64B│ +│ ├──────┬──────┼───┬──┤ +│ │ Yes │ No │ │ │ +│ ├──────┼──────┤ │ │ +│ │ QN86 │ QN86 │ │ │ +│ ├───┬──┼───┬──┤ │ │ +│ │Yes│No│Yes│No│Yes│No│ +├─────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│QN61 Yes QN57 Yes Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 3│ 3│ 3│ 3│ 4│ 4│ +│ Subtable ID│ 7│ 7│ 8│ 8│ 9│ 9│ +│ ╶───────────────┼───┼──┼───┼──┼───┼──┤ +│ No Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 3│ 3│ 3│ 3│ 4│ 4│ +│ Subtable ID│ 7│ 7│ 8│ 8│ 9│ 9│ +│ ╶────────────────────────┼───┼──┼───┼──┼───┼──┤ +│ No QN57 Yes Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 3│ 3│ 3│ 3│ 4│ 4│ +│ Subtable ID│ 10│10│ 11│11│ 12│12│ +│ ╶───────────────┼───┼──┼───┼──┼───┼──┤ +│ No Table ID │ 1│ 1│ 1│ 1│ 2│ 2│ +│ Layer ID │ 3│ 3│ 3│ 3│ 4│ 4│ +│ Subtable ID│ 10│10│ 11│11│ 12│12│ +╰─────────────────────────────┴───┴──┴───┴──┴───┴──╯ + + Custom Tables +Male +╭──────────────────────────────┬─────────────┬──────╮ +│ │ QND7A │ QN64B│ +│ ├──────┬──────┼───┬──┤ +│ │ Yes │ No │ │ │ +│ ├──────┼──────┤ │ │ +│ │ QN86 │ QN86 │ │ │ +│ ├───┬──┼───┬──┤ │ │ +│ │Yes│No│Yes│No│Yes│No│ +├──────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│QN61 Yes QN57 Yes Row ID │ 1│ 1│ 2│ 2│ 3│ 3│ +│ Layer Row ID│ 1│ 1│ 1│ 1│ 2│ 2│ +│ ╶────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Row ID │ 4│ 4│ 5│ 5│ 6│ 6│ +│ Layer Row ID│ 3│ 3│ 3│ 3│ 4│ 4│ +│ ╶─────────────────────────┼───┼──┼───┼──┼───┼──┤ +│ No QN57 Yes Row ID │ 7│ 7│ 8│ 8│ 9│ 9│ +│ Layer Row ID│ 5│ 5│ 5│ 5│ 6│ 6│ +│ ╶────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Row ID │ 10│10│ 11│11│ 12│12│ +│ Layer Row ID│ 7│ 7│ 7│ 7│ 8│ 8│ +╰──────────────────────────────┴───┴──┴───┴──┴───┴──╯ + + Custom Tables +Female +╭──────────────────────────────┬─────────────┬──────╮ +│ │ QND7A │ QN64B│ +│ ├──────┬──────┼───┬──┤ +│ │ Yes │ No │ │ │ +│ ├──────┼──────┤ │ │ +│ │ QN86 │ QN86 │ │ │ +│ ├───┬──┼───┬──┤ │ │ +│ │Yes│No│Yes│No│Yes│No│ +├──────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│QN61 Yes QN57 Yes Row ID │ 13│13│ 14│14│ 15│15│ +│ Layer Row ID│ 9│ 9│ 9│ 9│ 10│10│ +│ ╶────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Row ID │ 16│16│ 17│17│ 18│18│ +│ Layer Row ID│ 11│11│ 11│11│ 12│12│ +│ ╶─────────────────────────┼───┼──┼───┼──┼───┼──┤ +│ No QN57 Yes Row ID │ 19│19│ 20│20│ 21│21│ +│ Layer Row ID│ 13│13│ 13│13│ 14│14│ +│ ╶────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Row ID │ 22│22│ 23│23│ 24│24│ +│ Layer Row ID│ 15│15│ 15│15│ 16│16│ +╰──────────────────────────────┴───┴──┴───┴──┴───┴──╯ + + Custom Tables +Male +╭─────────────────────────────────┬─────────────┬──────╮ +│ │ QND7A │ QN64B│ +│ ├──────┬──────┼───┬──┤ +│ │ Yes │ No │ │ │ +│ ├──────┼──────┤ │ │ +│ │ QN86 │ QN86 │ │ │ +│ ├───┬──┼───┬──┤ │ │ +│ │Yes│No│Yes│No│Yes│No│ +├─────────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│QN61 Yes QN57 Yes Column ID │ 1│ 2│ 3│ 4│ 5│ 6│ +│ Layer Column ID│ 1│ 2│ 3│ 4│ 5│ 6│ +│ ╶───────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Column ID │ 1│ 2│ 3│ 4│ 5│ 6│ +│ Layer Column ID│ 1│ 2│ 3│ 4│ 5│ 6│ +│ ╶────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│ No QN57 Yes Column ID │ 7│ 8│ 9│10│ 11│12│ +│ Layer Column ID│ 1│ 2│ 3│ 4│ 5│ 6│ +│ ╶───────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Column ID │ 7│ 8│ 9│10│ 11│12│ +│ Layer Column ID│ 1│ 2│ 3│ 4│ 5│ 6│ +╰─────────────────────────────────┴───┴──┴───┴──┴───┴──╯ + + Custom Tables +Female +╭─────────────────────────────────┬─────────────┬──────╮ +│ │ QND7A │ QN64B│ +│ ├──────┬──────┼───┬──┤ +│ │ Yes │ No │ │ │ +│ ├──────┼──────┤ │ │ +│ │ QN86 │ QN86 │ │ │ +│ ├───┬──┼───┬──┤ │ │ +│ │Yes│No│Yes│No│Yes│No│ +├─────────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│QN61 Yes QN57 Yes Column ID │ 13│14│ 15│16│ 17│18│ +│ Layer Column ID│ 7│ 8│ 9│10│ 11│12│ +│ ╶───────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Column ID │ 13│14│ 15│16│ 17│18│ +│ Layer Column ID│ 7│ 8│ 9│10│ 11│12│ +│ ╶────────────────────────────┼───┼──┼───┼──┼───┼──┤ +│ No QN57 Yes Column ID │ 19│20│ 21│22│ 23│24│ +│ Layer Column ID│ 7│ 8│ 9│10│ 11│12│ +│ ╶───────────────────┼───┼──┼───┼──┼───┼──┤ +│ No Column ID │ 19│20│ 21│22│ 23│24│ +│ Layer Column ID│ 7│ 8│ 9│10│ 11│12│ +╰─────────────────────────────────┴───┴──┴───┴──┴───┴──╯ +]) +AT_CLEANUP + +AT_SETUP([CTABLES categorical summary functions]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +CTABLES + /TABLE region BY qnd5a[COUNT, ROWPCT, ROWPCT.VALIDN, ROWPCT.TOTALN, TOTAL[COUNT, VALIDN, TOTALN]] + /CATEGORIES VARIABLES=qnd5a TOTAL=YES MISSING=INCLUDE + /SLABELS POSITION=ROW. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=120], [0], [dnl + Custom Tables +╭─────────────────┬────────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ │ D5a. What would you say is your primary ethnic background? │ +│ ├─────┬───────┬───────┬──────────┬──────────┬─────────┬──────────┬──────────────┬──────┬───────┬─────┤ +│ │ │ │ │ │ │ │ │ Multiple - │ │ │ │ +│ │ │ │ │ South │ Central │ Puerto │ Something│ cannot choose│ Don't│ │ │ +│ │Cuban│Mexican│Spanish│ American │ American │Rican, OR│ else │ one │ know │Refused│Total│ +├─────────────────┼─────┼───────┼───────┼──────────┼──────────┼─────────┼──────────┼──────────────┼──────┼───────┼─────┤ +│Region NE Count │ 6│ 8│ 8│ 11│ 7│ 39│ 23│ 2│ 0│ 1│ 105│ +│ Row % │ 5.7%│ 7.6%│ 7.6%│ 10.5%│ 6.7%│ 37.1%│ 21.9%│ 1.9%│ .0%│ 1.0%│ │ +│ Row │ 5.8%│ 7.7%│ 7.7%│ 10.6%│ 6.7%│ 37.5%│ 22.1%│ 1.9%│ .0%│ .0%│ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Row │ .4%│ .6%│ .6%│ .8%│ .5%│ 2.8%│ 1.6%│ .1%│ .0%│ .1%│ │ +│ Total N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ 104│ +│ Total N│ │ │ │ │ │ │ │ │ │ │ 1409│ +│ ╶──────────┼─────┼───────┼───────┼──────────┼──────────┼─────────┼──────────┼──────────────┼──────┼───────┼─────┤ +│ MW Count │ 3│ 24│ 1│ 4│ 5│ 9│ 6│ 0│ 0│ 1│ 53│ +│ Row % │ 5.7%│ 45.3%│ 1.9%│ 7.5%│ 9.4%│ 17.0%│ 11.3%│ .0%│ .0%│ 1.9%│ │ +│ Row │ 5.8%│ 46.2%│ 1.9%│ 7.7%│ 9.6%│ 17.3%│ 11.5%│ .0%│ .0%│ .0%│ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Row │ .2%│ 1.5%│ .1%│ .2%│ .3%│ .5%│ .4%│ .0%│ .0%│ .1%│ │ +│ Total N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ 52│ +│ Total N│ │ │ │ │ │ │ │ │ │ │ 1654│ +│ ╶──────────┼─────┼───────┼───────┼──────────┼──────────┼─────────┼──────────┼──────────────┼──────┼───────┼─────┤ +│ S Count │ 10│ 113│ 11│ 14│ 25│ 23│ 20│ 2│ 3│ 2│ 223│ +│ Row % │ 4.5%│ 50.7%│ 4.9%│ 6.3%│ 11.2%│ 10.3%│ 9.0%│ .9%│ 1.3%│ .9%│ │ +│ Row │ 4.6%│ 51.8%│ 5.0%│ 6.4%│ 11.5%│ 10.6%│ 9.2%│ .9%│ .0%│ .0%│ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Row │ .4%│ 4.7%│ .5%│ .6%│ 1.0%│ 1.0%│ .8%│ .1%│ .1%│ .1%│ │ +│ Total N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ 218│ +│ Total N│ │ │ │ │ │ │ │ │ │ │ 2390│ +│ ╶──────────┼─────┼───────┼───────┼──────────┼──────────┼─────────┼──────────┼──────────────┼──────┼───────┼─────┤ +│ W Count │ 1│ 166│ 28│ 5│ 15│ 7│ 19│ 3│ 0│ 1│ 245│ +│ Row % │ .4%│ 67.8%│ 11.4%│ 2.0%│ 6.1%│ 2.9%│ 7.8%│ 1.2%│ .0%│ .4%│ │ +│ Row │ .4%│ 68.0%│ 11.5%│ 2.0%│ 6.1%│ 2.9%│ 7.8%│ 1.2%│ .0%│ .0%│ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Row │ .1%│ 10.7%│ 1.8%│ .3%│ 1.0%│ .5%│ 1.2%│ .2%│ .0%│ .1%│ │ +│ Total N│ │ │ │ │ │ │ │ │ │ │ │ +│ % │ │ │ │ │ │ │ │ │ │ │ │ +│ Valid N│ │ │ │ │ │ │ │ │ │ │ 244│ +│ Total N│ │ │ │ │ │ │ │ │ │ │ 1546│ +╰─────────────────┴─────┴───────┴───────┴──────────┴──────────┴─────────┴──────────┴──────────────┴──────┴───────┴─────╯ +]) +AT_CLEANUP + + +AT_SETUP([CTABLES scale summary functions]) +AT_CHECK([ln $top_srcdir/examples/nhtsa.sav . || cp $top_srcdir/examples/nhtsa.sav .]) +AT_DATA([ctables.sps], +[[GET 'nhtsa.sav'. +SET TVAR=NAME. +SPLIT FILE BY REGION. +FREQUENCIES qn19a /STATISTICS=ALL /FORMAT NOTABLE. +SPLIT FILE OFF. +CTABLES + /VLABELS VARIABLE=qn19a DISPLAY=NAME /*XXX NONE yields an assertion failure + /TABLE region BY qn19a[COUNT, MAXIMUM, MEAN, MINIMUM, MISSING, MODE] + /CATEGORIES VARIABLES=qn19a TOTAL=YES MISSING=INCLUDE + /SLABELS POSITION=ROW. +]]) +AT_CHECK([pspp ctables.sps -O box=unicode -O width=120], [0], []) +AT_CLEANUP +