Interesting problem. If this issue gets fixed
https://github.com/openscad/openscad/issues/1594 then you could make the
random number a default parameter to randcyl.

In the meantime you could set a global variable with rand and pass it to
randcyl() or just reference it in randcyl().

F5 doesn't work with this code on my system. It shows only half of the
result and when I rotate it flips to the other half.

On 5 March 2016 at 11:01, Neon22 mschafer@wireframe.biz wrote:

From the top of my head, this sounds like a bug. I’ll have to look into it in more detail, and I’ve opened an issue for this: https://github.com/openscad/openscad/issues/1596

-Marius

Neon22, I think you misunderstood the way rands operates with seeds. I had
the same misunderstanding the first time I tried to use it.

If you run the code:

echo(randn(n=1000, myseed=10));
echo(randn(n=1000, myseed=10));

the console will show two identical echos. That is: each time you run
rands(0,1,1, myseed)[0] you will receive the exact same number for each
myseed. The seed in rands is useful just in a random series of numbers: the
series will be the same for each seed.

So, to be useful, generate the entire random number series at once (or as
many series you need) and access a random number by the list indexing. If a
seed is provided in the series generation, it will be repeated in the next
run. Otherwise, a new random series will be generated.

2016-03-06 16:06 GMT-03:00 Marius Kintel marius@kintel.net:

I don't believe you can define a function that returns different results
each time (other than with rands) as that would require it to hold some
mutable state that isn't allowed.

Really I don't think rand should be allowed in OpenScad. It should always
produce the same results each run.

Is the problem you have just with the m_mirror module or do you have other
cases where you need to repeat a call to rands? You could define $seed =
rands(...) in m_mirror() and then use $seed in the children to create
identical results. e.g.

module m_mirror() {
$seed = rands(0,1000000,1)[0];
children(0);
mirror([1,0,0])
children(0);
}
module cut_in_half(size)  {
intersection() {
translate([0, -size/2.0, -size/2.0])
cube(size=size, center=false);
children(0);
}
}

module randcyl() {
// use of rands in here shows this object being called twice
echo("randcyl called");
rotate([rands(0,77,1, $seed)[0],45,0])
cylinder(h=rands(4,8,1, $seed)[0], d = 2, center=true);
}

m_mirror() cut_in_half(100) render() randcyl();

This creates random angles and lengths that are the same in each child but
they are probably related to each other.

On 6 March 2016 at 23:08, Neon22 mschafer@wireframe.biz wrote:

I don't think there is any way to do it. All functions in OpenSCAD, except
rands or anything using rands, return the same value for the same given
parameters. This is the heart of no side effects. And the function you are
looking for doesn't use rands.

2016-03-06 20:08 GMT-03:00 Neon22 mschafer@wireframe.biz:

module randcyl() {
// use of rands in here shows this object being called twice
echo("randcyl called");
rotate([rands(0,77,1, $seed)[0],45,0])
cylinder(h=rands(4,8,1, $seed + 1)[0], d = 2, center=true);
}

Seems to work better.

On 6 March 2016 at 23:48, Ronaldo Persiano rcmpersiano@gmail.com wrote:

The problem I see is that OpenSCAD is designed to be a pure declarative
language, but rands() is designed with an interface that only works
properly in an imperative language. To resolve the mismatch, we either need
to turn OpenSCAD into an imperative language, which is essentially where
Neon22 is going with his questions, or we need to deprecate rands(), and
provide a declarative interface for generating random numbers.

In a declarative language, function and module calls are referentially
transparent: they are guaranteed to return the same value or shape if the
arguments are the same. Users don't worry about how many times a function
or module call is evaluated, and they don't worry about the order of
evaluation, because these things can't have any effect on the final
rendered shape. (Okay, these things might have an impact on performance,
but not on correctness.) This results in two benefits:

1. It's easier for users to reason about the meaning of a program, and
   there are more ways that you can rearrange code without changing its
   meaning. Algebraic properties like the commutative and associate law are
   more useful in a declarative language. You can use algebraic reasoning on
   OpenSCAD scripts.
2. The implementation has more latitude to optimize the code, by
   rearranging the evaluation order, caching values, merging common
   subexpressions, and evaluating things in parallel.

To get these benefits, we need a declarative interface for generating
random numbers, which I will call 'random()'.

Here's my design:

• Each time the script is evaluated, a new random seed is generated.
  This is a global value, which has the name '$seed'. This is what happens
  today; what's new is that I've introduced the name '$seed'.
• The first argument to random() is a list of numbers and strings, which
  acts as a 'signature' for the random number to be generated. The strings
  and numbers in the signature are hashed together with $seed, to produce a
  random number in the range [0...1], which is returned.
• If you want a random number in the range 0...M, then you use
  random(sig)*M.
  • If you want N random numbers, then you include an index value in
    the signature list, which varies from 0 to N-1, and call random() N times.
• You can optionally pass $seed as a dynamically scoped argument to
  random(), which overrides the default global value of $seed.

The signature argument is the key idea that makes this interface
declarative. If random() is called multiple times with the same signature
and seed, then the same value is returned.

In a typical use of random(), the signature array will contain a unique
string that identifies this particular use of random(), plus one (or maybe
more) numbers, if the calling function needs more than one random number.

Neon22's randcyl() module would be written like this:

module randcyl() {
rotate([random(["randcyl"])*77,45,0])
cylinder(h=4, d = 2, center=true);
}

With just this code, every call to randcyl() within a given script
evaluation will return the same shape, unless randcyl() is called with a
$seed argument, in which case different values of $seed will produce
different shapes.

If your script uses random(), then each time you hit F5 you'll get a
different shape. If you add
echo(seed=$seed);
to your script, then you'll see the the seed value used for this particular
evaluation. If you get a result that you want to preserve, then you can
copy the seed value into your script by writing
$seed = <desired seed value>;
at the top level of your script, and now the script will always produce the
same shape.

On 6 March 2016 at 18:08, Neon22 mschafer@wireframe.biz wrote: