You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA. */
/* FIXME: Many possible optimizations. */
#include <stdlib.h>
#include "algorithm.h"
#include "alloc.h"
+#include "case.h"
#include "casefile.h"
#include "command.h"
+#include "dictionary.h"
#include "lexer.h"
#include "error.h"
#include "magic.h"
struct dsc_var
{
struct variable *v; /* Variable to calculate on. */
- char z_name[9]; /* Name for z-score variable. */
+ char z_name[LONG_NAME_LEN + 1]; /* Name for z-score variable. */
double valid, missing; /* Valid, missing counts. */
struct moments *moments; /* Moments. */
double min, max; /* Maximum and mimimum values. */
else if (lex_match_id ("DEFAULT"))
dsc->show_stats |= DEFAULT_STATS;
else
- {
- dsc->show_stats |= 1ul << (match_statistic ());
- if (dsc->show_stats == DSC_NONE)
- dsc->show_stats = DEFAULT_STATS;
- }
+ dsc->show_stats |= 1ul << (match_statistic ());
lex_match (',');
}
if (dsc->show_stats == 0)
if (dict_lookup_var (default_dict, name) != NULL)
return 0;
for (i = 0; i < dsc->var_cnt; i++)
- if (!strcmp (dsc->vars[i].z_name, name))
+ if (!strcasecmp (dsc->vars[i].z_name, name))
return 0;
return 1;
}
generate_z_varname (struct dsc_proc *dsc, char *z_name,
const char *var_name, int *z_cnt)
{
- char name[10];
+ char name[LONG_NAME_LEN + 1];
/* Try a name based on the original variable name. */
name[0] = 'Z';
- strcpy (name + 1, var_name);
- name[8] = '\0';
+ str_copy_trunc (name + 1, sizeof name - 1, var_name);
if (try_name (dsc, name))
{
strcpy (z_name, name);
*/
static int
descriptives_trns_proc (struct trns_header *trns, struct ccase * c,
- int case_num UNUSED)
+ int case_idx UNUSED)
{
struct dsc_trns *t = (struct dsc_trns *) trns;
struct dsc_z_score *z;
assert(t->vars);
for (vars = t->vars; vars < t->vars + t->var_cnt; vars++)
{
- double score = c->data[(*vars)->fv].f;
+ double score = case_num (c, (*vars)->fv);
if ( score == SYSMIS || (!t->include_user_missing
&& is_num_user_missing(score, *vars)) )
{
for (z = t->z_scores; z < t->z_scores + t->z_score_cnt; z++)
{
- double score = c->data[z->src_idx].f;
+ double input = case_num (c, z->src_idx);
+ double *output = &case_data_rw (c, z->dst_idx)->f;
if (z->mean == SYSMIS || z->std_dev == SYSMIS
- || all_sysmis || score == SYSMIS
- || (!t->include_user_missing && is_num_user_missing(score, z->v)))
- c->data[z->dst_idx].f = SYSMIS;
+ || all_sysmis || input == SYSMIS
+ || (!t->include_user_missing && is_num_user_missing(input, z->v)))
+ *output = SYSMIS;
else
- c->data[z->dst_idx].f = (score - z->mean) / z->std_dev;
+ *output = (input - z->mean) / z->std_dev;
}
return -1;
}
{
struct dsc_proc *dsc = dsc_;
struct casereader *reader;
- const struct ccase *c;
+ struct ccase c;
int i;
for (i = 0; i < dsc->var_cnt; i++)
dsc->valid = 0.;
/* First pass to handle most of the work. */
- reader = casefile_get_reader (cf);
- while (casereader_read (reader, &c))
+ for (reader = casefile_get_reader (cf);
+ casereader_read (reader, &c);
+ case_destroy (&c))
{
- double weight = dict_get_case_weight (default_dict, c, &dsc->bad_warn);
+ double weight = dict_get_case_weight (default_dict, &c, &dsc->bad_warn);
if (weight <= 0.0)
- continue;
+ continue;
/* Check for missing values. */
- if (listwise_missing (dsc, c))
+ if (listwise_missing (dsc, &c))
{
dsc->missing_listwise += weight;
if (dsc->missing_type == DSC_LISTWISE)
for (i = 0; i < dsc->var_cnt; i++)
{
struct dsc_var *dv = &dsc->vars[i];
- double x = c->data[dv->v->fv].f;
+ double x = case_num (&c, dv->v->fv);
if (dsc->missing_type != DSC_LISTWISE
&& (x == SYSMIS
}
if (dv->moments != NULL)
- {
- if (dsc->max_moment > MOMENT_MEAN)
- moments_pass_one (dv->moments, x, weight);
- else
- moments_pass_two (dv->moments, x, weight);
- }
+ moments_pass_one (dv->moments, x, weight);
if (x < dv->min)
dv->min = x;
/* Second pass for higher-order moments. */
if (dsc->max_moment > MOMENT_MEAN)
{
- reader = casefile_get_reader (cf);
- while (casereader_read (reader, &c))
+ for (reader = casefile_get_reader (cf);
+ casereader_read (reader, &c);
+ case_destroy (&c))
{
- double weight = dict_get_case_weight (default_dict, c,
+ double weight = dict_get_case_weight (default_dict, &c,
&dsc->bad_warn);
if (weight <= 0.0)
continue;
/* Check for missing values. */
- if (listwise_missing (dsc, c)
+ if (listwise_missing (dsc, &c)
&& dsc->missing_type == DSC_LISTWISE)
continue;
for (i = 0; i < dsc->var_cnt; i++)
{
struct dsc_var *dv = &dsc->vars[i];
- double x = c->data[dv->v->fv].f;
+ double x = case_num (&c, dv->v->fv);
if (dsc->missing_type != DSC_LISTWISE
&& (x == SYSMIS
for (i = 0; i < dsc->var_cnt; i++)
{
struct dsc_var *dv = &dsc->vars[i];
- double x = c->data[dv->v->fv].f;
+ double x = case_num (c, dv->v->fv);
if (x == SYSMIS
|| (!dsc->include_user_missing && is_num_user_missing (x, dv->v)))
int result;
if (dsc->sort_by_stat == DSC_NAME)
- result = strcmp (a->v->name, b->v->name);
+ result = strcasecmp (a->v->name, b->v->name);
else
{
double as = a->stats[dsc->sort_by_stat];