Hi, the oddest thing about Julia is how it behaves in loops (especially For loops). The following example gives me an error, DataVar: Not Defined, and I cannot imagine why: function TestLogic(Nloops) for i in 1:Nloops println("i, Nloops = ",i,", ",Nloops) if (i == 1) DataVar = 333 end println("i = ", i) println("DataVar = ", DataVar) DataVar += 10^i println("DataVar = ", DataVar) end return end TestLogic(3) As an old Fortran programmer, I expect the variable DataVar to be defined during the i=1 pass, and incremented each time afterwards. But why does the For loop forget about DataVar completely?? I am aware of the “controversy” about For loops not knowing about variables defined outside of the loop. But here, DataVar is being defined INSIDE the loop! What’s going on??

[image] CosmoProf: I am aware of the “controversy” about For loops not knowing about variables defined outside of the loop. But here, DataVar is being defined INSIDE the loop! What’s going on?? The variable scope is each iteration of the for loop, not all iterations of the loop together. If you want to share the variable for all iterations of the for loop, you could also (as alternative to the suggestion of @briochemc) write local DataVar # this does not define the type of DataVar yet for i in 1:Nloops if i == 1 DataVar = 333 end DataVar += 10^i # ... end Edit: It is still required to set the 1st value of DataVar, code corrected.

Exactly. Put simply, no edit to the manual will help if people don’t know how to look up sections, just like with real books. You can put flashing neon lights on the section and it wouldn’t help if the reader hasn’t reached the page. That’s not to say this can’t be improved ever. I just remembered this topic where it turned out typing == and === in the search bar didn’t return the right sections in Base or Manual.

[image] Tamas_Papp: I think the fundamental problem is people not reading the manual (multiple times, coming back to parts, as they would read a textbook on some nontrivial subject). I think a big issue is that the manual is not at all easy to search. Something simple that might help is to make it easier for people to restrict their searches – for example, when I want to find something in the manual, half the time it’s buried under hundreds of function or type definitions from the base and standard library. Something as simple as letting me “just” restrict my search to the manual contents would be helpful. (and if that functionality exists, I haven’t been able to find it. Usually, I just rely on Google searches, which invariably take me to a version of the manual years out of date. Then I have to use that as a baseline for lookin in the current manual, and hope that the particular section hasn’t been moved or reorganized.) The manual has a lot of great content, but (IMHO) it’s too hard to find any of it unless you already know it inside and out.

[image] lmiq: Yes, that is clear. Does that mean that gfortran is just too bad? EDIT: I get the exact same performance between them (and -march=native doesn’t seem to matter). Compiling with gfortran -O3 -march=native rootloop.f90 -shared -fPIC -o libloop.so gfortran -Ofast -march=native rootloop.f90 -shared -fPIC -o libloopfast.so Yields: julia> using BenchmarkTools julia> function loop(x,n) s = 0. for i in 1:n r = sqrt(i) s = s + x*r end s end loop (generic function with 1 method) julia> function loopfast(x,n) s = 0. @fastmath for i in 1:n r = sqrt(i) s = s + x*r end s end loopfast (generic function with 1 method) julia> floop(x,n) = ccall((:loop_,"libloop.so"),Float64,(Ref{Float64},Ref{Int64}),x,n) floop (generic function with 1 method) julia> floopfast(x,n) = ccall((:loop_,"libloopfast.so"),Float64,(Ref{Float64},Ref{Int64}),x,n) floopfast (generic function with 1 method) julia> x = rand() ; n = 10_000_000; julia> @btime loop($x, $n) 13.054 ms (0 allocations: 0 bytes) 7.112252395049944e9 julia> @btime floop($x, $n) 13.054 ms (0 allocations: 0 bytes) 7.112252395049944e9 julia> @btime loopfast($x, $n) 6.982 ms (0 allocations: 0 bytes) 7.112252395049599e9 julia> @btime floopfast($x, $n) 6.982 ms (0 allocations: 0 bytes) 7.1122523950496235e9

[image] Elrod: No. Adding -march=native gives me the same performance in Julia and gfortran. Thanks for the tip, yet now I am trying to reproduce exactly what I did before and I do not see that difference in performance anymore… :neutral_face: … Now I see that -O3 is enough to pair up performances, maybe I forgot to add that when I compiled the code for the first time. How unfair with old good Fortran I have been :slight_smile: .

