view release on metacpan or  search on metacpan

src/fast-recs-collate/aggregators.c  view on Meta::CPAN

}

static void min_init(void *_c, void *_d)
{
    struct min_data *d = _d;
    d->min = INFINITY;
}

static void min_add(void *_c, void *_d, char *ch_data[], double num_data[])
{
    struct min_data *d = _d;
    if(!isnan(num_data[0]) && num_data[0] < d->min)
        d->min = num_data[0];
}

static void min_dump(void *_c, void *_d)
{
    struct min_data *d = _d;
    printf("%g", d->min);
}

/*
 * Sum
 */

struct sum_data
{
    double sum;
};

static bool sum_parse_args(void **config_data, char *config_str, int *num_fields, char **fields)
{
    return use_one_field(config_str, num_fields, fields);
}

static void sum_init(void *_c, void *_d)
{
    struct sum_data *d = _d;
    d->sum = 0;
}

static void sum_add(void *_c, void *_d, char *ch_data[], double num_data[])
{
    struct sum_data *d = _d;
    if(!isnan(num_data[0]))
        d->sum += num_data[0];
}

static void sum_dump(void *_c, void *_d)
{
    struct sum_data *d = _d;
    printf("%g", d->sum);
}

/*
 * Perc
 */

struct perc_config_data
{
    double percentile;
};

struct perc_data
{
    int values_len;
    int values_size;
    double *values;
};

static bool perc_parse_args(void **config_data, char *config_str, int *num_fields, char **fields)
{
    if(*config_str)
    {
        char *comma = strchr(config_str, ',');
        if(!comma) return false;
        *comma++ = '\0';

        struct perc_config_data *c = *config_data = malloc(sizeof(struct perc_config_data));
        char *endp;
        c->percentile = strtod(config_str, &endp);
        if(endp == config_str) return false;  /* failed to parse into number */

        fields[0] = comma;
        *num_fields = 1;

        return true;
    }
    else
    {
        return false;
    }
}

static void perc_init(void *_c, void *_d)
{
    struct perc_data *d = _d;
    d->values_len = 0;
    d->values_size = 64;
    d->values = malloc(sizeof(*d->values) * d->values_size);
}

static void perc_add(void *_c, void *_d, char *ch_data[], double num_data[])
{
    struct perc_data *d = _d;
    if(!isnan(num_data[0]))
    {
        RESIZE_ARRAY_IF_NECESSARY(d->values, d->values_size, d->values_len+1);
        d->values[d->values_len++] = num_data[0];
    }
}

static int cmp_dbl(const void *s1, const void *s2)
{
    double d1 = *(double*)s1;
    double d2 = *(double*)s2;
    if(d1 < d2) return -1;
    else if(d1 > d2) return 1;
    else return 0;
}

static void perc_dump(void *_c, void *_d)
{
    struct perc_config_data *c = _c;
    struct perc_data *d = _d;
    qsort(d->values, d->values_len, sizeof(*d->values), cmp_dbl);
    double perc = d->values[(int)floor((c->percentile / 100) * d->values_len)];
    printf("%g", perc);
}

static void perc_free(void *_c, void *_d)
{
    struct concat_data *d = _d;
    free(d->concat_buf);
}

/*
 * Mode
 */

static hash_val_t str_hash_func(const void *_k)
{
    char *k = (char*)_k;
    return hashlittle(k, strlen(k), 0);
}

struct table_entry
{
    double count;
};

struct mode_data
{
    hash_t *hash_table;

    /* this is just a pool of nodes */
    int nodes_len, nodes_size;
    hnode_t *nodes;

    /* this is just a pool of table_entry objs */
    int entries_len, entries_size;
    struct table_entry *entries;
};

static bool mode_parse_args(void **config_data, char *config_str, int *num_fields, char **fields)
{
    return use_one_field(config_str, num_fields, fields);
}

static void mode_init(void *_c, void *_d)
{
    struct mode_data *d = _d;
    d->hash_table = hash_create(HASHCOUNT_T_MAX, NULL, str_hash_func);
    d->nodes_size = d->entries_size = 32;
    d->nodes_len = d->entries_len = 0;
    d->nodes = malloc(sizeof(*d->nodes) * d->nodes_size);
    d->entries = malloc(sizeof(*d->entries) * d->entries_size);
}

static void mode_add(void *_c, void *_d, char *ch_data[], double num_data[])
{
    struct mode_data *d = _d;
    hnode_t *node = hash_lookup(d->hash_table, ch_data[0]);
    if(node == NULL)
    {
        RESIZE_ARRAY_IF_NECESSARY(d->nodes, d->nodes_size, d->nodes_len+1);
        RESIZE_ARRAY_IF_NECESSARY(d->entries, d->entries_size, d->entries_len+1);

src/fast-recs-collate/aggregators.c  view on Meta::CPAN

/*
 * Correlation
 */

struct corr_data
{
    struct cov_data cov_data;
    struct var_data var_data1;
    struct var_data var_data2;
};

static bool corr_parse_args(void **config_data, char *config_str, int *num_fields, char **fields)
{
    return use_two_fields(config_str, num_fields, fields);
}

static void corr_init(void *_c, void *_d)
{
    struct corr_data *d = _d;
    cov_init(_c, &d->cov_data);
    var_init(_c, &d->var_data1);
    var_init(_c, &d->var_data2);
}

static void corr_add(void *_c, void *_d, char *ch_data[], double num_data[])
{
    struct corr_data *d = _d;
    cov_add(NULL, &d->cov_data, ch_data, num_data);
    var_add(NULL, &d->var_data1, ch_data, num_data);
    var_add(NULL, &d->var_data2, ch_data+1, num_data+1);
}

static void corr_dump(void *_c, void *_d)
{
    struct corr_data *d = _d;
    double cov = cov_val(&d->cov_data);
    double var1 = var_val(&d->var_data1);
    double var2 = var_val(&d->var_data2);
    double corr = cov / sqrt(var1 * var2);
    printf("%g", corr);
}

struct aggregator aggregators[] = {
    {"average", "avg", sizeof(struct avg_data),
      avg_parse_args, avg_init, avg_add, avg_dump, NULL},
    {"concatenate", "concat", sizeof(struct concat_data),
      concat_parse_args, concat_init, concat_add, concat_dump, concat_free},
    {"count", "ct", sizeof(struct count_data),
      count_parse_args, count_init, count_add, count_dump, NULL},
    {"correlation", "corr", sizeof(struct corr_data),
      corr_parse_args, corr_init, corr_add, corr_dump, NULL},
    {"covariance", "cov", sizeof(struct cov_data),
      cov_parse_args, cov_init, cov_add, cov_dump, NULL},
    {"maximum", "max", sizeof(struct max_data),
      max_parse_args, max_init, max_add, max_dump, NULL},
    {"minimum", "min", sizeof(struct min_data),
      min_parse_args, min_init, min_add, min_dump, NULL},
    {"mode", "mode", sizeof(struct mode_data),
      mode_parse_args, mode_init, mode_add, mode_dump, mode_free},
    {"percentile", "perc", sizeof(struct perc_data),
      perc_parse_args, perc_init, perc_add, perc_dump, perc_free},
    {"sum", "sum", sizeof(struct sum_data),
      sum_parse_args, sum_init, sum_add, sum_dump, NULL},
    {"variance", "var", sizeof(struct var_data),
      var_parse_args, var_init, var_add, var_dump, NULL},
    {NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL}
};