Changeset e0350e0 for doc/theses/mike_brooks_MMath/benchmarks/string/make-corpus.cfa

Timestamp:

Jun 4, 2025, 1:43:34 PM (4 months ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

f858ca5

Parents:

c8bdbaf

Message:

Recent rework of string benchmarks

File:

• doc/theses/mike_brooks_MMath/benchmarks/string/make-corpus.cfa (modified) (4 diffs)

doc/theses/mike_brooks_MMath/benchmarks/string/make-corpus.cfa

@@ -1 @@
-#include <stdlib.hfa>
+#include <stdlib.h>
 #include <math.h>
 #include <limits.h>
 #include <unistd.h>
 #include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include <stdlib.h>
+#include <math.h>
+#include <limits.h>
+#include <unistd.h>
+
+int printing =
+#ifdef VERBOSE
+    1
+#else
+    0
+#endif
+;
+
+#define PRTF(fmt, ...) if (printing) fprintf(stderr, fmt, __VA_ARGS__)
 
 // U(0,1)
 static double U() {
-    return (double)rand() / (double)INT_MAX;
+    return  ((double)rand() + 1) / ((double)RAND_MAX + 2); // avoid 0
 }
 
-// generate random draws from a geometric distribution of the given mean
-// https://math.stackexchange.com/questions/485448/prove-the-way-to-generate-geometrically-distributed-random-numbers
-static double denom;
-static void initialize(int mean) {
-    srand(getpid());
-    double p = 1.0 / (double) mean;
-    denom = log(1-p);
+// parameters for distribution
+static double logn_mu, logn_sigma;
+
+// returns a draw from N(0,1)
+// based on https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform, section Implementation
+static double rand_std_normal() {
+    double u1 = U();
+    double u2 = U();
+    double ret = sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2);
+    PRTF("=== %f %f %f\n", u1, u2, ret);
+    return ret;
 }
-static int nextGeoRand() {
-    // ret = ⌊ln(U)/ln(1−p)⌋ where U ~ U(0, 1)
-    return 1 + (int) (log(U()) / denom);
+
+// Initialize parameters for log-normal
+// Mean and stdev are for the underlying normal distribution
+// Resulting values will be log-normally distributed: X = exp(mu + sigma * Z)
+static void initialize(double locn, double relscale, int seed) {
+    if (seed) srand(seed);
+    else srand(getpid());
+
+    logn_sigma = sqrt(log(1 + pow(relscale, 2)));
+    logn_mu = log(locn-1) - 0.5 * pow(relscale, 2);
+    PRTF("xxx %f %f\n", logn_mu, logn_sigma);
+}
+
+// Generate a log-normally distributed random integer
+// ln(X) ~ N(mu, sigma^2)
+static int nextLognRand() {
+    double z = rand_std_normal();
+    double x = exp(logn_mu + logn_sigma * z);
+    PRTF("---%f %f\n", z, x);
+    return round(x);
 }
 
 // write a randomly generated alphabetic string whose length is adjused from a draw of the above distribution
 static void emit1( int offset, double mcfreq, char mchar ) {
-    int lim = offset + nextGeoRand();
-    // printf("==%d\n", lim);
-    for (i; lim) {
+    int lim = 1 + offset + nextLognRand();
+    PRTF("%d\n", lim);
+    for (int i = 0; i < lim; i++) {
         char emit;
         if (U() < mcfreq) emit = mchar;
-        else emit = 'a' + (rand() % ('z'-'a'));
+        else emit = 'a' + (rand() % ('z'-'a'+1));
         printf("%c", emit);
     }
@@ -36 +74 @@
 }
 
-// usage: ./make-corpus toGen mean [offset=0] [mcfreq=0.0] [mchar='-']
+// usage: ./make-corpus toGen locn [relscale=1.0] [seed=(pid)] [offset=0] [mcfreq=0.0] [mchar='-']
 //
 // Outputs alphabetic (plus magic-char) strings, one per line.
 // toGen: number of strings (lines)
 // 
-// generated length ~  offset + geo(mean)
+// generated length ~  offset + lognormal( ... locn ... relscale ... )
 //                  >= 1
 //
-// offset=0,  mean=1:  constant length 1
-// offset=0,  mean=2:  lengths go like number of coin tosses it takes to get heads
-// offset=0,  mean=6:  lengths go like number of cube die rolls it takes to get :::
-// offset=15, mean=1:  constant length 16
-// offset=15, mean=2:  population's minimum is 16 and mean is 17
+// offset=0,  locn=1:  constant length 1
+// offset=0,  locn=2:  lengths go like current value of $1 cash + $1-bought stock
+// offset=0,  locn=6:  lengths go like current value of $1 cash + $5-bought stock
+// offset=15, locn=1:  constant length 16
+// offset=15, locn=2:  population's minimum is 16 and mean is 17
+//                     i.e. lengths go like current value of $16 cash + $1-bought stock
+//
+// relscale gives the volatility of the stock.  It's relative to the mean.
+// relscale=0.5 means the +-1 SD outcomes (68% case) are between locn/1.5 = locn*0.67 and locn*1.5.
 //
 // Magic Char (mc) does not affect these lengths.  Any mc occurrence replaces an alphabetic char.
@@ -56 +98 @@
 
     int toGen;
-    int mean;
+    double locn;
+    double relscale = 1.0;
+    int seed = 0;
     int offset = 0;
     double mcfreq = 0.0;
     char mchar = '-';
 
-    assert(argc >= 3 && argc <= 6);
+    assert(argc >= 3 && argc <= 8);
     switch(argc) {
+        case 8:
+            assert(strlen(argv[7]) == 1);
+            mchar = argv[7][0];
+        case 7:
+            mcfreq = atof(argv[6]);
+            assert(mcfreq >= 0.0 && mcfreq <= 1.0);
         case 6:
-            assert(strlen(argv[5]) == 0);
-            mchar = argv[5][0];
+            offset = atoi(argv[5]);
+            assert(offset >= 0 && offset < 10000);
         case 5:
-            mcfreq = atof(argv[4]);
-            assert(mcfreq >= 0.0 && mcfreq <= 1.0);
+            seed = atoi(argv[4]);
+            assert(seed > 0);
         case 4:
-            offset = atoi(argv[3]);
-            assert(offset >= 0 && offset < 10000);
+            relscale = atof(argv[3]);
+            assert(relscale > 0);
+            assert(relscale < 10);
         default:
-            mean = atoi(argv[2]);
-            assert(mean > 0);
-            assert(mean < 1000);
+            locn = atof(argv[2]);
+            assert(locn > 0);
+            assert(locn < 1000);
             toGen = atoi(argv[1]);
             assert(toGen > 0);
@@ -81 +132 @@
     }
 
-    initialize(mean);
-    for( i; toGen ) {
+    PRTF("toGen=%d, locn=%f, relscale=%f, seed=%d, offset=%d, mcfreq=%f, mchar='%c'\n", toGen, locn, relscale, seed, offset, mcfreq, mchar);
+
+    initialize(locn, relscale, seed);
+    for( int i = 0; i < toGen; i++ ) {
         emit1(offset, mcfreq, mchar);
     }