in reply to Re^3: A set of new operators. In keeping with the design of Perl? (aliasing)
in thread A set of new operators. In keeping with the design of Perl?

List::Utils is great and was one the reasons I got around to upgrading. It replaced about half the routines in my personal utils module. The problem is that I need the min and max of each dataset, and iterating each dataset twice isn't ideal with huge datasets.

I agree with your reduction when the array is of a reasonable size, but each dataset is 786,432 elements, there are several datasets and the operation isn't a one-off, so building a list in the for loop is kind of expensive I think? Hence the choice to use the lazy evaluation of the range op in a for loop to index the elements. That problem goes away once we get lazy-evaluating in P6.

It still irks me that I have to type the operands, to what is essentially a binary operation, twice each, but it seems I'm the only one who sees that as a problem, and I don't relish causing, let alone being involved in, a 3 year p5p flame fest which I was told above is what it took to get ||= implemented:(.

It's the same "I know that everything is available in the cpu for the processing required" type ire that I feel about the need to do 

my $n;
my ($div, $rem) = ( int($n/10), $n % 10 );

[download]

as I pontificated on at A better mod (%) operator?. It's not a "performance thing",

 my ($div, %rem) = $n %% 10;

just seems cleaner. That I know that both values are available in the registers after either / or % means that even hiding the double division within a sub or overloading % or whatever still doesn't satisfy my sense of "once and once only:)

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"When I'm working on a problem, I never think about beauty. I think only how to solve the problem. But when I have finished, if the solution is not beautiful, I know it is wrong." -Richard Buckminster Fuller

Replies are listed 'Best First'.
Re^5: A set of new operators. In keeping with the design of Perl? (aliasing)
by Aristotle (Chancellor) on May 21, 2003 at 20:58 UTC
    As for the single-pass problem, you can do that too: 
    use List::Util qw(reduce);

@hash{$set}{qw(min max)} = @{ reduce {
    return [ $a, $b ] if 'ARRAY' ne ref $a;
    return
        $a->[0] < $b ? [ $b, $a->[1] ] :
        $a->[1] > $b ? [ $a->[0], $b ] :
        $a;
} @{$hash{$set}{data}} };

    [download]
    Admittedly more hoop jumping here. Of course that doesn't address the memory problem, but in that case I'd still opt for a counter in a while loop instead. (In keeping with the corresponding use of while and each to traverse a hash.) 
    for my $min ($hash{$set}{min}) {
    my $data = $hash{$set}{data};
    my $i = -1;
    while(++$i < @$data) {
        $min = $min < $data->{$i}
            ? $min
            : $data->{$i};
    }
}

    [download]

    Makeshifts last the longest.

[reply]
[d/l]
[select]

In Section Meditations