www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Generate array of random values

reply Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
I'm currently using this:

import std.algorithm;
import std.array;
import std.random;
import std.range;

void main()
{
    auto arr2 = array(map!( (int){ return uniform(0, 1024); })(iota(0, 1024)));
}

Is there a simpler way to do get an array of random values?
Jul 30 2011
next sibling parent bearophile <bearophileHUGS lycos.com> writes:
Andrej Mitrovic:

 void main()
 {
     auto arr2 = array(map!( (int){ return uniform(0, 1024); })(iota(0, 1024)));
 }
 
 Is there a simpler way to do get an array of random values?

If you want a single expression you are allowed to write a bit shorter code: auto arr2 = array(map!((int){ return uniform(0, 1024); })(iota(1024))); Once we get amap/afilter added to Phobos (http://d.puremagic.com/issues/show_bug.cgi?id=5756 ) the code gets a bit simpler: auto arr2 = amap!((int){ return uniform(0, 1024); })(iota(1024)); amap/afilter are not orthogonal, but this is acceptable for practicality (and done in all the languages I know), because in D arrays are much more commonly useful than lazy ranges. I have also proposed a N dimensional table() function to be added to Phobos. With it the code gets simple (Mathematica has a similar function): auto arr2 = table!q{ uniform(0, 1024) }(1024); In Python3 you use a list (array) comp: lst = [randrange(1024) for _ in range(1024)] Unfortunately often the "simpler way" in D is to use an imperative programming style. Bye, bearophile
Jul 30 2011
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
Yeah I really like Python's list comprehensions. That's something I'll
always miss in D.
Jul 30 2011
prev sibling next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Sat, 30 Jul 2011 11:10:38 -0400, Andrej Mitrovic  
<andrej.mitrovich gmail.com> wrote:

 I'm currently using this:

 import std.algorithm;
 import std.array;
 import std.random;
 import std.range;

 void main()
 {
     auto arr2 = array(map!( (int){ return uniform(0, 1024); })(iota(0,  
 1024)));
 }

 Is there a simpler way to do get an array of random values?

I think that an infinite range which returns random numbers should be a phobos-declared type... If it's not, it should be. -Steve
Aug 01 2011
parent Dmitry Olshansky <dmitry.olsh gmail.com> writes:
On 01.08.2011 18:05, Steven Schveighoffer wrote:
 On Sat, 30 Jul 2011 11:10:38 -0400, Andrej Mitrovic 
 <andrej.mitrovich gmail.com> wrote:

 I'm currently using this:

 import std.algorithm;
 import std.array;
 import std.random;
 import std.range;

 void main()
 {
     auto arr2 = array(map!( (int){ return uniform(0, 1024); 
 })(iota(0, 1024)));
 }

 Is there a simpler way to do get an array of random values?

I think that an infinite range which returns random numbers should be a phobos-declared type... If it's not, it should be.

import std.random, std.algorithm, std.stdio, std.range; void main() { Xorshift rng; rng.seed(unpredictableSeed); writeln(take(rng, 10)); } -- Dmitry Olshansky
Aug 01 2011
prev sibling next sibling parent reply David Nadlinger <see klickverbot.at> writes:
On 7/30/11 5:10 PM, Andrej Mitrovic wrote:
 Is there a simpler way to do get an array of random values?

If you don't need the random numbers to be in a certain range, you could use array(take(rndGen(), 1024)) – if you do need a limit, that would be array(map!"a % 1024"(take(rndGen(), 1024))). David
Aug 01 2011
parent reply bearophile <bearophileHUGS lycos.com> writes:
David Nadlinger:

 if you do need a limit, that would be 
 array(map!"a % 1024"(take(rndGen(), 1024))).

% doesn't give an uniform distribution. Bye, bearophile
Aug 01 2011
parent reply David Nadlinger <see klickverbot.at> writes:
On 8/1/11 8:55 PM, bearophile wrote:
 David Nadlinger:
 array(map!"a % 1024"(take(rndGen(), 1024))).

% doesn't give an uniform distribution.

I'd argue it does with 1024… ;) David
Aug 01 2011
next sibling parent Adam D. Ruppe <destructionator gmail.com> writes:
I'm barely following this thread, but why not:

===
import std.random;
void main() {
    int[] arr;
    foreach(i; 1 .. 100)
         arr ~= uniform(0, 1024);
}
===

?
Aug 01 2011
prev sibling next sibling parent bearophile <bearophileHUGS lycos.com> writes:
David Nadlinger:

 I'd argue it does with 1024… ;)

Right, I am sorry :-) Bye, bearophile
Aug 01 2011
prev sibling next sibling parent Dmitry Olshansky <dmitry.olsh gmail.com> writes:
On 01.08.2011 23:43, Andrej Mitrovic wrote:
 Actually I don't really need *uniform* distribution, it's just that
 when porting C code to D I didn't find any obvious random()/rnd()
 functions, and uniform seemed to be the closest thing without having
 to mess around with a bunch of randomization parameters which I don't
 care about.

 I don't see how we can claim D to be an elegant language with this mess:
 array(map!"a % 1024"(take(rndGen(), 1024)))

 That's just damn *horrible*.

