Add assert_floating_point

Author: emmt

NEWS.md

@@ -4,6 +4,18 @@ This page describes the most important changes in `TypeUtils`. The format is bas
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
 [Semantic Versioning](https://semver.org/spec).
 
+## Unreleased
+
+## Added
+
+- Macro `@assert_floating_point` to assert whether arguments or variables of a function
+  do use floating-point for storing their value(s).
+
+- New function `assert_floating_point` to assert whether an object does use floating-point
+  for storing its value(s). This method is a *trait*: its result only depend on the type
+  of its argument and this type may be directly specified.
+
+
 ## Version 1.5.1 (2025-04-12)
 
 ### Changed

src/TypeUtils.jl

@@ -1,6 +1,7 @@
 module TypeUtils
 
 export
+    @assert_floating_point,
     ArrayAxes,
     ArrayAxis,
     ArrayShape,
@@ -15,6 +16,7 @@ export
     as_array_size,
     as_eltype,
     as_return,
+    assert_floating_point,
     bare_type,
     convert_bare_type,
     convert_eltype,
@@ -54,6 +56,22 @@ macro public(args::Union{Symbol,Expr}...)
 end
 VERSION ≥ v"1.11.0-DEV.469" && eval(Expr(:public, Symbol("@public")))
 
+"""
+    @assert_floating_point A B ...
+
+throws an `ArgumentError` exception if any of the variables `A`, `B`, etc. does not use
+floating-point to store its value(s).
+
+See also [`assert_floating_point`](@ref).
+
+"""
+macro assert_floating_point(args::Symbol...)
+    code = [:(assert_floating_point($(QuoteNode(arg)), $(esc(arg)))) for arg in args]
+    return quote
+        $(code...)
+    end
+end
+
 """
     c = TypeUtils.Converter(f, T::Type)
 
@@ -878,6 +896,52 @@ for any `x`.
 convert_floating_point_type(::Type{T}) where {T} =
     Converter(convert_floating_point_type, floating_point_type(T))
 
+"""
+    assert_floating_point(Bool, x) -> bool
+
+yields whether `x` uses floating-point to store its value(s). For n-tuples, the same
+floating-point type must be used for all values.
+
+"""
+assert_floating_point(::Type{Bool}, x) =
+    assert_floating_point(Bool, typeof(x))
+
+assert_floating_point(::Type{Bool}, ::Type{<:AbstractArray{T}}) where {T} =
+    assert_floating_point(Bool, T)
+
+assert_floating_point(::Type{Bool}, ::Type{<:NTuple{N,T}}) where {N,T} =
+    assert_floating_point(Bool, T)
+
+assert_floating_point(::Type{Bool}, ::DataType) = false
+
+assert_floating_point(::Type{Bool}, ::Type{T}) where {T<:Number} =
+    _assert_floating_point(Bool, real_type(T))
+
+_assert_floating_point(::Type{Bool}, ::Type{T}) where {T<:AbstractFloat} = isconcretetype(T)
+_assert_floating_point(::Type{Bool}, ::Type{T}) where {T<:Number} = false
+
+"""
+    assert_floating_point([name,] x)
+
+throws an exception if `x` does not use floating-point to store its value(s). Optional
+`name` argument is to specify the name to use for the error message.
+
+See also [`@assert_floating_point`](@ref).
+
+"""
+assert_floating_point(x) = assert_floating_point(typeof(x))
+assert_floating_point(::Type{T}) where {T} =
+    assert_floating_point(Bool, T) ? nothing : throw_not_floating_point(T)
+
+assert_floating_point(name::Union{Symbol,AbstractString}, x) = assert_floating_point(name, typeof(x))
+assert_floating_point(name::Union{Symbol,AbstractString}, ::Type{T}) where {T} =
+    assert_floating_point(Bool, T) ? nothing : throw_not_floating_point(name, T)
+
+@noinline throw_not_floating_point(::Type{T}) where {T} =
+    throw(ArgumentError("type `$T` is not floating-point"))
+@noinline throw_not_floating_point(name::Union{Symbol,AbstractString}, ::Type{T}) where {T} =
+    throw(ArgumentError("argument or variable `$name` of type `$T` is not floating-point"))
+
 """
     promote_eltype(args...)
 

test/runtests.jl

@@ -669,6 +669,36 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
             @test map(x -> convert_floating_point_type(Float32, x), vals) === @inferred map(convert_floating_point_type(Float32), vals)
         end
 
+        # assert_floating_point
+        @test !assert_floating_point(Bool, 1)
+        @test !assert_floating_point(Bool, π)
+        @test !assert_floating_point(Bool, 1//2)
+        @test !assert_floating_point(Bool, "hello")
+        @test !assert_floating_point(Bool, [0x1, 0x2])
+        @test !assert_floating_point(Bool, (0x1, -1))
+        @test  assert_floating_point(Bool, 1.0)
+        @test  assert_floating_point(Bool, complex(-2f0,3f0))
+        @test  assert_floating_point(Bool, [0.0f0, 2.0f0])
+        @test !assert_floating_point(Bool, Int)
+        @test !assert_floating_point(Bool, AbstractFloat)
+        @test  assert_floating_point(Bool, Float16)
+        @test  assert_floating_point(Bool, Float32)
+        @test  assert_floating_point(Bool, Float64)
+        @test  assert_floating_point(Bool, Complex{Float32})
+        @test  assert_floating_point(Bool, AbstractRange{Float64})
+        # only ok for homogeneous tuples
+        @test !assert_floating_point(Bool, (-1.0, 2.0f0))
+        @test  assert_floating_point(Bool, (-1.0, 2.0))
+        @test !assert_floating_point(Bool, Tuple{Float64,Float32})
+        @test  assert_floating_point(Bool, Tuple{Float32,Float32})
+        #
+        x, y = 2, 3.0
+        @test assert_floating_point(y) === nothing
+        @test assert_floating_point("y", y) === nothing
+        @test_throws Exception assert_floating_point(x)
+        @test_throws Exception assert_floating_point(:x, x)
+        @test_throws Exception @assert_floating_point x y
+
         # unitless
         @test bare_type(Real)         === @inferred unitless(Real)
         @test bare_type(Integer)      === @inferred unitless(Integer)