125 lines
4.3 KiB
C++
125 lines
4.3 KiB
C++
// Generated automatically from src/optional/wren_opt_random.wren. Do not edit.
|
|
static const char* randomModuleSource =
|
|
"foreign class Random {\n"
|
|
" construct new() {\n"
|
|
" seed_()\n"
|
|
" }\n"
|
|
"\n"
|
|
" construct new(seed) {\n"
|
|
" if (seed is Num) {\n"
|
|
" seed_(seed)\n"
|
|
" } else if (seed is Sequence) {\n"
|
|
" if (seed.isEmpty) Fiber.abort(\"Sequence cannot be empty.\")\n"
|
|
"\n"
|
|
" // TODO: Empty sequence.\n"
|
|
" var seeds = []\n"
|
|
" for (element in seed) {\n"
|
|
" if (!(element is Num)) Fiber.abort(\"Sequence elements must all be numbers.\")\n"
|
|
"\n"
|
|
" seeds.add(element)\n"
|
|
" if (seeds.count == 16) break\n"
|
|
" }\n"
|
|
"\n"
|
|
" // Cycle the values to fill in any missing slots.\n"
|
|
" var i = 0\n"
|
|
" while (seeds.count < 16) {\n"
|
|
" seeds.add(seeds[i])\n"
|
|
" i = i + 1\n"
|
|
" }\n"
|
|
"\n"
|
|
" seed_(\n"
|
|
" seeds[0], seeds[1], seeds[2], seeds[3],\n"
|
|
" seeds[4], seeds[5], seeds[6], seeds[7],\n"
|
|
" seeds[8], seeds[9], seeds[10], seeds[11],\n"
|
|
" seeds[12], seeds[13], seeds[14], seeds[15])\n"
|
|
" } else {\n"
|
|
" Fiber.abort(\"Seed must be a number or a sequence of numbers.\")\n"
|
|
" }\n"
|
|
" }\n"
|
|
"\n"
|
|
" foreign seed_()\n"
|
|
" foreign seed_(seed)\n"
|
|
" foreign seed_(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13, n14, n15, n16)\n"
|
|
"\n"
|
|
" foreign float()\n"
|
|
" float(end) { float() * end }\n"
|
|
" float(start, end) { float() * (end - start) + start }\n"
|
|
"\n"
|
|
" foreign int()\n"
|
|
" int(end) { (float() * end).floor }\n"
|
|
" int(start, end) { (float() * (end - start)).floor + start }\n"
|
|
"\n"
|
|
" sample(list) { sample(list, 1)[0] }\n"
|
|
" sample(list, count) {\n"
|
|
" if (count > list.count) Fiber.abort(\"Not enough elements to sample.\")\n"
|
|
"\n"
|
|
" // There at (at least) two simple algorithms for choosing a number of\n"
|
|
" // samples from a list without replacement -- where we don't pick the same\n"
|
|
" // element more than once.\n"
|
|
" //\n"
|
|
" // The first is faster when the number of samples is small relative to the\n"
|
|
" // size of the collection. In many cases, it avoids scanning the entire\n"
|
|
" // list. In the common case of just wanting one sample, it's a single\n"
|
|
" // random index lookup.\n"
|
|
" //\n"
|
|
" // However, its performance degrades badly as the sample size increases.\n"
|
|
" // Vitter's algorithm always scans the entire list, but it's also always\n"
|
|
" // O(n).\n"
|
|
" //\n"
|
|
" // The cutoff point between the two follows a quadratic curve on the same\n"
|
|
" // size. Based on some empirical testing, scaling that by 5 seems to fit\n"
|
|
" // pretty closely and chooses the fastest one for the given sample and\n"
|
|
" // collection size.\n"
|
|
" if (count * count * 5 < list.count) {\n"
|
|
" // Pick random elements and retry if you hit a previously chosen one.\n"
|
|
" var picked = {}\n"
|
|
" var result = []\n"
|
|
" for (i in 0...count) {\n"
|
|
" // Find an index that we haven't already selected.\n"
|
|
" var index\n"
|
|
" while (true) {\n"
|
|
" index = int(count)\n"
|
|
" if (!picked.containsKey(index)) break\n"
|
|
" }\n"
|
|
"\n"
|
|
" picked[index] = true\n"
|
|
" result.add(list[index])\n"
|
|
" }\n"
|
|
"\n"
|
|
" return result\n"
|
|
" } else {\n"
|
|
" // Jeffrey Vitter's Algorithm R.\n"
|
|
"\n"
|
|
" // Fill the reservoir with the first elements in the list.\n"
|
|
" var result = list[0...count]\n"
|
|
"\n"
|
|
" // We want to ensure the results are always in random order, so shuffle\n"
|
|
" // them. In cases where the sample size is the entire collection, this\n"
|
|
" // devolves to running Fisher-Yates on a copy of the list.\n"
|
|
" shuffle(result)\n"
|
|
"\n"
|
|
" // Now walk the rest of the list. For each element, randomly consider\n"
|
|
" // replacing one of the reservoir elements with it. The probability here\n"
|
|
" // works out such that it does this uniformly.\n"
|
|
" for (i in count...list.count) {\n"
|
|
" var slot = int(0, i + 1)\n"
|
|
" if (slot < count) result[slot] = list[i]\n"
|
|
" }\n"
|
|
"\n"
|
|
" return result\n"
|
|
" }\n"
|
|
" }\n"
|
|
"\n"
|
|
" shuffle(list) {\n"
|
|
" if (list.isEmpty) return\n"
|
|
"\n"
|
|
" // Fisher-Yates shuffle.\n"
|
|
" for (i in 0...list.count - 1) {\n"
|
|
" var from = int(i, list.count)\n"
|
|
" var temp = list[from]\n"
|
|
" list[from] = list[i]\n"
|
|
" list[i] = temp\n"
|
|
" }\n"
|
|
" }\n"
|
|
"}\n";
|