Dunno maybe it's only me, but some years ago when I used C++98 & STL extensively I would find this line a very simple and clean solution. Now time is changing and so on... A thought - would amap as a shorthand for array(map... float your boat? One pair of parens off. -- Dmitry Olshansky
Aug 01 2011
prev sibling next sibling parent Dmitry Olshansky <dmitry.olsh gmail.com> writes:
On 02.08.2011 16:08, Andrej Mitrovic wrote:
 On 8/2/11, Pelle<pelle.mansson gmail.com>  wrote:
 Without UFCS, well, how would you want it to look?

auto max = 1024; auto len = 1024; arr = rndRange(max)[0..len]; IOW, using the slice operator instead of a call to array().

slice to 1. return the same type as the range itself (or 100% compatible) 2. most of the time not to allocate -- Dmitry Olshansky
Aug 02 2011
prev sibling parent bearophile <bearophileHUGS lycos.com> writes:
Andrej Mitrovic:

 Maybe..
 
 auto max = 1024;
 auto len = 1024;
 
 arr = rndRange(max)[0..len];

In my opinion that's not general enough for Phobos, see the N dimensional table() I have explained here: auto arr = table!q{ uniform(0, 1024) }(1024); http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D.learn&article_id=28543 Bye, bearophile
Aug 02 2011
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
Actually I don't really need *uniform* distribution, it's just that
when porting C code to D I didn't find any obvious random()/rnd()
functions, and uniform seemed to be the closest thing without having
to mess around with a bunch of randomization parameters which I don't
care about.

I don't see how we can claim D to be an elegant language with this mess:
array(map!"a % 1024"(take(rndGen(), 1024)))

That's just damn *horrible*.
Aug 01 2011
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 8/1/11, Adam D. Ruppe <destructionator gmail.com> wrote:
 I'm barely following this thread, but why not:

 ===
 import std.random;
 void main() {
     int[] arr;
     foreach(i; 1 .. 100)
          arr ~= uniform(0, 1024);
 }
 ===

 ?

Ah but nearly every initialization can be converted to a foreach loop. But I'm trying to avoid that and use a simple expression instead. :)
Aug 01 2011
prev sibling next sibling parent "Jonathan M Davis" <jmdavisProg gmx.com> writes:
 On 01.08.2011 23:43, Andrej Mitrovic wrote:
 Actually I don't really need *uniform* distribution, it's just that
 when porting C code to D I didn't find any obvious random()/rnd()
 functions, and uniform seemed to be the closest thing without having
 to mess around with a bunch of randomization parameters which I don't
 care about.
 
 I don't see how we can claim D to be an elegant language with this mess:
 array(map!"a % 1024"(take(rndGen(), 1024)))
 
 That's just damn *horrible*.

Dunno maybe it's only me, but some years ago when I used C++98 & STL extensively I would find this line a very simple and clean solution. Now time is changing and so on... A thought - would amap as a shorthand for array(map... float your boat? One pair of parens off.

Yeah. I confess that I don't see much ugly in that solution. It wouldn't hurt my feelings any to have a cleaner solution, but array(map!"a % 1024"(take(rndGen(), 1024))); seems fine to me. But maybe I'm just too used to the STL and std.algorithm. Regardless, it's _way_ cleaner than what you can achieve in C++98 trying to do the same thing. - Jonathan M Davis
Aug 01 2011
prev sibling next sibling parent Pelle <pelle.mansson gmail.com> writes:
On Mon, 01 Aug 2011 21:43:13 +0200, Andrej Mitrovic  
<andrej.mitrovich gmail.com> wrote:

 Actually I don't really need *uniform* distribution, it's just that
 when porting C code to D I didn't find any obvious random()/rnd()
 functions, and uniform seemed to be the closest thing without having
 to mess around with a bunch of randomization parameters which I don't
 care about.

 I don't see how we can claim D to be an elegant language with this mess:
 array(map!"a % 1024"(take(rndGen(), 1024)))

 That's just damn *horrible*.

If we ever get UFCS that'd be rndGen().take(1024).map!"a % 1024"().array() Which is a lot better :--) Without UFCS, well, how would you want it to look? How does it look in other languages?
Aug 02 2011
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 8/2/11, Pelle <pelle.mansson gmail.com> wrote:
 Without UFCS, well, how would you want it to look?

Maybe.. auto max = 1024; auto len = 1024; arr = rndRange(max)[0..len]; IOW, using the slice operator instead of a call to array().
Aug 02 2011
prev sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
Woops you're right about the range type being returned.

I guess this is the next best thing:

arr = array(rndRange(max, len));
Aug 02 2011