Array Operations: a[] + b[] etc.

[Robert Jacques]

On Thu, 22 Nov 2012 20:06:44 -0600, John Colvin  
<john.loughran.colvin at gmail.com> wrote:
> On Thursday, 22 November 2012 at 21:37:19 UTC, Dmitry Olshansky wrote:
>> Array ops supposed to be overhead-free loops transparently leveraging  
>> SIMD parallelism of modern CPUs. No more and no less. It's like  
>> auto-vectorization but it's guaranteed and obvious in the form.
>
> I disagree that array ops are only for speed.
> I would argue that their primary significance lies in their ability to  
> make code significantly more readable, and more importantly, writeable.  
> For example, the vector distance between 2 position vectors can be  
> written as:
> dv[] = v2[] - v1[]
> or
> dv = v2[] - v1[]
> anyone with an understanding of mathematical vectors instantly  
> understands the general intent of the code.
> With documentation something vaguely like this:
> "An array is a reference to a chunk of memory that contains a list of  
> data, all of the same type. v[] means the set of elements in the array,  
> while v on it's own refers to just the reference. Operations on sets of  
> elements e.g. dv[] = v2[] - v1[] work element-wise along the arrays  
> {insert mathematical notation and picture of 3 arrays as columns next to  
> each other etc.}.
> Array operations can be very fast, as they are sometimes lowered  
> directly to cpu vector instructions. However, be aware of situations  
> where a new array has to be created implicitly, e.g. dv = v2[] - v1[];  
> Let's look at what this really means: we are asking for dv to be set to  
> refer to the vector difference between v2 and v1. Note we said nothing  
> about the current elements of dv, it might not even have any! This means  
> we need to put the result of v2[] - v1] in a new chunk of memory, which  
> we then set dv to refer to. Allocating new memory takes time,  
> potentially taking a lot longer than the array operation itself, so if  
> you can, avoid it!",
> anyone with the most basic programming and mathematical knowledge can  
> write concise code operating on arrays, taking advantage of the  
> potential speedups while being aware of the pitfalls.
>
> In short:
> Vector syntax/array ops is/are great. Concise code that's easy to read  
> and write. They fulfill one of the guiding principles of D: the most  
> obvious code is fast and safe (or if not 100% safe, at least not too  
> error-prone).
> More vector syntax capabilities please!

While I think implicit allocation is a good idea in the case of variable  
initialization, i.e.:

auto dv = v2[] - v1[];

however, as a general statement, i.e. dv = v2[] - v1[];, it could just as  
easily be a typo and result in a silent and hard to find performance bug.

// An alternative syntax for variable initialization by an array operation  
expression:
auto dv[] = v2[] - v1[];