missing floatmin, floatmax, and issubnormal for Dual

[stevengj]

julia> x = ForwardDiff.Dual(1.0)
Dual{Nothing}(1.0)

julia> floatmin(x) # expected result: floatmin(1.0)
ERROR: MethodError: no method matching floatmin(::ForwardDiff.Dual{Nothing, Float64, 0})
  ...

julia> floatmax(x) # expected result: floatmax(1.0)
ERROR: MethodError: no method matching floatmax(::ForwardDiff.Dual{Nothing, Float64, 0})
  ...

julia> issubnormal(x) # expected result: false
ERROR: MethodError: no method matching issubnormal(::ForwardDiff.Dual{Nothing, Float64, 0})
  ...

[devmotion]

Are floatmin and floatmax supposed to be defined for instances? There was a PR but my impression based on the docstring was that they are only to be defined for types:

help?> floatmin
search: floatmin floatmax float Float64 Float32 Float16 Cfloat findmin

  floatmin(T = Float64)

  Return the smallest positive normal number representable by the floating-point type T.

  Examples
  ≡≡≡≡≡≡≡≡

  julia> floatmin(Float16)
  Float16(6.104e-5)

  julia> floatmin(Float32)
  1.1754944f-38

  julia> floatmin()
  2.2250738585072014e-308

help?> floatmax
search: floatmax floatmin float findmax Float64 Float32 Float16 Cfloat

  floatmax(T = Float64)

  Return the largest finite number representable by the floating-point type T.

  See also: typemax, floatmin, eps.

  Examples
  ≡≡≡≡≡≡≡≡

  julia> floatmax(Float16)
  Float16(6.55e4)

  julia> floatmax(Float32)
  3.4028235f38

  julia> floatmax()
  1.7976931348623157e308

  julia> typemax(Float64)
  Inf

Unsurprisingly, issubnormal is different and documented to be defined on instances:

help?> issubnormal
search: issubnormal

  issubnormal(f) -> Bool

  Test whether a floating point number is subnormal.

  An IEEE floating point number is [subnormal](https://en.wikipedia.org/wiki/Subnormal_number) when its exponent bits are zero and its significand is not zero.

  Examples
  ≡≡≡≡≡≡≡≡

  julia> floatmin(Float32)
  1.1754944f-38

  julia> issubnormal(1.0f-37)
  false

  julia> issubnormal(1.0f-38)
  true

[stevengj]

floatmin and floatmax are indeed defined for instances.

> julia> floatmin(1.0)
2.2250738585072014e-308

This is also true for lots of other functions like typemin and one and maxintfloat, and has been true for a long time. This should probably be fixed in the documentation: JuliaLang/julia#63450

Note that the definition in Base is:

floatmin(x::T) where {T<:AbstractFloat} = floatmin(T)

which just falls through to the type, but this fallthrough only occurs for AbstractFloat instances and not wrappers like Dual numbers.

[stevengj]

It looks like there are indeed floatmin and floatmax functions for Type{<:Dual}, so it just needs to be extended to instances:

julia> x = ForwardDiff.Dual(1.0)
Dual{Nothing}(1.0)

julia> floatmin(typeof(x)) # works
Dual{Nothing}(2.2250738585072014e-308)

Note that you already have typemin and typemax defined for instances, even though this is similarly undocumented:

julia> typemin(x)
Dual{Nothing}(-Inf)

However, maxintfloat is missing for both instances and types:

julia> maxintfloat(typeof(x))
ERROR: MethodError: no method matching maxintfloat(::Type{ForwardDiff.Dual{Nothing, Float64, 0}})
  ...

julia> maxintfloat(x)
ERROR: MethodError: no method matching maxintfloat(::ForwardDiff.Dual{Nothing, Float64, 0})
  ...

[devmotion]

The main question is still whether floatmin and floatmax (and typemin and typemax which likely were added without considering this question) are supposed to be defined on instances. I'd like to be certain about this before extending Base methods in an unintended way.

[stevengj]

As I commented in JuliaLang/julia#63451, typemin and floatmin (previously called realmin) etcetera have been defined for instances since Julia 0.1. It's clearly just an omission in the docs that needs to be rectified.