F. Almeida wrote:
== Quote from KennyTM~ (kenn...@gmail.com)'s article
On Aug 18, 10 14:41, F. Almeida wrote:
What if the compiler was able to introduce them in the
assignment
loop, provided that the functions pass ref double (in this
case)?
double anyfun(ref double x) { ... }
c = anyfun(a[]) + 2.0*b[];
import std.algorithm;
import std.stdio;
import std.array;
auto vectorize(alias f, U)(U a) {
return array(map!f(a));
}
double square(double x) {
return x*x;
}
void main () {
auto a = [1.0, 2.0, 3.0, 4.0];
auto b = [5.0, 6.0, 7.0, 8.0];
auto c = [0.0, 0.0, 0.0, 0.0];
c[] = vectorize!square(a)[] + 2.0 * b[];
writeln(">", c);
}
This doesn't help, as vectorize!() is being called to create an
array before passing it to the array expression (one additional
assignment loop). Additional functions passed through vectorize!()
would lead to N+1 loops per operation, with N the number of
vectorize!() calls, instead of the intended single loop. What is
intended is to pass as many functions as possible, and allow the
assignment to occur within a single loop.
The best alternative so far is to allow the compiler to take
initiative whenever a pure function accepting one argument (value,
not ref) of the same type exists.
pure double myf(double x) { ... }
c[] = myf(a[]) + 2.0*myf(b[]);
Is such an optimization possible?
Definitely. I'm just a bit paranoid about what could happen with
user-defined types.
I would hope, btw, that we could do:
Complex!double[] a;
double [] r = a[].re; // grab the real part
I see abs, sqrt, re, and im as the most important use cases.
My feeling is that it might be necessary to restrict this to:
c[] = myf(a[])[] + 2.0 * myf(b[])[];
That may be paranoia on my part. I'm not certain that
