automate tuple creation

[forkit]

On Thursday, 20 January 2022 at 04:38:39 UTC, forkit wrote:
>

all done ;-)

// ---

module test;

import std.stdio : writeln;
import std.range : iota, isForwardRange, hasSlicing, hasLength, 
isInfinite;
import std.array : array, Appender;
import std.random : Random, unpredictableSeed, dice, choice;
import std.algorithm : map, uniq, canFind;

@safe:

Random rnd;

static this()
{
   rnd = Random(unpredictableSeed);
}

void main()
{
     int recordsNeeded = 2;
     int boolValuesNeeded = 3;

     uint[] uniqueIDs;
     makeUniqueIDs(uniqueIDs, recordsNeeded);

     uint[][] tuples;
     createBoolMatrix(tuples, recordsNeeded, boolValuesNeeded);

     uint[][uint][] records = CreateTupleDictionary(uniqueIDs, 
tuples);
     processRecords(records);

}

auto CreateTupleDictionary(ref uint[] ids, ref uint[][] tuples)
{
     uint[][uint][] records;

     foreach(i, id; ids)
         records ~= [ ids[i] : tuples[i] ];

     return records.dup;
}

void processRecords(T)(const ref T t) if (isForwardRange!T && 
hasSlicing!T && hasLength!T && !isInfinite!T)
{
     t.writeln;

     // output from above should look like this:
     // [[999583661:[1, 1, 0]], [999273256:[1, 1, 1]]]

     // hoping to explore parallel here too...
}

void createBoolMatrix(ref uint[][] m, size_t numberOfTuples, 
size_t numberOfBoolsInTuple)
{
     m = iota(numberOfTuples)
             .map!(i => iota(numberOfBoolsInTuple)
             .map!(numberOfBoolsInTuple => cast(uint) 
rnd.dice(0.6, 1.4))
             .array).array;
}


void makeUniqueIDs(ref uint[] arr, size_t sz)
{
     arr.reserve(sz);

     // id needs to be 9 digits, and needs to start with 999
     int[] a = iota(999_000_000, 1_000_000_000).array;
     // above will contain 1_000_000 records that we can choose 
from.

     int i = 0;
     uint x;
     while(i != sz)
     {
        x = cast(uint)a.choice(rnd);

        // ensure every id added is unique.
        if (!arr.canFind(x))
        {
            arr ~= x;
            i++;
        }
     }
}

// ---