The Val{N} version will makes the compiler specialize the tuple creation
for that specific value of N. It should be significantly faster for small
lengths of the tuple and the return value should also be inferrable.
On Wednesday, August 10, 2016 at 8:59:45 PM UTC+2, Jeffrey Sarnoff wrote:
>
> almost certainly -- I use BenchmarkTools for this sort of timing, and can
> recommend it.
>
> On Wednesday, August 10, 2016 at 2:56:17 PM UTC-4, Bill Hart wrote:
>>
>> For me, the version using CartesianIndex is exactly the same speed as the
>> syntax with the Val, which in turn is faster than without Val.
>>
>> It probably depends a lot on the application and what the compiler can
>> handle.
>>
>> Bill.
>>
>> On 10 August 2016 at 20:45, Jeffrey Sarnoff <jeffrey...@gmail.com> wrote:
>>
>>> relative to the same thing without the Val
>>>
>>>
>>> On Wednesday, August 10, 2016 at 2:45:06 PM UTC-4, Jeffrey Sarnoff wrote:
>>>>
>>>> that slows it down by a factor of 5
>>>>
>>>> On Wednesday, August 10, 2016 at 2:37:25 PM UTC-4, Bill Hart wrote:
>>>>>
>>>>> How about compared with:
>>>>>
>>>>> ntuple(i -> a[i] + b[i], Val{N})
>>>>>
>>>>>
>>>>> On 10 August 2016 at 20:32, Jeffrey Sarnoff <jeffrey...@gmail.com>
>>>>> wrote:
>>>>>
>>>>>> Bill,
>>>>>>
>>>>>> Following Eric's note, I tried (with a,b equi-length tuples)
>>>>>> function addTuples(a,b)
>>>>>> ca = CartesianIndex(a)
>>>>>> cb = CartesianIndex(b)
>>>>>> return (ca+cb).I
>>>>>> end
>>>>>>
>>>>>>
>>>>>> for me, with 100 values it ran ~60% faster, and with 1000 values much
>>>>>> much faster than
>>>>>> ntuple(i -> a[i] + b[i], N)
>>>>>>
>>>>>>
>>>>>>
>>>>>> On Wednesday, August 10, 2016 at 11:06:46 AM UTC-4, Bill Hart wrote:
>>>>>>>
>>>>>>> This code seems to be (about 50%) faster than recursive functions:
>>>>>>>
>>>>>>> Base.:+{N}(a::NTuple{N}, b::NTuple{N}) = ntuple(i -> a[i] + b[i], N)
>>>>>>>
>>>>>>>
>>>>>>> But this seems (about 50%) slower:
>>>>>>>
>>>>>>> ((a[i] + b[i] for i = 1:N)...)
>>>>>>>
>>>>>>>
>>>>>>> Anyway, I can use the first method, until I find something faster.
>>>>>>> It's definitely way more convenient. Thanks.
>>>>>>>
>>>>>>> Bill.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> On 10 August 2016 at 16:56, Erik Schnetter <schn...@gmail.com>
>>>>>>> wrote:
>>>>>>>
>>>>>>>> The built-in type `CartesianIndex` supports adding and subtracting,
>>>>>>>> and presumably also multiplication. It is implemented very
>>>>>>>> efficiently,
>>>>>>>> based on tuples.
>>>>>>>>
>>>>>>>> Otherwise, to generate efficient code, you might have to make use
>>>>>>>> of "generated functions". These are similar to macros, but they know
>>>>>>>> about
>>>>>>>> the types upon which they act, and thus know the value of `N`. This is
>>>>>>>> a
>>>>>>>> bit low-level, so I'd use this only if (a) there is not other package
>>>>>>>> available, and (b) you have examined Julia's performance and found it
>>>>>>>> lacking.
>>>>>>>>
>>>>>>>> I would avoid overloading operators for `NTuple`, and instead us a
>>>>>>>> new immutable type, since overloading operations for Julia's tuples
>>>>>>>> can
>>>>>>>> have unintended side effects.
>>>>>>>>
>>>>>>>> -erik
>>>>>>>>
>>>>>>>>
>>>>>>>> On Wed, Aug 10, 2016 at 9:57 AM, 'Bill Hart' via julia-users <
>>>>>>>> julia...@googlegroups.com> wrote:
>>>>>>>>
>>>>>>>>> Does anyone know an efficient way to add NTuples in Julia?
>>>>>>>>>
>>>>>>>>> I can do it using recursive functions, but for various reasons
>>>>>>>>> this is not efficient in my context. I really miss something like
>>>>>>>>> tuple(a[i] + b[i] for i in 1:N) to create the resulting tuple all in
>>>>>>>>> one go
>>>>>>>>> (here a and b would be tuples).
>>>>>>>>>
>>>>>>>>> The compiler doesn't do badly with recursive functions for
>>>>>>>>> handling tuples in very straightforward situations, but for example,
>>>>>>>>> if I
>>>>>>>>> want to create an immutable type based on a tuple the compiler
>>>>>>>>> doesn't seem
>>>>>>>>> to be able to handle the necessary optimisations. At least, that is
>>>>>>>>> what I
>>>>>>>>> infer from the timings. Consider
>>>>>>>>>
>>>>>>>>> immutable bill{N}
>>>>>>>>> d::NTuple{N, Int}
>>>>>>>>> end
>>>>>>>>>
>>>>>>>>> and I want to add two bill's together. If I have to add the tuples
>>>>>>>>> themselves using recursive functions, then I no longer seem to be
>>>>>>>>> able to
>>>>>>>>> do something like:
>>>>>>>>>
>>>>>>>>> A[i] = B[i] + C[i] efficiently, where A, B and C are arrays whose
>>>>>>>>> elements are of type bill.
>>>>>>>>>
>>>>>>>>> I know how to handle tuples via arrays, but for efficiency reasons
>>>>>>>>> I certainly don't want to do that, e.g. tuple([a[i] + b[i] for i in
>>>>>>>>> 1:N]...).
>>>>>>>>>
>>>>>>>>> Bill.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> --
>>>>>>>> Erik Schnetter <schn...@gmail.com>
>>>>>>>> http://www.perimeterinstitute.ca/personal/eschnetter/
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>
>>
