Renamed badly abbreviated names in crand.h.

Moved coroutine.h from algo subfolder to stc.
Updated coroutine.h and docs.

20 files changed, 105 insertions, 55 deletions

diff --git a/misc/examples/algorithms/forfilter.c b/misc/examples/algorithms/forfilter.c
index f3c008b3..644b8459 100644
--- a/misc/examples/algorithms/forfilter.c
+++ b/misc/examples/algorithms/forfilter.c
@@ -3,8 +3,7 @@
 #include <stc/cstr.h>
 #define i_implement
 #include <stc/csview.h>
-#include <stc/algo/filter.h>
-#include <stc/algo/crange.h>
+#include <stc/algorithm.h>
 
 #define i_type IVec
 #define i_key int
diff --git a/misc/examples/algorithms/forloops.c b/misc/examples/algorithms/forloops.c
index 72d745f8..300eee18 100644
--- a/misc/examples/algorithms/forloops.c
+++ b/misc/examples/algorithms/forloops.c
@@ -1,5 +1,5 @@
 #include <stdio.h>
-#include <stc/algo/filter.h>
+#include <stc/algorithm.h>
 
 #define i_type IVec
 #define i_key int
diff --git a/misc/examples/algorithms/random.c b/misc/examples/algorithms/random.c
index b7c0f277..ccd0711d 100644
--- a/misc/examples/algorithms/random.c
+++ b/misc/examples/algorithms/random.c
@@ -4,11 +4,11 @@
 
 int main(void)
 {
-    const int N = 1000000000;
+    long long N = 1000000000;
     const uint64_t seed = (uint64_t)time(NULL), range = 1000000;
     crand_t rng = crand_init(seed);
 
-    int64_t sum;
+    long long sum;
     clock_t diff, before;
 
     printf("Compare speed of full and unbiased ranged random numbers...\n");
@@ -18,19 +18,19 @@ int main(void)
         sum += (uint32_t)crand_u64(&rng);
     }
     diff = clock() - before;
