#include "libpspp/str.h"
#include "math/random.h"
#include "output/pivot-table.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
double diff = 0;
for (j = 0; j < m1->size2; ++j)
{
- diff += pow2 (gsl_matrix_get (m1,i,j) - gsl_matrix_get (m2,i,j) );
+ diff += pow2 (gsl_matrix_get (m1,i,j) - gsl_matrix_get (m2,i,j));
}
if (diff > max_diff)
max_diff = diff;
for (j = 0; j < qc->n_vars; j++)
{
const union value *val = case_data (c, qc->vars[j]);
- if ( var_is_value_missing (qc->vars[j], val, qc->exclude))
+ if (var_is_value_missing (qc->vars[j], val) & qc->exclude)
NOT_REACHED ();
dist += pow2 (gsl_matrix_get (kmeans->centers, which, j) - val->f);
for (j = 0; j < qc->n_vars; ++j)
{
const union value *val = case_data (c, qc->vars[j]);
- if ( var_is_value_missing (qc->vars[j], val, qc->exclude))
+ if (var_is_value_missing (qc->vars[j], val) & qc->exclude)
{
missing = true;
break;
for (j = 0; j < qc->n_vars; j++)
{
const union value *val = case_data (c, qc->vars[j]);
- if ( var_is_value_missing (qc->vars[j], val, qc->exclude))
+ if (var_is_value_missing (qc->vars[j], val) & qc->exclude)
continue;
dist += pow2 (gsl_matrix_get (kmeans->centers, i, j) - val->f);
for (j = 0; j < qc->n_vars; j++)
{
const union value *val = case_data (c, qc->vars[j]);
- if ( var_is_value_missing (qc->vars[j], val, qc->exclude))
+ if (var_is_value_missing (qc->vars[j], val) & qc->exclude)
missing = true;
}
}
long *n = gsl_vector_long_ptr (kmeans->num_elements_groups, group);
- *n += qc->wv ? case_data (c, qc->wv)->f : 1.0;
+ *n += qc->wv ? case_num (c, qc->wv) : 1.0;
kmeans->n++;
for (j = 0; j < qc->n_vars; ++j)
{
const union value *val = case_data (c, qc->vars[j]);
- if ( var_is_value_missing (qc->vars[j], val, qc->exclude))
+ if (var_is_value_missing (qc->vars[j], val) & qc->exclude)
continue;
double *x = gsl_matrix_ptr (kmeans->updated_centers, group, j);
- *x += val->f * (qc->wv ? case_data (c, qc->wv)->f : 1.0);
+ *x += val->f * (qc->wv ? case_num (c, qc->wv) : 1.0);
}
}
for (j = 0; j < qc->n_vars; ++j)
{
const union value *val = case_data (c, qc->vars[j]);
- if ( var_is_value_missing (qc->vars[j], val, qc->exclude))
+ if (var_is_value_missing (qc->vars[j], val) & qc->exclude)
continue;
double *x = gsl_matrix_ptr (kmeans->updated_centers, group, j);
}
long *n = gsl_vector_long_ptr (kmeans->num_elements_groups, group);
- *n += qc->wv ? case_data (c, qc->wv)->f : 1.0;
+ *n += qc->wv ? case_num (c, qc->wv) : 1.0;
kmeans->n++;
}
casereader_destroy (cs);
/* A transformation function which juxtaposes the dataset with the
(pre-prepared) dataset containing membership and/or distance
values. */
-static int
+static enum trns_result
save_trans_func (void *aux, struct ccase **c, casenumber x UNUSED)
{
const struct save_trans_data *std = aux;
*c = case_unshare (*c);
if (std->CASE_IDX_MEMBERSHIP >= 0)
- case_data_rw (*c, std->membership)->f = case_data_idx (ca, std->CASE_IDX_MEMBERSHIP)->f;
+ *case_num_rw (*c, std->membership) = case_num_idx (ca, std->CASE_IDX_MEMBERSHIP);
if (std->CASE_IDX_DISTANCE >= 0)
- case_data_rw (*c, std->distance)->f = case_data_idx (ca, std->CASE_IDX_DISTANCE)->f;
+ *case_num_rw (*c, std->distance) = case_num_idx (ca, std->CASE_IDX_DISTANCE);
case_unref (ca);
/* Calculate the membership and distance values. */
struct ccase *outc = case_create (proto);
if (qc->save_values & SAVE_MEMBERSHIP)
- case_data_rw_idx (outc, qc->save_trans_data->CASE_IDX_MEMBERSHIP)->f = cluster + 1;
+ *case_num_rw_idx (outc, qc->save_trans_data->CASE_IDX_MEMBERSHIP) = cluster + 1;
if (qc->save_values & SAVE_DISTANCE)
- case_data_rw_idx (outc, qc->save_trans_data->CASE_IDX_DISTANCE)->f
+ *case_num_rw_idx (outc, qc->save_trans_data->CASE_IDX_DISTANCE)
= sqrt (dist_from_case (kmeans, c, qc, clust));
casewriter_write (qc->save_trans_data->writer, outc);
if (lex_match_id (lexer, "CLUSTERS"))
{
if (lex_force_match (lexer, T_LPAREN) &&
- lex_force_int (lexer))
+ lex_force_int_range (lexer, "CLUSTERS", 1, INT_MAX))
{
qc->ngroups = lex_integer (lexer);
- if (qc->ngroups <= 0)
- {
- lex_error (lexer, _("The number of clusters must be positive"));
- return false;
- }
lex_get (lexer);
if (!lex_force_match (lexer, T_RPAREN))
return false;
else if (lex_match_id (lexer, "CONVERGE"))
{
if (lex_force_match (lexer, T_LPAREN) &&
- lex_force_num (lexer))
+ lex_force_num_range_open (lexer, "CONVERGE", 0, DBL_MAX))
{
qc->epsilon = lex_number (lexer);
- if (qc->epsilon <= 0)
- {
- lex_error (lexer, _("The convergence criterion must be positive"));
- return false;
- }
lex_get (lexer);
if (!lex_force_match (lexer, T_RPAREN))
return false;
else if (lex_match_id (lexer, "MXITER"))
{
if (lex_force_match (lexer, T_LPAREN) &&
- lex_force_int (lexer))
+ lex_force_int_range (lexer, "MXITER", 1, INT_MAX))
{
qc->maxiter = lex_integer (lexer);
- if (qc->maxiter <= 0)
- {
- lex_error (lexer, _("The number of iterations must be positive"));
- return false;
- }
lex_get (lexer);
if (!lex_force_match (lexer, T_RPAREN))
return false;
while (casegrouper_get_next_group (grouper, &group))
{
- if ( qc.missing_type == MISS_LISTWISE )
+ if (qc.missing_type == MISS_LISTWISE)
{
group = casereader_create_filter_missing (group, qc.vars, qc.n_vars,
qc.exclude,
std->distance = dict_create_var_assert (qc.dict, qc.var_distance, 0);
}
- add_transformation (qc.dataset, save_trans_func, save_trans_destroy, std);
+ static const struct trns_class trns_class = {
+ .name = "QUICK CLUSTER",
+ .execute = save_trans_func,
+ .destroy = save_trans_destroy,
+ };
+ add_transformation (qc.dataset, &trns_class, std);
}
free (qc.var_distance);