Merge branch 'master' of github.com:JuliaLang/julia

Author: ViralBShah

README.md

@@ -395,6 +395,7 @@ The following distributions include julia, but the versions may be out of date d
 * openSUSE
   * Stable package for openSUSE: [OBS page](https://build.opensuse.org/package/show/science/julia), [1 Click Install](http://software.opensuse.org/download.html?project=science&package=julia)
   * Git package for openSUSE: [OBS page](https://build.opensuse.org/package/show/science/julia-unstable), [1 Click Install](http://software.opensuse.org/download.html?project=science&package=julia-unstable)
+* [NixOS](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/compilers/julia)
 * Ubuntu
   * [Ubuntu 13.04 (Raring Ringtail)](http://packages.ubuntu.com/raring/julia)
   * [Nightly builds PPA](https://launchpad.net/~staticfloat/+archive/julianightlies) (depends on the [julia-deps PPA](https://launchpad.net/~staticfloat/+archive/julia-deps/))

base/array.jl

@@ -1455,20 +1455,24 @@ symdiff(a, b, rest...) = symdiff(a, symdiff(b, rest...))
 _cumsum_type{T<:Number}(v::AbstractArray{T}) = typeof(+zero(T))
 _cumsum_type(v) = typeof(v[1]+v[1])
 
-for (f, fp, op) = ((:cumsum, :cumsum_pairwise, :+),
-                   (:cumprod, :cumprod_pairwise, :*) )
-    # in-place cumsum of c = s+v(i1:n), using pairwise summation as for sum
-    @eval function ($fp)(v::AbstractVector, c::AbstractVector, s, i1, n)
+for (f, fp, op) = ((:cumsum, :cumsum_pairwise!, :+),
+                   (:cumprod, :cumprod_pairwise!, :*) )
+    # in-place cumsum of c = s+v[range(i1,n)], using pairwise summation
+    @eval function ($fp){T}(v::AbstractVector, c::AbstractVector{T}, s, i1, n)
+        local s_::T # for sum(v[range(i1,n)]), i.e. sum without s
         if n < 128
-            @inbounds c[i1] = ($op)(s, v[i1])
+            @inbounds s_ = v[i1]
+            @inbounds c[i1] = ($op)(s, s_)
             for i = i1+1:i1+n-1
-                @inbounds c[i] = $(op)(c[i-1], v[i])
+                @inbounds s_ = $(op)(s_, v[i])
+                @inbounds c[i] = $(op)(s, s_)
             end
         else
-            n2 = div(n,2)
-            ($fp)(v, c, s, i1, n2)
-            ($fp)(v, c, c[(i1+n2)-1], i1+n2, n-n2)
+            n2 = n >> 1
+            s_ = ($fp)(v, c, s, i1, n2)
+            s_ = $(op)(s_, ($fp)(v, c, s + s_, i1+n2, n-n2))
         end
+        return s_
     end
 
     @eval function ($f)(v::AbstractVector)

base/client.jl

@@ -375,7 +375,7 @@ function early_init()
                                     get(ENV, "GOTOBLAS_MAIN_FREE", "1"))
     Sys.init_sysinfo()
     if CPU_CORES > 8 && !("OPENBLAS_NUM_THREADS" in keys(ENV)) && !("OMP_NUM_THREADS" in keys(ENV))
-        # Prevent openblas from stating to many threads, unless/until specifically requested
+        # Prevent openblas from starting too many threads, unless/until specifically requested
         ENV["OPENBLAS_NUM_THREADS"] = 8
     end
 end

base/pkg/entry.jl

@@ -690,8 +690,8 @@ function test!(pkg::AbstractString, errs::Vector{AbstractString}, notests::Vecto
         cd(dirname(test_path)) do
             try
                 color = Base.have_color? "--color=yes" : "--color=no"
-                codecov = coverage? "--code-coverage=user" : "--code-coverage=none"
-                run(`$JULIA_HOME/julia $codecov $color $test_path`)
+                codecov = coverage? "--code-coverage=user --inline=no" : "--code-coverage=none"
+                run(`$JULIA_HOME/julia --check-bounds=yes $codecov $color $test_path`)
                 info("$pkg tests passed")
             catch err
                 warnbanner(err, label="[ ERROR: $pkg ]")

base/primes.jl

@@ -93,6 +93,10 @@ function factor{T<:Integer}(n::T)
                 n = oftype(n, div(n,p))
             end
             n == 1 && return h
+            if isprime(n)
+                h[n] = 1
+                return h
+            end
             s = isqrt(n)
         end
     end
@@ -103,7 +107,9 @@ function factor{T<:Integer}(n::T)
                 h[p] = get(h,p,0)+1
                 n = oftype(n, div(n,p))
             end
-            if n == 1
+            n == 1 && return h
+            if isprime(n)
+                h[n] = 1
                 return h
             end
             s = isqrt(n)

base/reflection.jl

@@ -170,10 +170,8 @@ function which(f::ANY, t::(Type...))
         if !isa(f,Function)
             t = tuple(isa(f,Type) ? Type{f} : typeof(f), t...)
             f = call
-        else
-            if !isgeneric(f)
-                error("argument is not a generic function")
-            end
+        elseif !isgeneric(f)
+            error("argument is not a generic function")
         end
         m = ccall(:jl_gf_invoke_lookup, Any, (Any, Any), f, t)
         if m === nothing

doc/manual/variables.rst

@@ -143,7 +143,7 @@ adopt the following conventions:
 - Word separation can be indicated by underscores (``'_'``), but use of
   underscores is discouraged unless the name would be hard to read otherwise.
 - Names of ``Type``\ s begin with a capital letter and word separation is
-  shown with CamelCase instead of underscores.
+  shown with upper camel case instead of underscores.
 - Names of ``function``\ s and ``macro``\s are in lower case, without
   underscores.
 - Functions that write to their arguments have names that end in ``!``. 

examples/juliatypes.jl

@@ -219,9 +219,6 @@ function exists_issub(x, y, env, anyunions::Bool)
             push!(env.Runions.stack, false)
             found = exists_issub(x, y, env, true)
             pop!(env.Runions.stack)
-            if env.Lunions.more
-                return true  # return up to forall_exists_issub
-            end
         end
         found && return true
     end
@@ -230,7 +227,7 @@ end
 
 function issub_union(t, u::UnionT, env, R, state::UnionState)
     if state.depth > length(state.stack)
-        # at a new nesting depth, begin by just counting unions
+        # indicate that stack needs to grow
         state.more = true
         return true
     end
@@ -339,7 +336,7 @@ function rename(t::UnionAllT)
 end
 
 function issub_unionall(t::Ty, u::UnionAllT, env, R)
-    haskey(env.vars, u.var) && (u = rename(u))  # TODO: tests for this
+    haskey(env.vars, u.var) && (u = rename(u))
     env.vars[u.var] = Bounds(u.var.lb, u.var.ub, R)
     ans = R ? issub(t, u.T, env) : issub(u.T, t, env)
     delete!(env.vars, u.var)
@@ -634,8 +631,12 @@ function test_3()
 
     @test isequal_type((@UnionAll T tupletype(inst(RefT,T), T)),
                        (@UnionAll T @UnionAll S<:T tupletype(inst(RefT,T),S)))
+    @test isequal_type((@UnionAll T tupletype(inst(RefT,T), T)),
+                       (@UnionAll T @UnionAll S<:T @UnionAll R<:S tupletype(inst(RefT,T),R)))
     @test isequal_type((@UnionAll T tupletype(inst(RefT,T), T)),
                        (@UnionAll T @UnionAll T<:S<:T tupletype(inst(RefT,T),S)))
+    @test issub_strict((@UnionAll T tupletype(inst(RefT,T), T)),
+                       (@UnionAll T @UnionAll S>:T tupletype(inst(RefT,T),S)))
 end
 
 # level 4: Union
@@ -684,6 +685,8 @@ end
 
 # level 5: union and UnionAll
 function test_5()
+    u = Ty(Union(Int8,Int))
+
     @test issub(Ty((String,Array{Int,1})),
                 (@UnionAll T UnionT(tupletype(T,inst(ArrayT,T,1)),
                                     tupletype(T,inst(ArrayT,Ty(Int),1)))))
@@ -697,12 +700,12 @@ function test_5()
     @test !issub(Ty((Union(Vector{Int},Vector{Int8}),Vector{Int8})),
                  @UnionAll T tupletype(inst(ArrayT,T,1), inst(ArrayT,T,1)))
 
-    @test !issub(Ty(Vector{Int}), @UnionAll T>:Ty(Union(Int,Int8)) inst(ArrayT,T,1))
-    @test  issub(Ty(Vector{Integer}), @UnionAll T>:Ty(Union(Int,Int8)) inst(ArrayT,T,1))
-    @test  issub(Ty(Vector{Union(Int,Int8)}), @UnionAll T>:Ty(Union(Int,Int8)) inst(ArrayT,T,1))
+    @test !issub(Ty(Vector{Int}), @UnionAll T>:u inst(ArrayT,T,1))
+    @test  issub(Ty(Vector{Integer}), @UnionAll T>:u inst(ArrayT,T,1))
+    @test  issub(Ty(Vector{Union(Int,Int8)}), @UnionAll T>:u inst(ArrayT,T,1))
 
-    @test issub((@UnionAll Ty(Int)<:T<:Ty(Union(Int,Int8)) inst(ArrayT,T,1)),
-                (@UnionAll Ty(Int)<:T<:Ty(Union(Int,Int8)) inst(ArrayT,T,1)))
+    @test issub((@UnionAll Ty(Int)<:T<:u inst(ArrayT,T,1)),
+                (@UnionAll Ty(Int)<:T<:u inst(ArrayT,T,1)))
 
     # with varargs
     @test !issub(inst(ArrayT,tupletype(inst(ArrayT,Ty(Int)),inst(ArrayT,Ty(Vector{Int16})),inst(ArrayT,Ty(Vector{Int})),inst(ArrayT,Ty(Int)))),
@@ -716,6 +719,11 @@ function test_5()
 
     @test issub(tupletype(inst(ArrayT,Ty(Int)),inst(ArrayT,Ty(Vector{Int})),inst(ArrayT,Ty(Vector{Int})),inst(ArrayT,Ty(Int))),
                 @UnionAll S vatype(UnionT(inst(ArrayT,S),inst(ArrayT,inst(ArrayT,S,1)))))
+
+    B = @UnionAll S<:u tupletype(S, tupletype(AnyT,AnyT,AnyT), inst(RefT,S))
+    # these tests require renaming in issub_unionall
+    @test  issub((@UnionAll T<:B tupletype(Ty(Int8), T, inst(RefT,Ty(Int8)))), B)
+    @test !issub((@UnionAll T<:B tupletype(Ty(Int8), T, inst(RefT,T))),        B)
 end
 
 # tricky type variable lower bounds
@@ -861,9 +869,13 @@ function test_properties()
             @test isequal_type(T, rename(T))
         end
 
+        # inequality under wrapping
+        @test !isequal_type(T, inst(RefT,T))
+
         for S in menagerie
+            issubTS = issub(T, S)
             # transitivity
-            if issub(T, S)
+            if issubTS
                 for R in menagerie
                     if issub(S, R)
                         @test issub(T, R)  # issub(S, R) → issub(T, R)
@@ -879,12 +891,12 @@ function test_properties()
             @test isequal_type(T, S) == isequal_type(inst(RefT,T), inst(RefT,S))
 
             # covariance
-            @test issub(T, S) == issub(tupletype(T), tupletype(S))
-            @test issub(T, S) == issub(vatype(T), vatype(S))
-            @test issub(T, S) == issub(tupletype(T), vatype(S))
+            @test issubTS == issub(tupletype(T), tupletype(S))
+            @test issubTS == issub(vatype(T), vatype(S))
+            @test issubTS == issub(tupletype(T), vatype(S))
 
             # contravariance
-            @test issub(T, S) == issub(¬S, ¬T)
+            @test issubTS == issub(¬S, ¬T)
         end
     end
 end

src/module.c

@@ -21,6 +21,7 @@ jl_module_t *jl_new_module(jl_sym_t *name)
     m->type = (jl_value_t*)jl_module_type;
     assert(jl_is_symbol(name));
     m->name = name;
+    m->parent = NULL;
     m->constant_table = NULL;
     m->call_func = NULL;
     htable_new(&m->bindings, 0);

test/arrayops.jl

@@ -974,3 +974,8 @@ a = [ [ 1 0 0 ], [ 0 0 0 ] ]
 @test rotl90(a,4) == a
 @test rotr90(a,4) == a
 @test rot180(a,2) == a
+
+# issue #9648
+let x = fill(1.5f0, 10^7)
+    @test abs(1.5f7 - cumsum(x)[end]) < 3*eps(1.5f7)
+end

test/numbers.jl

@@ -2086,3 +2086,9 @@ end
 let x = big(-0.0)
     @test signbit(x) && !signbit(abs(x))
 end
+
+# issue #9611
+@test factor(int128(2)^101+1) == Dict(3=>1,845100400152152934331135470251=>1)
+
+# test second branch, after all small primes in list have been searched
+@test factor(10009 * int128(1000000000000037)) == Dict(10009=>1,1000000000000037=>1)