Ha, I admit I didn’t try without -march=native to confirm. I just did and got the exact same performance as with it when using -O3. When using -Ofast, it was faster without -march=native. lol The problem is that sqrt limits the performance of this function, and that SIMD square roots with 4 or 8 elements aren’t any faster per element than SIMD square roots with 2 elements in terms of number of clock cycles. That is, on Skylake/Cascadelake-X, sqrt on 1 or 2 Float64 are equally fast, but on 4 takes twice as long, and 8 twice as long again. Note that this is architecture specific. Agner Fog’s instruction tables suggest that sqrtpd on Zen2 CPUs is equally fast, independent of vector sizes, meaning if using -Ofast -march=native should be faster on them than just -Ofast. Similarly, starting Julia normally and using @fastmath should be faster than starting Julia with julia -Cgeneric. julia> @btime floopfastgeneric($x, $n) 6.527 ms (0 allocations: 0 bytes) 9.735648448452713e9 julia> @btime floopfast($x, $n) 6.982 ms (0 allocations: 0 bytes) 9.735648448452318e9 julia> 6.982 * 4.3/4.6 6.526652173913044 My CPU runs AVX(2) and light AVX512 code at 4.3 GHz, and SSE code at 4.6 GHz. The ratio 4.3/4.6 equals the ratio in relative times. So, equivalent speed in terms of number of clock cycles needed, but faster clock speed when not using -march=native gives the generic version the edge.

[image] StefanKarpinski: Scope behavior decisions are made entirely for the sake of user-facing semantics, not at all for the sake of the compiler. If we wanted something that was easy on the compiler, we wouldn’t have closures at all or would have closures that capture by value. Interesting! So… I must ask: Why do we have scope below function-level, then? The way it looks like to me is: If we removed scoping of let/for/while within functions, then some code that currently throws UndefVarError would instead do something else. And that’s it – code that doesn’t throw UndefVarError would not change behavior. Or am I missing something?

[image] Why not an even-harder scope? Internals & Design Having a lot of time thinking about it, I really believe that our current design is very close to optimal given just these assumptions: Locals may be implicitly declared by assignment The rules for all local scopes are the same The language has closures. There are languages where all variables have to be explicitly declared, i.e. you have to write var x or local x to declare a new local. This, of course, makes all problems relating to what scope an assignment assigns to go away: it’s the inne…

I don’t know why but a lot of people including me were asking about scope rules in the last few days, maybe astrology is real.

Thanks lungben, the local DataVar statement seems to have gotten this kind of loop to work as I expected it to work in the first place. While the discussion that my question triggered is all very interesting, and people seem to be repeating positions from previous debates, as a relative newbie to Julia, I’d like to put my two cents in on this. First, while the documentation has some good info, it is incredibly sparse. I spend 2 or 3 times more time clicking back and forth between documentation pages and googling key phrases, trying to find specific useful info, than I spend actually reading documentation. There is an extreme shortage of actual programming examples, demonstrating the proper syntax of how to use the commands, and often I can’t even find a listing or explanation of the options available for the commands. There are also very few books on Julia, since it is a relatively new language, so it is very hard to pick up from scratch. Without this discussion board, I would have completely given up on the Julia programming language within a week. Second, the entire “scope” setup of variables in Julia is a horror, plain and simple. I don’t care how many advantages it creates down the road, just writing a simple program with a detailed control flow leads constantly to errors and spurious results. Rather than debating how much detail is optimal to fill in on the “scope of variables” documentation, maybe the problem is that the entire approach is baffling from a common sense point of view. (Even if statement blocks sometimes create new scopes!?) Julia provides so many advantages in mathematical power, why completely reinvent the wheel on basic programming strategy? I just lost a week of productivity trying to figure out where my variables were going, it is incredibly frustrating.

Julia's loop scope behavior differs from Fortran?

General Usage

StefanKarpinski November 17, 2020, 7:14pm 27

Topic		Replies	Views
Explain scoping confusion to a programming beginner New to Julia question	26	3623	August 11, 2020
Global scope confusion again General Usage question , scope	52	7755	May 17, 2025
Toward a real and final solution to Julia’s variable scope issue Internals & Design	35	2992	June 6, 2023
Julia's assignment behavior differs from Fortran? General Usage fortran	47	4166	November 20, 2020
Why not an even-harder scope? Internals & Design	29	4067	November 27, 2020

Julia's loop scope behavior differs from Fortran?

Related topics