Update docstrings to reflect NaN (lack of) handling

Author: andrewjradcliffe

src/vfindminmax.jl

@@ -39,6 +39,9 @@ of an array are not well-supported. A workaround is possible by reshaping `A` bu
 the resultant performance is often only on par with `findmax`. As a temporary convenience,
 `findmax1` is provided for explicit uses of the re-shaping strategy, though the user
 is cautioned as to the performance problems.
+
+# Warning
+`NaN` values are not handled!
 """
 vfindmax(f::F, A, dims) where {F<:Function} = vfindminmax(f, >, typemin, A, dims)
 
@@ -55,6 +58,9 @@ of an array are not well-supported. A workaround is possible by reshaping `A` bu
 the resultant performance is often only on par with `findmin`. As a temporary convenience,
 `findmin1` is provided for explicit uses of the re-shaping strategy, though the user
 is cautioned as to the performance problems.
+
+# Warning
+`NaN` values are not handled!
 """
 vfindmin(f::F, A, dims) where {F<:Function} = vfindminmax(f, <, typemax, A, dims)
 
@@ -384,6 +390,10 @@ dimensions `dims`, which may be `::Int`, `::NTuple{M, Int} where {M}` or `::Colo
 Threaded.
 
 See also: [`vfindmax`](@ref)
+
+# Warning
+`NaN` values are not handled!
+
 """
 vtfindmax(f::F, A, dims) where {F<:Function} = vtfindminmax(f, >, typemin, A, dims)
 
@@ -395,6 +405,9 @@ dimensions `dims`, which may be `::Int`, `::NTuple{M, Int} where {M}` or `::Colo
 Threaded.
 
 See also: [`vfindmin`](@ref)
+
+# Warning
+`NaN` values are not handled!
 """
 vtfindmin(f::F, A, dims) where {F<:Function} = vtfindminmax(f, <, typemax, A, dims)
 # ::AbstractArray required in order for kwargs interface to work

src/vmapreduce.jl

@@ -68,13 +68,19 @@ vvprod(f::F, A, dims) where {F} = vvmapreduce(f, *, one, A, dims)
     vvmaximum(f, A::AbstractArray, dims=:)
 
 Compute the maximum value by calling `f` on each element of `A` over the given `dims`.
+
+# Warning
+`NaN` values are not handled!
 """
 vvmaximum(f::F, A, dims) where {F} = vvmapreduce(f, max, typemin, A, dims)
 
 """
     vvminimum(f, A::AbstractArray, dims=:)
 
 Compute the minimum value by calling `f` on each element of `A` over the given `dims`.
+
+# Warning
+`NaN` values are not handled!
 """
 vvminimum(f::F, A, dims) where {F} = vvmapreduce(f, min, typemax, A, dims)
 
@@ -130,6 +136,9 @@ vvminimum(A::AbstractArray) = vvmapreduce(identity, min, typemax, A, :)
 
 Compute the minimum and maximum values by calling `f`  on each element of of `A`
 over the given `dims`.
+
+# Warning
+`NaN` values are not handled!
 """
 vvextrema(f::F, A, dims) where {F} = collect(zip(vvminimum(f, A, dims), vvmaximum(f, A, dims)))
 vvextrema(f::F, A, ::Colon) where {F} = (vvminimum(f, A, :), vvmaximum(f, A, :))
@@ -632,13 +641,19 @@ vtprod(f::F, A, dims) where {F} = vtmapreduce(f, *, one, A, dims)
     vtmaximum(f, A::AbstractArray, dims=:)
 
 Compute the maximum value by calling `f` on each element of `A` over the given `dims`.
+
+# Warning
+`NaN` values are not handled!
 """
 vtmaximum(f::F, A, dims) where {F} = vtmapreduce(f, max, typemin, A, dims)
 
 """
     vtminimum(f, A::AbstractArray, dims=:)
 
 Compute the minimum value by calling `f` on each element of `A` over the given `dims`.
+
+# Warning
+`NaN` values are not handled!
 """
 vtminimum(f::F, A, dims) where {F} = vtmapreduce(f, min, typemax, A, dims)
 
@@ -688,6 +703,9 @@ vtminimum(A::AbstractArray) = vtmapreduce(identity, min, typemax, A, :)
 
 Compute the minimum and maximum values by calling `f`  on each element of of `A`
 over the given `dims`.
+
+# Warning
+`NaN` values are not handled!
 """
 vtextrema(f::F, A, dims) where {F} = collect(zip(vtminimum(f, A, dims), vtmaximum(f, A, dims)))
 vtextrema(f::F, A, ::Colon) where {F} = (vtminimum(f, A, :), vtmaximum(f, A, :))