On Friday, 23 December 2022 at 17:53:24 UTC, H. S. Teoh wrote:

No need, I have ample logging already written into the program.

False alarm everyone, there was a logical error in my code. And not only this, but the error appeared in none of the code I posted, sorry! I was working from a wrong assumption.

I counted calls to my rand01 function and realized that the number of calls was equal to the number of times rand appeared in the file being interpreted, rather than the number of times it should have been evaluated. Then it became clear that the parser was replacing calls to rand with a number, which was displayed repeatedly when a loop was evaluated. I removed rand from the dictionary of substitutions the parser needs to make.

On Friday, 23 December 2022 at 07:25:23 UTC, Salih Dincer wrote:

import std.random;

static this() { } // can try using

Mt19937 rnd;
void init_random() {
  rnd = Random(unpredictableSeed);
}

double rand01() {
    return uniform(0, 1.0, rnd);
}

void main()
{
  init_random();

  struct Atom { double num; }
  alias atom = Atom* function();
  atom[string] primitiveSymbols = [
    "rand" : () => new Atom(rand01)
  ];
  import std.stdio;
  writeln(*primitiveSymbols["rand"]()); // Atom(0.630001)
}

I would still like to learn about this idiom. Can you tell me what it means and when I should use it?

On Saturday, 24 December 2022 at 16:16:17 UTC, jwatson-CO-edu wrote:

Sounds like a case of https://xkcd.com/221/

BTW, you don't need to explicitly initialize unpredictableSeed, because that's how it is already configured dby efault. Setting the seed is useful if you are interested in a specific PRNG algorithm with a specific seed to produce a predictable deterministic pattern.

Another thing is that the current implementation of std.random in Phobos is extremely slow and with some tweaks it can be up to 3x-6x times faster. There's a more advanced mir-random third-party dub package, but I'm not sure whether they have any plans to backport all of their optimizations to Phobos (or whether such contribution would be accepted).

On Saturday, 24 December 2022 at 16:42:36 UTC, Siarhei Siamashka wrote:

Even better, I automated the caching of dice rolls to be used later as random numbers! ;P

Thanks for the tips.

On Saturday, 24 December 2022 at 16:34:29 UTC, Ali Çehreli wrote:

"rand" : () => new Atom(rand01)

Ali, your post contained at least 3 things I did not previously know about D; thank you!

And thank you all for helping troubleshoot this issue with my hobby language!

On Saturday, 24 December 2022 at 17:58:04 UTC, jwatson-CO-edu wrote:

Thank you for completing me: Tesekkurler hocam in Turkish.

Meanwhile, the compile-time and associative array capabilities are incredible:

alias oT = int;
enum opMap =
[ "×": (oT a, oT b) => a * b,
  "÷": (oT a, oT b) => a / b,
  //...
];

auto doubleAndDivide(oT first, oT second) {
  const foldedDouble = opMap["×"](first, 2);
  return opMap["÷"](foldedDouble, second);
}

void main()
{
  assert(6.doubleAndDivide(3) == 4);
}

Don't you think it's delicious too? It's impossible not to love D.

SDB@79

On Saturday, 24 December 2022 at 17:55:11 UTC, jwatson-CO-edu wrote:

Just in case if you are not joking, caching a certain amount of dice rolls to reuse them later in a circular fashion would make a bad quality pseudorandom number generator (a slightly upgraded version of the xkcd joke). Don't do this. Just use std.random if performance doesn't really matter and you want to avoid an extra library dependency. But if performance does matter and you need hundreds of millions of random numbers for Monte Carlo simulations, fuzz testing or anything else, then consider mir.random.

BTW, a few puzzles from https://adventofcode.com/2022 are trivialized by using randomized bruteforce instead of a more sophisticated algorithm. And having fast random numbers generation helps.