Merge branch 'aa/iszero' into patch-1

Author: ararslan

LICENSE.md

@@ -73,6 +73,7 @@ The following components of Julia's standard library have separate licenses:
 - base/fftw.jl (see [FFTW](http://fftw.org/doc/License-and-Copyright.html))
 - base/linalg/umfpack.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
 - base/linalg/cholmod.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
+- base/special/exp.jl (see [FREEBSD MSUN](https://github.com/freebsd/freebsd) [FreeBSD/2-clause BSD/Simplified BSD License])
 
 
 Julia's build process uses the following external tools:

base/broadcast.jl

@@ -202,7 +202,9 @@ Note that `dest` is only used to store the result, and does not supply
 arguments to `f` unless it is also listed in the `As`,
 as in `broadcast!(f, A, A, B)` to perform `A[:] = broadcast(f, A, B)`.
 """
-@inline function broadcast!{N}(f, C::AbstractArray, A, Bs::Vararg{Any,N})
+@inline broadcast!{N}(f, C::AbstractArray, A, Bs::Vararg{Any,N}) =
+    broadcast_c!(f, containertype(C, A, Bs...), C, A, Bs...)
+@inline function broadcast_c!{N}(f, ::Type, C::AbstractArray, A, Bs::Vararg{Any,N})
     shape = indices(C)
     @boundscheck check_broadcast_indices(shape, A, Bs...)
     keeps, Idefaults = map_newindexer(shape, A, Bs)

base/deprecated.jl

@@ -1242,7 +1242,9 @@ for (Bsig, A1sig, A2sig, gbb, funcname) in
     end  # let broadcast_cache
 end
 _broadcast_zpreserving!(args...) = broadcast!(args...)
-_broadcast_zpreserving(f, As...) = broadcast!(f, similar(Array{promote_op(f, map(eltype, As)...)}, Base.Broadcast.broadcast_indices(As...)), As...)
+# note: promote_eltype_op also deprecated, defined later in this file
+_broadcast_zpreserving(f, As...) =
+    broadcast!(f, similar(Array{_promote_eltype_op(f, As...)}, Base.Broadcast.broadcast_indices(As...)), As...)
 _broadcast_zpreserving{Tv1,Ti1,Tv2,Ti2}(f::Function, A_1::SparseMatrixCSC{Tv1,Ti1}, A_2::SparseMatrixCSC{Tv2,Ti2}) =
     _broadcast_zpreserving!(f, spzeros(promote_type(Tv1, Tv2), promote_type(Ti1, Ti2), Base.to_shape(Base.Broadcast.broadcast_indices(A_1, A_2))), A_1, A_2)
 _broadcast_zpreserving{Tv,Ti}(f::Function, A_1::SparseMatrixCSC{Tv,Ti}, A_2::Union{Array,BitArray,Number}) =
@@ -1502,8 +1504,21 @@ function frexp{T<:AbstractFloat}(A::Array{T})
     return (F, E)
 end
 
-# Calling promote_op is likely a bad idea, so deprecate its convenience wrapper promote_eltype_op
-@deprecate promote_eltype_op(op, As...) promote_op(op, map(eltype, As)...)
+# Deprecate promote_eltype_op (#19814, #19937)
+_promote_eltype_op(::Any) = Any
+_promote_eltype_op(op, A) = (@_inline_meta; promote_op(op, eltype(A)))
+_promote_eltype_op(op, A, B) = (@_inline_meta; promote_op(op, eltype(A), eltype(B)))
+_promote_eltype_op(op, A, B, C, D...) = (@_inline_meta; _promote_eltype_op(op, eltype(A), _promote_eltype_op(op, B, C, D...)))
+@inline function promote_eltype_op(args...)
+    depwarn("""
+            `promote_eltype_op` is deprecated and should not be used.
+            See https://github.com/JuliaLang/julia/issues/19669.""",
+            :promote_eltype_op)
+    _promote_eltype_op(args...)
+end
+
+# Rename LibGit2.Oid to LibGit2.GitHash (part of #19839)
+eval(Base.LibGit2, :(Base.@deprecate_binding Oid GitHash))
 
 function unsafe_wrap(::Type{String}, p::Union{Ptr{UInt8},Ptr{Int8}}, len::Integer, own::Bool=false)
     Base.depwarn("unsafe_wrap(String, ...) is deprecated; use `unsafe_string` instead.", :unsafe_wrap)

base/exports.jl

@@ -361,6 +361,7 @@ export
     isimag,
     iszero,
     issubnormal,
+    iszero,
     lcm,
     ldexp,
     leading_ones,

base/float.jl

@@ -738,9 +738,18 @@ exponent_one(::Type{Float16}) =     0x3c00
 exponent_half(::Type{Float16}) =    0x3800
 significand_mask(::Type{Float16}) = 0x03ff
 
+# integer size of float
+fpinttype(::Type{Float64}) = UInt64
+fpinttype(::Type{Float32}) = UInt32
+fpinttype(::Type{Float16}) = UInt16
+
 @pure significand_bits{T<:AbstractFloat}(::Type{T}) = trailing_ones(significand_mask(T))
 @pure exponent_bits{T<:AbstractFloat}(::Type{T}) = sizeof(T)*8 - significand_bits(T) - 1
 @pure exponent_bias{T<:AbstractFloat}(::Type{T}) = Int(exponent_one(T) >> significand_bits(T))
+# maximum float exponent
+@pure exponent_max{T<:AbstractFloat}(::Type{T}) = Int(exponent_mask(T) >> significand_bits(T)) - exponent_bias(T)
+# maximum float exponent without bias
+@pure exponent_raw_max{T<:AbstractFloat}(::Type{T}) = Int(exponent_mask(T) >> significand_bits(T))
 
 ## Array operations on floating point numbers ##
 

base/libgit2/blob.jl

@@ -8,10 +8,10 @@ function Base.length(blob::GitBlob)
     return ccall((:git_blob_rawsize, :libgit2), Int64, (Ptr{Void},), blob.ptr)
 end
 
-function lookup(repo::GitRepo, oid::Oid)
+function lookup(repo::GitRepo, oid::GitHash)
     blob_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_blob_lookup, :libgit2), Cint,
-                  (Ptr{Ptr{Void}}, Ptr{Void}, Ref{Oid}),
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ref{GitHash}),
                    blob_ptr_ptr, repo.ptr, Ref(oid))
     return GitBlob(blob_ptr_ptr[])
 end

