ssize_t min, max;
size_t total[2];
/* This allows limited frequency analysis. */
- size_t buckets;
- size_t step_bits;
+ unsigned buckets, step_bits;
size_t counts[1 /* [buckets] */ ];
};
-struct tally *tally_new(size_t buckets)
+struct tally *tally_new(unsigned buckets)
{
struct tally *tally;
return NULL;
tally = malloc(sizeof(*tally) + sizeof(tally->counts[0])*buckets);
if (tally) {
- /* SSIZE_MAX isn't portable, so make it one of these types. */
- BUILD_ASSERT(sizeof(tally->min) == sizeof(int)
- || sizeof(tally->min) == sizeof(long)
- || sizeof(tally->min) == sizeof(long long));
- if (sizeof(tally->min) == sizeof(int)) {
- tally->min = INT_MAX;
- tally->max = INT_MIN;
- } else if (sizeof(tally->min) == sizeof(long)) {
- tally->min = LONG_MAX;
- tally->max = LONG_MIN;
- } else if (sizeof(tally->min) == sizeof(long long)) {
- tally->min = (ssize_t)LLONG_MAX;
- tally->max = (ssize_t)LLONG_MIN;
- }
+ tally->max = ((size_t)1 << (SIZET_BITS - 1));
+ tally->min = ~tally->max;
tally->total[0] = tally->total[1] = 0;
/* There is always 1 bucket. */
tally->buckets = buckets+1;
memcpy(tmp->counts, tally->counts,
sizeof(tally->counts[0]) * tmp->buckets);
while ((max_bucket = get_max_bucket(tmp)) >= height)
- renormalize(tmp, tmp->min, tmp->max *= 2);
+ renormalize(tmp, tmp->min, tmp->max * 2);
/* Restore max */
tmp->max = tally->max;
tally = tmp;
free(tmp);
return NULL;
}
+
for (i = 0; i < height; i++) {
- unsigned covered = 0;
- count = (double)tally->counts[i] / largest_bucket * width;
+ unsigned covered = 1;
+ count = (double)tally->counts[i] / largest_bucket * (width-1)+1;
if (i == 0)
covered = snprintf(p, width, "%zi", tally->min);
else if (i == height - 1)
covered = snprintf(p, width, "%zi", tally->max);
- if (covered) {
- if (covered > width)
- covered = width;
- p += covered;
- if (count > covered)
- count -= covered;
- else
- count = 0;
- }
+ else if (i == bucket_of(tally->min, tally->step_bits, 0))
+ *p = '+';
+ else
+ *p = '|';
+
+ if (covered > width)
+ covered = width;
+ p += covered;
+
+ if (count > covered)
+ count -= covered;
+ else
+ count = 0;
+
memset(p, '*', count);
p += count;
*p = '\n';
*
* This allocates a tally structure using malloc(). The greater the value
* of @buckets, the more accurate tally_approx_median() and tally_approx_mode()
- * and tally_graph() will be, but more memory is consumed.
+ * and tally_histogram() will be, but more memory is consumed. If you want
+ * to use tally_histogram(), the optimal bucket value is the same as that
+ * @height argument.
*/
-struct tally *tally_new(size_t buckets);
+struct tally *tally_new(unsigned int buckets);
/**
* tally_add - add a value.
char *graph, *p;
bool trunc;
- plan_tests(100 + 1 + 10 + 1 + 100 + 1 + 10 + 1 + 10 + 2 + 1);
+ plan_tests(100 + 1 + 10 + 1 + 100 + 1 + 10 + 1 + 10 * 2 + 1);
/* Uniform distribution, easy. */
tally = tally_new(100);
/* Check min/max labels. */
if (i == 0)
ok1(strncmp(p, "-5*", 3) == 0);
- if (i == 9)
+ else if (i == 9)
ok1(strncmp(p, "4*", 2) == 0);
+ else if (i == 5)
+ ok1(p[0] == '+'); /* 0 marker */
+ else
+ ok1(p[0] == '|');
p = eol + 1;
}
ok1(!*p);
+ diag("Here's the pretty: %s", graph);
free(graph);
free(tally);