use uint32_t

Author: amorphedstar

README.md

@@ -8,7 +8,9 @@ $n$-sided die with rational probabilities.
 
 The library can be built by running
 
-    $ make all
+```sh
+make all
+```
 
 This command creates the following artifacts in the `build/` directory:
 
@@ -22,7 +24,8 @@ This command creates the following artifacts in the `build/` directory:
 ## Usage
 
 The following code from [examples/example.c](examples/example.c)
-shows how to use ALDR to sample from a distribution with given integer weights.
+shows how to use ALDR to sample from a distribution
+defined by a list of nonnegative integer weights.
 
 ```c
 #include <stdlib.h>

aldr.c

@@ -17,35 +17,37 @@ void aldr_free (struct aldr_s x) {
     free(x.leaves_flat);
 }
 
-struct aldr_s aldr_preprocess(int* a, int n) {
-    // assume k <= 31
-    int m = 0;
-    for (int i = 0; i < n; ++i) {
+struct aldr_s aldr_preprocess(uint32_t* a, uint32_t n) {
+    // this algorithm requires that
+    // 0 < n < (1 << 32) - 1
+    // 0 < sum(a) < (1 << 31) - 1
+    uint32_t m = 0;
+    for (uint32_t i = 0; i < n; ++i) {
         m += a[i];
     }
-    int k = 32 - __builtin_clz(m) - (1 == __builtin_popcount(m));
-    int K = k << 1;                         // depth
-    long long c = (1ll << K) / m;           // amplification factor
-    long long r = (1ll << K) % m;           // reject weight
+    uint32_t k = 32 - __builtin_clz(m-1);
+    uint32_t K = k << 1;                   // depth
+    uint64_t c = (1ll << K) / m;           // amplification factor
+    uint64_t r = (1ll << K) % m;           // reject weight
 
-    int num_leaves = __builtin_popcountll(r);
-    for (int i = 0; i < n; ++i) {
+    uint32_t num_leaves = __builtin_popcountll(r);
+    for (uint32_t i = 0; i < n; ++i) {
         num_leaves += __builtin_popcountll(c * a[i]);
     }
 
-    int *breadths = calloc(K + 1, sizeof(int));
-    int *leaves_flat = calloc(num_leaves, sizeof(int));
+    uint32_t *breadths = calloc(K + 1, sizeof(*breadths));
+    uint32_t *leaves_flat = calloc(num_leaves, sizeof(*leaves_flat));
 
-    int location = 0;
-    for(int j = 0; j <= K; j++) {
-        long long bit = (1ll << (K - j));
+    uint32_t location = 0;
+    for(uint32_t j = 0; j <= K; j++) {
+        uint64_t bit = (1ll << (K - j));
         if (r & bit) {
             leaves_flat[location] = 0;
             ++breadths[j];
             ++location;
         }
-        for (int i = 0; i < n; ++i) {
-            long long Qi = c*a[i];
+        for (uint32_t i = 0; i < n; ++i) {
+            uint64_t Qi = c*a[i];
             if (Qi & bit) {
                 leaves_flat[location] = i + 1;
                 ++breadths[j];
@@ -62,14 +64,14 @@ struct aldr_s aldr_preprocess(int* a, int n) {
         };
 }
 
-int aldr_sample(struct aldr_s* f) {
+uint32_t aldr_sample(struct aldr_s* f) {
     for (;;) {
-        int depth = 0;
-        int location = 0;
-        int val = 0;
+        uint32_t depth = 0;
+        uint32_t location = 0;
+        uint32_t val = 0;
         for (;;) {
             if (val < f->breadths[depth]) {
-                int ans = f->leaves_flat[location + val];
+                uint32_t ans = f->leaves_flat[location + val];
                 if (ans) return ans - 1;
                 else break;
             }

aldr.h

@@ -10,16 +10,18 @@
 #ifndef ALDR_H
 #define ALDR_H
 
+#include <stdint.h>
+
 // flattened ALDR tree
 struct aldr_s {
-    int length_breadths;
-    int length_leaves_flat;
-    int *breadths;
-    int *leaves_flat;
+    uint32_t length_breadths;
+    uint32_t length_leaves_flat;
+    uint32_t *breadths;
+    uint32_t *leaves_flat;
 };
 
 void aldr_free (struct aldr_s x);
-struct aldr_s aldr_preprocess(int* a, int n);
-int aldr_sample(struct aldr_s *x);
+struct aldr_s aldr_preprocess(uint32_t* a, uint32_t n);
+uint32_t aldr_sample(struct aldr_s *x);
 
 #endif

examples/example.c

@@ -13,12 +13,12 @@
 #include "aldr.h"
 
 int main(int argc, char **argv) {
-    int num_samples = 90;
-    int *samples = calloc(num_samples, sizeof(*samples));
+    uint32_t num_samples = 90;
+    uint32_t *samples = calloc(num_samples, sizeof(*samples));
 
-    int distribution[5] = { 1, 1, 2, 3, 2 };
+    uint32_t distribution[5] = { 1, 1, 2, 3, 2 };
     struct aldr_s x = aldr_preprocess(distribution, 5);
-    for (int i = 0; i < num_samples; ++i) {
+    for (uint32_t i = 0; i < num_samples; ++i) {
         samples[i] = aldr_sample(&x);
         printf("%d ", samples[i]);
     }

flip.c

@@ -8,7 +8,6 @@
 */
 
 #include <stdlib.h>
-#include <stdint.h>
 #include <sys/random.h>
 
 #include "flip.h"

sample.c

@@ -17,19 +17,19 @@ int main(int argc, char **argv) {
         printf("usage: %s <num_samples> <distribution>\n", argv[0]);
         exit(0);
     }
-    int num_samples = atoi(argv[1]);
+    uint32_t num_samples = strtoul(argv[1], NULL, 10);
 
     // Parse the distribution.
-    int n = argc - 2;
-    int *a = calloc(n, sizeof(*a));
-    for (int i = 0; i < n; ++i) {
-        a[i] = atoi(argv[i + 2]);
+    uint32_t n = argc - 2;
+    uint32_t *a = calloc(n, sizeof(*a));
+    for (uint32_t i = 0; i < n; ++i) {
+        a[i] = strtoul(argv[i + 2], NULL, 10);
     }
 
     // Obtain the samples.
-    int sample;
+    uint32_t sample;
     struct aldr_s x = aldr_preprocess(a, n);
-    for (int i = 0; i < num_samples; ++i) {
+    for (uint32_t i = 0; i < num_samples; ++i) {
         printf("%d ", aldr_sample(&x));
     }
     printf("\n");