-    printf("full range\t\t: %f secs, %d, avg: %f\n",
-           (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
+    printf("full range\t\t: %f secs, %lld, avg: %f\n",
+           (double)diff/CLOCKS_PER_SEC, N, (double)(sum/N));
 
-    crand_unif_t dist1 = crand_unif_init(0, range);
+    crand_uniform_t dist1 = crand_uniform_init(0, range);
     rng = crand_init(seed);
     sum = 0;
     before = clock();
     c_forrange (N)  {
-        sum += crand_unif(&rng, &dist1); // unbiased
+        sum += crand_uniform(&rng, &dist1); // unbiased
     }
     diff = clock() - before;
-    printf("unbiased 0-%" PRIu64 "\t: %f secs, %d, avg: %f\n",
-            range, (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
+    printf("unbiased 0-%" PRIu64 "\t: %f secs, %lld, avg: %f\n",
+            range, (double)diff/CLOCKS_PER_SEC, N, (double)(sum/N));
 
     sum = 0;
     rng = crand_init(seed);
@@ -39,7 +39,7 @@ int main(void)
         sum += (int64_t)(crand_u64(&rng) % (range + 1)); // biased
     }
     diff = clock() - before;
-    printf("biased 0-%" PRIu64 "  \t: %f secs, %d, avg: %f\n",
-            range, (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
+    printf("biased 0-%" PRIu64 "  \t: %f secs, %lld, avg: %f\n",
+            range, (double)diff/CLOCKS_PER_SEC, N, (double)(sum/N));
 
 }
diff --git a/misc/examples/bitsets/prime.c b/misc/examples/bitsets/prime.c
index cb3b095a..e5764d83 100644
--- a/misc/examples/bitsets/prime.c
+++ b/misc/examples/bitsets/prime.c
@@ -2,23 +2,23 @@
 #include <math.h>
 #include <time.h>
 #include <stc/cbits.h>
-#include <stc/algo/filter.h>
-#include <stc/algo/crange.h>
+#include <stc/algorithm.h>
 
+typedef long long llong;
 
-cbits sieveOfEratosthenes(int64_t n)
+cbits sieveOfEratosthenes(llong n)
 {
     cbits bits = cbits_with_size(n/2 + 1, true);
-    int64_t q = (int64_t)sqrt((double) n) + 1;
-    for (int64_t i = 3; i < q; i += 2) {
-        int64_t j = i;
+    llong q = (llong)sqrt((double) n) + 1;
+    for (llong i = 3; i < q; i += 2) {
+        llong j = i;
         for (; j < n; j += 2) {
             if (cbits_test(&bits, j>>1)) {
                 i = j;
                 break;
             }
         }
-        for (int64_t j = i*i; j < n; j += i*2)
+        for (llong j = i*i; j < n; j += i*2)
             cbits_reset(&bits, j>>1);
     }
     return bits;
@@ -26,12 +26,12 @@ cbits sieveOfEratosthenes(int64_t n)
 
 int main(void)
 {
-    int n = 1000000000;
-    printf("Computing prime numbers up to %d\n", n);
+    llong n = 100000000;
+    printf("Computing prime numbers up to %lld\n", n);
 
     clock_t t = clock();
     cbits primes = sieveOfEratosthenes(n + 1);
-    int np = (int)cbits_count(&primes);
+    llong np = cbits_count(&primes);
     t = clock() - t;
 
     puts("Show all the primes in the range [2, 1000):");
@@ -50,7 +50,7 @@ int main(void)
         printf("%lld ", *i.ref);
         if (c_flt_getcount(i) % 10 == 0) puts("");
     }
-    printf("Number of primes: %d, time: %.2f\n\n", np, (double)t/CLOCKS_PER_SEC);
+    printf("Number of primes: %lld, time: %.2f\n\n", np, (double)t/CLOCKS_PER_SEC);
 
     cbits_drop(&primes);
 }
diff --git a/misc/examples/coroutines/cointerleave.c b/misc/examples/coroutines/cointerleave.c
index 599ceaab..ea0d4dac 100644
--- a/misc/examples/coroutines/cointerleave.c
+++ b/misc/examples/coroutines/cointerleave.c
@@ -1,6 +1,6 @@
 // https://www.youtube.com/watch?v=8sEe-4tig_A
 #include <stdio.h>
-#include <stc/calgo.h>
+#include <stc/coroutine.h>
 #define i_type IVec
 #define i_key int
 #include <stc/cvec.h>
diff --git a/misc/examples/coroutines/coread.c b/misc/examples/coroutines/coread.c
index a13f6be5..56248108 100644
--- a/misc/examples/coroutines/coread.c
+++ b/misc/examples/coroutines/coread.c
@@ -1,6 +1,6 @@
 #define i_implement
 #include <stc/cstr.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 #include <errno.h>
 
 // Read file line by line using coroutines:
diff --git a/misc/examples/coroutines/coroutines.c b/misc/examples/coroutines/coroutines.c
index b8dfaa13..de0fcda5 100644
--- a/misc/examples/coroutines/coroutines.c
+++ b/misc/examples/coroutines/coroutines.c
@@ -1,4 +1,4 @@
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 #include <stdio.h>
 #include <stdint.h>
 
diff --git a/misc/examples/coroutines/cotasks1.c b/misc/examples/coroutines/cotasks1.c
index c87582f1..27999ccf 100644
--- a/misc/examples/coroutines/cotasks1.c
+++ b/misc/examples/coroutines/cotasks1.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #define i_static
 #include <stc/cstr.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 
 struct next_value { 
     int val;
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index 293583bc..9ca69bda 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #define i_static
 #include <stc/cstr.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 
 cco_task_struct (next_value,
     int val;
@@ -45,7 +45,7 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
         while (true)
         {
             // await for next CCO_YIELD in next_value()
-            cco_await_task(&p->next, rt, CCO_YIELD);
+            cco_task_await(&p->next, rt, CCO_YIELD);
             cstr_printf(&p->str, "item %d", p->next.val);
             print_time();
             printf("produced %s\n", cstr_str(&p->str));
@@ -71,7 +71,7 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
         for (c->i = 1; c->i <= c->n; ++c->i)
         {
             printf("consume #%d\n", c->i);
-            cco_await_task(&c->produce, rt, CCO_YIELD);
+            cco_task_await(&c->produce, rt, CCO_YIELD);
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
@@ -87,12 +87,12 @@ int main(void)
 {
     struct consume_items consume = {
         .n=5,
-        .cco_fn=consume_items,
-        .produce={.cco_fn=produce_items, .next={.cco_fn=next_value}},
+        .cco_func=consume_items,
+        .produce={.cco_func=produce_items, .next={.cco_func=next_value}},
     };
     int count = 0;
 
-    cco_block_task(&consume)
+    cco_task_block_on(&consume)
     {
         ++count;
         //cco_sleep(0.001);
diff --git a/misc/examples/coroutines/dining_philosophers.c b/misc/examples/coroutines/dining_philosophers.c
index a5063a42..abe09204 100644
--- a/misc/examples/coroutines/dining_philosophers.c
+++ b/misc/examples/coroutines/dining_philosophers.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <time.h>
 #include <stc/crand.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
  
 // Define the number of philosophers and forks
 enum {
diff --git a/misc/examples/coroutines/generator.c b/misc/examples/coroutines/generator.c
index a15f9ba5..f9e59fea 100644
--- a/misc/examples/coroutines/generator.c
+++ b/misc/examples/coroutines/generator.c
@@ -1,7 +1,7 @@
 // https://quuxplusone.github.io/blog/2019/03/06/pythagorean-triples/
 
-#include <stc/algo/coroutine.h>
 #include <stdio.h>
+#include <stc/coroutine.h>
 
 typedef struct {
     int size;
diff --git a/misc/examples/coroutines/scheduler.c b/misc/examples/coroutines/scheduler.c
index 38defd0f..78461277 100644
--- a/misc/examples/coroutines/scheduler.c
+++ b/misc/examples/coroutines/scheduler.c
@@ -1,6 +1,6 @@
 // https://www.youtube.com/watch?v=8sEe-4tig_A
 #include <stdio.h>
-#include <stc/calgo.h>
+#include <stc/coroutine.h>
 
 struct Task {
     int (*fn)(struct Task*);
diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
index 9f2fcc1e..fe1ca7c3 100644
--- a/misc/examples/coroutines/triples.c
+++ b/misc/examples/coroutines/triples.c
@@ -1,7 +1,7 @@
 // https://quuxplusone.github.io/blog/2019/03/06/pythagorean-triples/
 
-#include <stc/algo/coroutine.h>
 #include <stdio.h>
+#include <stc/coroutine.h>
 
 int gcd(int a, int b) {
     while (b) {
diff --git a/misc/examples/linkedlists/list.c b/misc/examples/linkedlists/list.c
index ad8bebb8..09591314 100644
--- a/misc/examples/linkedlists/list.c
+++ b/misc/examples/linkedlists/list.c
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <time.h>
-#include <stc/algo/filter.h>
+#include <stc/algorithm.h>
 #include <stc/crand.h>
 
 #define i_type DList
diff --git a/misc/examples/make.sh b/misc/examples/make.sh
index 7135ffdf..b362f275 100755
--- a/misc/examples/make.sh
+++ b/misc/examples/make.sh
@@ -38,8 +38,8 @@ fi
 
 if [ $run = 0 ] ; then
     for i in */*.c ; do
-        #out=$(basename $i .c).exe
-        out=$(dirname $i)/$(basename $i .c).exe
+        out=$(basename $i .c).exe
+        #out=$(dirname $i)/$(basename $i .c).exe
         echo $comp -I../../include $i $clibs $oflag$out
         $comp -I../../include $i $clibs $oflag$out
     done
@@ -47,8 +47,8 @@ else
     for i in */*.c ; do
         echo $comp -I../../include $i $clibs
         $comp -I../../include $i $clibs
-        #out=$(basename $i .c).exe
-        out=$(dirname $i)/$(basename $i .c).exe
+        out=$(basename $i .c).exe
+        #out=$(dirname $i)/$(basename $i .c).exe
         if [ -f $out ]; then ./$out; fi
     done
 fi
diff --git a/misc/examples/priorityqueues/priority.c b/misc/examples/priorityqueues/priority.c
index bf2e188a..18684e73 100644
--- a/misc/examples/priorityqueues/priority.c
+++ b/misc/examples/priorityqueues/priority.c
@@ -11,21 +11,21 @@
 int main(void) {
     intptr_t N = 10000000;
     crand_t rng = crand_init((uint64_t)time(NULL));
-    crand_unif_t dist = crand_unif_init(0, N * 10);
+    crand_uniform_t dist = crand_uniform_init(0, N * 10);
 
     cpque_i heap = {0};
 
     // Push ten million random numbers to priority queue
     printf("Push %" c_ZI " numbers\n", N);
     c_forrange (N)
-        cpque_i_push(&heap, crand_unif(&rng, &dist));
+        cpque_i_push(&heap, crand_uniform(&rng, &dist));
 
     // push some negative numbers too.
     c_forlist (i, int, {-231, -32, -873, -4, -343})
         cpque_i_push(&heap, *i.ref);
 
     c_forrange (N)
-        cpque_i_push(&heap, crand_unif(&rng, &dist));
+        cpque_i_push(&heap, crand_uniform(&rng, &dist));
 
     puts("Extract the hundred smallest.");
     c_forrange (100) {
diff --git a/misc/examples/queues/new_queue.c b/misc/examples/queues/new_queue.c
index f3592df6..3904c50c 100644
--- a/misc/examples/queues/new_queue.c
+++ b/misc/examples/queues/new_queue.c
@@ -23,19 +23,19 @@ int point_cmp(const Point* a, const Point* b) {
 int main(void) {
     int n = 50000000;
     crand_t rng = crand_init((uint64_t)time(NULL));
-    crand_unif_t dist = crand_unif_init(0, n);
+    crand_uniform_t dist = crand_uniform_init(0, n);
 
     IQ Q = {0};
 
     // Push 50'000'000 random numbers onto the queue.
     c_forrange (n)
-        IQ_push(&Q, (int)crand_unif(&rng, &dist));
+        IQ_push(&Q, (int)crand_uniform(&rng, &dist));
 
     // Push or pop on the queue 50 million times
     printf("befor: size %" c_ZI ", capacity %" c_ZI "\n", IQ_size(&Q), IQ_capacity(&Q));
     
     c_forrange (n) {
-        int r = (int)crand_unif(&rng, &dist);
+        int r = (int)crand_uniform(&rng, &dist);
         if (r & 3)
             IQ_push(&Q, r);
         else
diff --git a/misc/examples/queues/queue.c b/misc/examples/queues/queue.c
index 56b5beb9..913524cc 100644
--- a/misc/examples/queues/queue.c
+++ b/misc/examples/queues/queue.c
@@ -7,20 +7,20 @@
 
 int main(void) {
     int n = 100000000;
-    crand_unif_t dist;
+    crand_uniform_t dist;
     crand_t rng = crand_init(1234);
-    dist = crand_unif_init(0, n);
+    dist = crand_uniform_init(0, n);
 
     cqueue_i queue = {0};
 
     // Push ten million random numbers onto the queue.
     c_forrange (n)
-        cqueue_i_push(&queue, (int)crand_unif(&rng, &dist));
+        cqueue_i_push(&queue, (int)crand_uniform(&rng, &dist));
 
     // Push or pop on the queue ten million times
     printf("%d\n", n);
     c_forrange (n) { // forrange uses initial n only.
-        int r = (int)crand_unif(&rng, &dist);
+        int r = (int)crand_uniform(&rng, &dist);
         if (r & 1)
             ++n, cqueue_i_push(&queue, r);
         else
diff --git a/misc/examples/sortedmaps/gauss2.c b/misc/examples/sortedmaps/gauss2.c
index 1ab8ade5..02ce4bc5 100644
--- a/misc/examples/sortedmaps/gauss2.c
+++ b/misc/examples/sortedmaps/gauss2.c
@@ -21,14 +21,14 @@ int main(void)
     printf("Mean %f, StdDev %f\n", Mean, StdDev);
 
     // Setup random engine with normal distribution.
-    crand_norm_t dist = crand_norm_init(Mean, StdDev);
+    crand_normal_t dist = crand_normal_init(Mean, StdDev);
 
     // Create and init histogram map with defered destruct
     csmap_int hist = {0};
     cstr bar = {0};
 
     c_forrange (N) {
-        int index = (int)round(crand_norm(&rng, &dist));
+        int index = (int)round(crand_normal(&rng, &dist));
         csmap_int_insert(&hist, index, 0).ref->second += 1;
     }
 
diff --git a/misc/examples/spans/mdspan.c b/misc/examples/spans/mdspan.c
new file mode 100644
index 00000000..4427299c
--- /dev/null
+++ b/misc/examples/spans/mdspan.c
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <stc/cspan.h>
+#include <stdlib.h>
+
+using_cspan3(DSpan, double);
+
+int main(void) {
+    const int nx=5, ny=4, nz=3;
+    double* data = c_new_n(double, nx*ny*nz);
+
+    printf("\nMultidim span ms[5, 4, 3], fortran ordered");
+    DSpan3 ms = cspan_md_order('F', data, nx, ny, nz); // Fortran, not 'C'
+
+    int idx = 0;
+    c_forrange (i, ms.shape[0])
+        c_forrange (j, ms.shape[1])
+            c_forrange (k, ms.shape[2]) 
+                *cspan_at(&ms, i, j, k) = ++idx;
+
+    cspan_transpose(&ms);
+
+    printf(", transposed:\n\n");
+    c_forrange (i, ms.shape[0]) {
+        c_forrange (j, ms.shape[1]) {
+            c_forrange (k, ms.shape[2])
+                printf(" %3g", *cspan_at(&ms, i, j, k));
+            puts("");
+        }
+        puts("");
+    }
+
+    DSpan2 sub;
+
+    puts("Slicing:");
+    printf("\nms[0, :, :] ");
+    sub = cspan_slice(DSpan2, &ms, {0}, {c_ALL}, {c_ALL});
+    c_foreach (i, DSpan2, sub) printf(" %g", *i.ref);
+    puts("");
+
+    printf("\nms[:, 0, :] ");
+    sub = cspan_slice(DSpan2, &ms, {c_ALL}, {0}, {c_ALL});
+    c_foreach (i, DSpan2, sub) printf(" %g", *i.ref);
+    puts("");
+
+    sub = cspan_slice(DSpan2, &ms, {c_ALL}, {c_ALL}, {0});
+    printf("\nms[:, :, 0] ");
+    c_foreach (i, DSpan2, sub) printf(" %g", *i.ref);
+    puts("");
+
+    free(data);
+}