>
> A general question: I find the main Julia document very sparse in
> description.
For example I just couldn't figure out how to use @time.
@time 1+1
@time foo()
@time begin
for i in 1:10
...
end
end
I generally end up searching in the forum and most of the time I am lucky.
> The forum is gracious but I do not want to often post stupid questions.
There is a julia-lang tag on StackOverflow, if you prefer to use that for
"how do I do X" questions.
Apparently showing activity there helps us on one language ranking :)
On Wed, Jan 29, 2014 at 9:12 PM, Rajan Gurjar <rjngrj2...@gmail.com> wrote:
> Ok issue settled! Thanks guys, that really helped.
> Actually what Jacob suggested may have already worked i.e., evaluating the
> code inside the function.
>
> The reason I was still (i.e., despite function usage) getting long
> processing time was because instead of erasing my earlier code I decide to
> block comment it. I found on Google that some one suggested a way to block
> comment was to use ### ###.
> I was misled by it. The old code still hung around and was getting
> evaluated. I had to comment each line.
>
> I haven't still figured out a way to block comment on Julia. Maybe it does
> not exist?
>
> Anyway, now I actually implemented sum(sub(A...)) as Stefan suggested and
> implemented a function call and timed it using @time.
>
> It is coming out 13.8 seconds. I should time Matlab, but I am quite
> excited already! I know it comes very close. Finally a match to Matlab.
> Hopefully I will remain a happy camper at Julia (still struggling with
> Xubuntu installation though). How delighted I am. Thanks folks(developers)
> for your great work.
>
> A general question: I find the main Julia document very sparse in
> description. For example I just couldn't figure out how to use @time.
> The standard library just gives one line definition. I generally end up
> searching in the forum and most of the time I am lucky.
> The forum is gracious but I do not want to often post stupid questions.
>
>
>
> On Wed, Jan 29, 2014 at 6:27 PM, Rajan Gurjar <rjngrj2...@gmail.com>wrote:
>
>> Stefan,
>> sum(foo) did not work for me. It gave error and then I realized why.
>> sum(Array) turns out to be an array of (Float64,1) while the left hand
>> side is an element of an array. Therefore, I had to do another sum on that
>> one element array to give me a scalar. I just could not figure out the
>> error for almost an hour and then when I did
>> (sum(foo))
>> it would give me a number but
>> S(i,j)=sum(foo) did not and gave error (I do not recall the error but I
>> think it was something like "conversion for this type not possible"!)
>> Of course being fresh to Julia I did not figure this out and then I
>> realized that this occurs usually in scipy too.
>> But you are correct, I will change the sum(sum) provided I am able to
>> figure out how to convert the array to a number.
>>
>> Also I tried plain summation without using sum just like your last
>> section but it is was twice slower. I have that code too and
>> I will recheck again to see how it differs from your last section.
>>
>> John, I will implement some of Stefan's suggestion and run the timing
>> that you suggested. But what I am doing is very simple. I copy paste each
>> section of the code (both Matlab and Julia) and run them and time them. I
>> find that only that last piece which I wrote takes full 40 odd seconds. But
>> I should find out which line takes up that time.
>>
>> Thanks
>>
>>
>>
>>
>> On Wed, Jan 29, 2014 at 12:59 PM, Stefan Karpinski
>> <ste...@karpinski.org>wrote:
>>
>>> This sum(sum(foo,2)) business is really wasteful. Just do sum(foo) to
>>> take the sum of foo. It's also better to extract the dimensions into
>>> individual variables. Something like this:
>>>
>>> function runave1(S,A,f)
>>> s1, s2 = size(A)
>>> p1 = f+1
>>> for n = f+1:s2-f-1, m = f+1:s1-f
>>> S[m,n+1] = S[m,n] + sum(A[m-f:m+f,n+p1]) - sum(A[m-f:m+f,n-f])
>>> end
>>> S
>>> end
>>>
>>>
>>> I suspect that since Matlab forces this sum(sum(X,2)) idiom on you, it
>>> probably detects it and automatically does the efficient thing. It's
>>> unclear to me why you need two sum operations when the slices you're taking
>>> are just single columns, but maybe I'm missing something here.
>>>
>>> Currently, taking array slices in Julia makes a copy, which is
>>> unfortunate, but in the future they will be views. In the meantime, you
>>> might get better performance by explicitly using views:
>>>
>>> function runave2(S,A,f)
>>> s1, s2 = size(A)
>>> p1 = f+1
>>> for n = f+1:s2-f-1, m = f+1:s1-f
>>> S[m,n+1] = S[m,n] + sum(sub(A,m-f:m+f,n+p1)) -
>>> sum(sub(A,m-f:m+f,n-f))
>>> end
>>> S
>>> end
>>>
>>>
>>> And, of course, there's always the nuclear option for really performance
>>> critical code, which is to write out the summation manually:
>>>
>>> function runave3(S,A,f)
>>> s1, s2 = size(A)
>>> p1 = f+1
>>> for n = f+1:s2-f-1, m = f+1:s1-f
>>> t = S[m,n]
>>> for k = m-f:m+f; t += A[k,n+p1] - A[k,n-f]; end
>>> S[m,n+1] = t
>>> end
>>> S
>>> end
>>>
>>>
>>> Not so elegant, but probably the fastest possible version. Ideally, once
>>> array slices are views, the simpler version of the code will be essentially
>>> equivalent to this. It will take some compiler cleverness, but it's
>>> certainly doable. It would be interesting to hear how each of these
>>> versions performs on your data.
>>>
>>> On Wed, Jan 29, 2014 at 12:30 PM, John Myles White <
>>> johnmyleswh...@gmail.com> wrote:
>>>
>>>> Can you show the call to @time / @elapsed so we know exactly what's
>>>> being timed?
>>>>
>>>> -- John
>>>>
>>>> On Jan 29, 2014, at 9:28 AM, Rajn <rjngrj2...@gmail.com> wrote:
>>>>
>>>> > Now it takes even longer i.e., ~1 minute
>>>> >
>>>> > Does this make sense. Also I am running this loop only once. I do not
>>>> understand why writing in the function form would help. I read the manual
>>>> but they suggest writing function form for something which is used many
>>>> times.
>>>> > I=runave(S,A,f)
>>>> > showim(I);
>>>> >
>>>> > function runave(S,A,f)
>>>> > imsz=size(A);
>>>> > p1=f+1;
>>>> > for n=(f+1):(imsz[2]-f-1)
>>>> > for m=(f+1):(imsz[1]-f)
>>>> >
>>>> S[m,n+1]=S[m,n]+sum(sum(A[m-f:m+f,n+p1],2))-sum(sum(A[m-f:m+f,n-f],2));
>>>> > end
>>>> > end
>>>> > S;
>>>> > end
>>>> >
>>>> > Do I have to declare function parameters to speed it up.
>>>>
>>>>
>>>
>>
>
