Make base a keyword for trunc, floor, ceil, round, signif (JuliaLang#…

…26156)

NEWS.md

@@ -604,6 +604,9 @@ Library improvements
  * `IOBuffer` can take the `sizehint` keyword argument to suggest a capacity of
  the buffer ([#25944]).
 
+ * `trunc`, `floor`, `ceil`, `round`, and `signif` specify `base` using a
+ keyword argument. ([#26156])
+
 Compiler/Runtime improvements
 -----------------------------
 

base/complex.jl

@@ -960,9 +960,9 @@ function round(z::Complex{<:AbstractFloat}, ::RoundingMode{MR}, ::RoundingMode{M
 end
 round(z::Complex) = Complex(round(real(z)), round(imag(z)))
 
-function round(z::Complex, digits::Integer, base::Integer=10)
- Complex(round(real(z), digits, base),
- round(imag(z), digits, base))
+function round(z::Complex, digits::Integer; base::Integer = 10)
+ Complex(round(real(z), digits, base = base),
+ round(imag(z), digits, base = base))
 end
 
 float(z::Complex{<:AbstractFloat}) = z

base/deprecated.jl

@@ -1400,6 +1400,13 @@ end
  link_pipe!(pipe, reader_supports_async = julia_only_read, writer_supports_async = julia_only_write),
  false)
 
+# PR 26156
+@deprecate trunc(x, digits, base) trunc(x, digits, base = base)
+@deprecate floor(x, digits, base) floor(x, digits, base = base)
+@deprecate ceil(x, digits, base) ceil(x, digits, base = base)
+@deprecate round(x, digits, base) round(x, digits, base = base)
+@deprecate signif(x, digits, base) signif(x, digits, base = base)
+
 # Remember to delete the module when removing this
 @eval Base.Math module JuliaLibm
  Base.@deprecate log Base.log

base/floatfuncs.jl

@@ -43,7 +43,8 @@ maxintfloat() = maxintfloat(Float64)
 isinteger(x::AbstractFloat) = (x - trunc(x) == 0)
 
 """
- round([T,] x, [digits, [base]], [r::RoundingMode])
+ round([T,] x, [r::RoundingMode])
+ round(x, [digits; base = 10])
 
 Rounds `x` to an integer value according to the provided
 [`RoundingMode`](@ref), returning a value of the same type as `x`. When not
@@ -71,14 +72,14 @@ rounded.
 [`InexactError`](@ref) if the value is not representable.
 
 `round(x, digits)` rounds to the specified number of digits after the decimal place (or
-before if negative). `round(x, digits, base)` rounds using a base other than 10.
+before if negative). `round(x, digits, base = base)` rounds using a base other than 10.
 
 # Examples
 ```jldoctest
 julia> round(pi, 2)
 3.14
 
-julia> round(pi, 3, 2)
+julia> round(pi, 3, base = 2)
 3.125
 ```
 
@@ -141,7 +142,7 @@ function _signif_og(x, digits, base)
 end
 
 """
- signif(x, digits, [base])
+ signif(x, digits; base = 10)
 
 Rounds (in the sense of [`round`](@ref)) `x` so that there are `digits` significant digits, under a
 base `base` representation, default 10.
@@ -151,11 +152,11 @@ base `base` representation, default 10.
 julia> signif(123.456, 2)
 120.0
 
-julia> signif(357.913, 4, 2)
+julia> signif(357.913, 4, base = 2)
 352.0
 ```
 """
-function signif(x::Real, digits::Integer, base::Integer=10)
+function signif(x::Real, digits::Integer; base::Integer = 10)
  digits < 1 && throw(DomainError(digits, "`digits` cannot be less than 1."))
 
  x = float(x)
@@ -171,7 +172,7 @@ end
 
 for f in (:round, :ceil, :floor, :trunc)
  @eval begin
- function ($f)(x::Real, digits::Integer, base::Integer=10)
+ function ($f)(x::Real, digits::Integer; base::Integer = 10)
  x = float(x)
  og = convert(eltype(x),base)^digits
  r = ($f)(x * og) / og

base/int.jl

@@ -478,7 +478,7 @@ mod(x::Integer, ::Type{T}) where {T<:Integer} = rem(x, T)
 unsafe_trunc(::Type{T}, x::Integer) where {T<:Integer} = rem(x, T)
 
 """
- trunc([T,] x, [digits, [base]])
+ trunc([T,] x, [digits; base = 10])
 
 `trunc(x)` returns the nearest integral value of the same type as `x` whose absolute value
 is less than or equal to `x`.
@@ -491,7 +491,7 @@ not representable.
 function trunc end
 
 """
- floor([T,] x, [digits, [base]])
+ floor([T,] x, [digits; base = 10])
 
 `floor(x)` returns the nearest integral value of the same type as `x` that is less than or
 equal to `x`.
@@ -504,7 +504,7 @@ not representable.
 function floor end
 
 """
- ceil([T,] x, [digits, [base]])
+ ceil([T,] x, [digits; base = 10])
 
 `ceil(x)` returns the nearest integral value of the same type as `x` that is greater than or
 equal to `x`.

test/floatfuncs.jl

@@ -79,11 +79,11 @@ end
 @testset "significant digits" begin
  # (would be nice to have a smart vectorized
  # version of signif)
- @test signif(123.456,1) ≈ 100.
- @test signif(123.456,3) ≈ 123.
- @test signif(123.456,5) ≈ 123.46
- @test signif(123.456,8,2) ≈ 123.5
- @test signif(123.456,2,4) ≈ 128.0
+ @test signif(123.456, 1) ≈ 100.
+ @test signif(123.456, 3) ≈ 123.
+ @test signif(123.456, 5) ≈ 123.46
+ @test signif(123.456, 8, base = 2) ≈ 123.5
+ @test signif(123.456, 2, base = 4) ≈ 128.0
  @test signif(0.0, 1) === 0.0
  @test signif(-0.0, 1) === -0.0
  @test signif(1.2, 2) === 1.2

test/rounding.jl

@@ -312,18 +312,18 @@ end
  end
 end
 @testset "rounding in other bases" begin
- @test round(pi,2,2) ≈ 3.25
- @test round(pi,3,2) ≈ 3.125
- @test round(pi,3,5) ≈ 3.144
+ @test round(pi, 2, base = 2) ≈ 3.25
+ @test round(pi, 3, base = 2) ≈ 3.125
+ @test round(pi, 3, base = 5) ≈ 3.144
 end
 @testset "vectorized trunc/round/floor/ceil with digits/base argument" begin
  a = rand(2, 2, 2)
  for f in (round, trunc, floor, ceil)
  @test f.(a[:, 1, 1], 2) == map(x->f(x, 2), a[:, 1, 1])
  @test f.(a[:, :, 1], 2) == map(x->f(x, 2), a[:, :, 1])
- @test f.(a, 9, 2) == map(x->f(x, 9, 2), a)
- @test f.(a[:, 1, 1], 9, 2) == map(x->f(x, 9, 2), a[:, 1, 1])
- @test f.(a[:, :, 1], 9, 2) == map(x->f(x, 9, 2), a[:, :, 1])
- @test f.(a, 9, 2) == map(x->f(x, 9, 2), a)
+ @test f.(a, 9, base = 2) == map(x->f(x, 9, base = 2), a)
+ @test f.(a[:, 1, 1], 9, base = 2) == map(x->f(x, 9, base = 2), a[:, 1, 1])
+ @test f.(a[:, :, 1], 9, base = 2) == map(x->f(x, 9, base = 2), a[:, :, 1])
+ @test f.(a, 9, base = 2) == map(x->f(x, 9, base = 2), a)
  end
 end