base/libgit2/callbacks.jl

@@ -255,9 +255,9 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring,
 end
 
 function fetchhead_foreach_callback(ref_name::Cstring, remote_url::Cstring,
-                        oid::Ptr{Oid}, is_merge::Cuint, payload::Ptr{Void})
+                        oid::Ptr{GitHash}, is_merge::Cuint, payload::Ptr{Void})
     fhead_vec = unsafe_pointer_to_objref(payload)::Vector{FetchHead}
-    push!(fhead_vec, FetchHead(unsafe_string(ref_name), unsafe_string(remote_url), Oid(oid), is_merge == 1))
+    push!(fhead_vec, FetchHead(unsafe_string(ref_name), unsafe_string(remote_url), GitHash(oid), is_merge == 1))
     return Cint(0)
 end
 
@@ -266,4 +266,4 @@ mirror_cb() = cfunction(mirror_callback, Cint, (Ptr{Ptr{Void}}, Ptr{Void}, Cstri
 "C function pointer for `credentials_callback`"
 credentials_cb() = cfunction(credentials_callback, Cint, (Ptr{Ptr{Void}}, Cstring, Cstring, Cuint, Ptr{Void}))
 "C function pointer for `fetchhead_foreach_callback`"
-fetchhead_foreach_cb() = cfunction(fetchhead_foreach_callback, Cint, (Cstring, Cstring, Ptr{Oid}, Cuint, Ptr{Void}))
+fetchhead_foreach_cb() = cfunction(fetchhead_foreach_callback, Cint, (Cstring, Cstring, Ptr{GitHash}, Cuint, Ptr{Void}))

base/libgit2/commit.jl

@@ -30,11 +30,11 @@ function commit(repo::GitRepo,
                 committer::GitSignature,
                 tree::GitTree,
                 parents::GitCommit...)
-    commit_id_ptr = Ref(Oid())
+    commit_id_ptr = Ref(GitHash())
     nparents = length(parents)
     parentptrs = Ptr{Void}[c.ptr for c in parents]
     @check ccall((:git_commit_create, :libgit2), Cint,
-                 (Ptr{Oid}, Ptr{Void}, Ptr{UInt8},
+                 (Ptr{GitHash}, Ptr{Void}, Ptr{UInt8},
                   Ptr{SignatureStruct}, Ptr{SignatureStruct},
                   Ptr{UInt8}, Ptr{UInt8}, Ptr{Void},
                   Csize_t, Ptr{Ptr{Void}}),
@@ -50,8 +50,8 @@ function commit(repo::GitRepo, msg::AbstractString;
                 refname::AbstractString=Consts.HEAD_FILE,
                 author::Signature = Signature(repo),
                 committer::Signature = Signature(repo),
-                tree_id::Oid = Oid(),
-                parent_ids::Vector{Oid}=Oid[])
+                tree_id::GitHash = GitHash(),
+                parent_ids::Vector{GitHash}=GitHash[])
     # Retrieve tree identifier
     if iszero(tree_id)
         tree_id = with(GitIndex, repo) do idx; write_tree!(idx) end
@@ -60,12 +60,12 @@ function commit(repo::GitRepo, msg::AbstractString;
     # Retrieve parents from HEAD
     if isempty(parent_ids)
         try # if throws then HEAD not found -> empty repo
-            push!(parent_ids, Oid(repo, refname))
+            push!(parent_ids, GitHash(repo, refname))
         end
     end
 
     # return commit id
-    commit_id  = Oid()
+    commit_id  = GitHash()
 
     # get necessary objects
     tree = get(GitTree, repo, tree_id)

base/libgit2/index.jl

@@ -18,9 +18,9 @@ function write!(idx::GitIndex)
 end
 
 function write_tree!(idx::GitIndex)
-    oid_ptr = Ref(Oid())
+    oid_ptr = Ref(GitHash())
     @check ccall((:git_index_write_tree, :libgit2), Cint,
-                 (Ptr{Oid}, Ptr{Void}), oid_ptr, idx.ptr)
+                 (Ptr{GitHash}, Ptr{Void}), oid_ptr, idx.ptr)
     return oid_ptr[]
 end
 
@@ -29,7 +29,7 @@ function owner(idx::GitIndex)
     return Base.get(idx.nrepo)
 end
 
-function read_tree!(idx::GitIndex, tree_id::Oid)
+function read_tree!(idx::GitIndex, tree_id::GitHash)
     repo = owner(idx)
     tree = get(GitTree, repo, tree_id)
     try

base/libgit2/libgit2.jl

@@ -35,12 +35,12 @@ include("callbacks.jl")
 using .Error
 
 immutable State
-    head::Oid
-    index::Oid
-    work::Oid
+    head::GitHash
+    index::GitHash
+    work::GitHash
 end
 
-"""Return HEAD Oid as string"""
+"""Return HEAD GitHash as string"""
 function head(pkg::AbstractString)
     with(GitRepo, pkg) do repo
         string(head_oid(repo))
@@ -213,18 +213,18 @@ function branch!(repo::GitRepo, branch_name::AbstractString,
             if branch_rmt_ref === nothing
                 with(head(repo)) do head_ref
                     with(peel(GitCommit, head_ref)) do hrc
-                        Oid(hrc)
+                        GitHash(hrc)
                     end
                 end
             else
                 tmpcmt = with(peel(GitCommit, branch_rmt_ref)) do hrc
-                    Oid(hrc)
+                    GitHash(hrc)
                 end
                 close(branch_rmt_ref)
                 tmpcmt
             end
         else
-            Oid(commit)
+            GitHash(commit)
         end
         iszero(commit_id) && return
         cmt =  get(GitCommit, repo, commit_id)
@@ -278,13 +278,13 @@ function checkout!(repo::GitRepo, commit::AbstractString = "";
             head_name = shortname(head_ref)
             # if it is HEAD use short OID instead
             if head_name == Consts.HEAD_FILE
-                head_name = string(Oid(head_ref))
+                head_name = string(GitHash(head_ref))
             end
         end
     end
 
     # search for commit to get a commit object
-    obj = get(GitUnknownObject, repo, Oid(commit))
+    obj = get(GitUnknownObject, repo, GitHash(commit))
     obj === nothing && return
     try
         peeled = peel(obj, Consts.OBJ_COMMIT)
@@ -293,7 +293,7 @@ function checkout!(repo::GitRepo, commit::AbstractString = "";
                        CheckoutOptions()
         try
             # detach commit
-            obj_oid = Oid(peeled)
+            obj_oid = GitHash(peeled)
             ref = GitReference(repo, obj_oid, force=force,
                 msg="libgit2.checkout: moving from $head_name to $(string(obj_oid))")
             close(ref)
@@ -340,7 +340,7 @@ function reset!(repo::GitRepo, committish::AbstractString, pathspecs::AbstractSt
 end
 
 """ git reset [--soft | --mixed | --hard] <commit> """
-function reset!(repo::GitRepo, commit::Oid, mode::Cint = Consts.RESET_MIXED)
+function reset!(repo::GitRepo, commit::GitHash, mode::Cint = Consts.RESET_MIXED)
     obj = get(GitUnknownObject, repo, commit)
     # object must exist for reset
     obj === nothing && throw(GitError(Error.Object, Error.ERROR, "Commit `$(string(commit))` object not found"))
@@ -425,7 +425,7 @@ function merge!(repo::GitRepo;
                     LibGit2.get(String, cfg, "branch.$branchname.remote")
                 end
                 obj = with(GitReference(repo, "refs/remotes/$remotename/$branchname")) do ref
-                    LibGit2.Oid(ref)
+                    LibGit2.GitHash(ref)
                 end
                 with(get(GitCommit, repo, obj)) do cmt
                     LibGit2.create_branch(repo, branchname, cmt)
@@ -528,7 +528,7 @@ function authors(repo::GitRepo)
 end
 
 function snapshot(repo::GitRepo)
-    head = Oid(repo, Consts.HEAD_FILE)
+    head = GitHash(repo, Consts.HEAD_FILE)
     index = with(GitIndex, repo) do idx; write_tree!(idx) end
     work = try
         with(GitIndex, repo) do idx

base/libgit2/merge.jl

@@ -1,9 +1,9 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-function GitAnnotated(repo::GitRepo, commit_id::Oid)
+function GitAnnotated(repo::GitRepo, commit_id::GitHash)
     ann_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_annotated_commit_lookup, :libgit2), Cint,
-                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Oid}),
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{GitHash}),
                    ann_ptr_ptr, repo.ptr, Ref(commit_id))
     return GitAnnotated(repo, ann_ptr_ptr[])
 end
@@ -19,7 +19,7 @@ end
 function GitAnnotated(repo::GitRepo, fh::FetchHead)
     ann_ref_ref = Ref{Ptr{Void}}(C_NULL)
     @check ccall((:git_annotated_commit_from_fetchhead, :libgit2), Cint,
-                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring, Ptr{Oid}),
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring, Ptr{GitHash}),
                    ann_ref_ref, repo.ptr, fh.name, fh.url, Ref(fh.oid))
     return GitAnnotated(repo, ann_ref_ref[])
 end
@@ -29,14 +29,14 @@ function GitAnnotated(repo::GitRepo, comittish::AbstractString)
     try
         cmt = peel(obj, Consts.OBJ_COMMIT)
         cmt === nothing && return nothing
-        return GitAnnotated(repo, Oid(cmt))
+        return GitAnnotated(repo, GitHash(cmt))
     finally
         close(obj)
     end
 end
 
 function commit(ann::GitAnnotated)
-    return Oid(ccall((:git_annotated_commit_id, :libgit2), Ptr{Oid}, (Ptr{Void},), ann.ptr))
+    return GitHash(ccall((:git_annotated_commit_id, :libgit2), Ptr{GitHash}, (Ptr{Void},), ann.ptr))
 end
 
 function merge_analysis(repo::GitRepo, anns::Vector{GitAnnotated})
@@ -58,7 +58,7 @@ function ffmerge!(repo::GitRepo, ann::GitAnnotated)
     try
         checkout_tree(repo, cmt)
         with(head(repo)) do head_ref
-            cmt_oid = Oid(cmt)
+            cmt_oid = GitHash(cmt)
             msg = "libgit2.merge: fastforward $(string(cmt_oid)) into $(name(head_ref))"
             new_head_ref = if reftype(head_ref) == Consts.REF_OID
                 target!(head_ref, cmt_oid, msg=msg)
@@ -148,17 +148,17 @@ function merge!(repo::GitRepo, anns::Vector{GitAnnotated}, fastforward::Bool;
 end
 
 function merge_base(repo::GitRepo, one::AbstractString, two::AbstractString)
-    oid1_ptr = Ref(Oid(one))
-    oid2_ptr = Ref(Oid(two))
-    moid_ptr = Ref(Oid())
+    oid1_ptr = Ref(GitHash(one))
+    oid2_ptr = Ref(GitHash(two))
+    moid_ptr = Ref(GitHash())
     moid = try
         @check ccall((:git_merge_base, :libgit2), Cint,
-                (Ptr{Oid}, Ptr{Void}, Ptr{Oid}, Ptr{Oid}),
+                (Ptr{GitHash}, Ptr{Void}, Ptr{GitHash}, Ptr{GitHash}),
                 moid_ptr, repo.ptr, oid1_ptr, oid2_ptr)
         moid_ptr[]
     catch e
         #warn("Pkg:",path(repo),"=>",e.msg)
-        Oid()
+        GitHash()
     end
     return moid
 end