Re: A few range questions

[Charles Smith via Digitalmars-d-learn]

On Tuesday, 5 January 2016 at 19:42:42 UTC, Ali Çehreli wrote:
You are traversing the array per index value (1000 times), 
which can be done once up front:

Good point. I guess I assumed `map!` was magic.



    // Now they get their own arrays:
    auto benchmarks = benchmark!(() => algorithmSort(arr.dup),
                                 () => 
countingSort(arr.dup))(1);


I'm not sure what this explicitly is doing... Are you defining an 
anonymous function? If so, that seems really useful.


    uint[valueCount] hist;
    arr.each!(a => ++hist[a]);

    auto result = hist[].enumerate.map!(t => 
t[0].repeat(t[1])).joiner;
    // To make sure that we consume the lazy range:
    return result.sum;
}
I think .joiner is what you're looking for.


Thanks a lot for this. Coming from a webdev background I'm 
ashamed I didn't guess `join`. That said, I don't think the 
example for `chain` should compile then. Just as an aside, I was 
searching the terms `concat` and `flatten ` when I was looking 
for this.

> 3. It's kind of hard to compare performance because of (1),
but is there
> a better way to do this?

I changed the code to pass each function a different array.

My results with -O -inline -noboundscheck:

Algorithm's Sort: 76 ms, 910 μs, and 8 hnsecs
Counting Sort   : 21 ms, 563 μs, and 9 hnsecs

Ali

Awesome