fix behavior and docs of nextpow and prevpow. closes #4819

Author: JeffBezanson

NEWS.md

@@ -22,6 +22,9 @@ Library improvements
   * `consume(p)` extended to `consume(p, args...)`, allowing it
     to optionally pass `args...` back to the producer ([#4775]).
 
+  * `nextpow` and `prevpow` now return the `a^n` values instead of the
+    exponent `n` ([#4819])
+
 Deprecated or removed
 ---------------------
 
@@ -32,6 +35,7 @@ Deprecated or removed
 [#4766]: https://github.com/JuliaLang/julia/issues/4766
 [#4782]: https://github.com/JuliaLang/julia/issues/4782
 [#4759]: https://github.com/JuliaLang/julia/issues/4759
+[#4819]: https://github.com/JuliaLang/julia/issues/4819
 
 
 

base/combinatorics.jl

@@ -446,7 +446,7 @@ function nextprod(a::Vector{Int}, x)
     end
     k = length(a)
     v = ones(Int, k)            # current value of each counter
-    mx = int(a.^nextpow(a, x))  # maximum value of each counter
+    mx = int(nextpow(a, x))     # maximum value of each counter
     v[1] = mx[1]                # start at first case that is >= x
     p::morebits(Int) = mx[1]    # initial value of product in this case
     best = p
@@ -478,7 +478,7 @@ function nextprod(a::Vector{Int}, x)
     return int(best)  # could overflow, but best to have predictable return type
 end
 
-# For a list of integers i1, i2, i3, find the largest 
+# For a list of integers i1, i2, i3, find the largest
 #     i1^n1 * i2^n2 * i3^n3 <= x
 # for integer n1, n2, n3
 function prevprod(a::Vector{Int}, x)
@@ -487,8 +487,8 @@ function prevprod(a::Vector{Int}, x)
     end
     k = length(a)
     v = ones(Int, k)            # current value of each counter
-    mx = int(a.^nextpow(a, x))  # allow each counter to exceed p (sentinel)
-    first = int(a[1]^prevpow(a[1], x))  # start at best case in first factor 
+    mx = int(nextpow(a, x))     # allow each counter to exceed p (sentinel)
+    first = int(prevpow(a[1], x))  # start at best case in first factor
     v[1] = first
     p::morebits(Int) = first
     best = p

base/intfuncs.jl

@@ -146,15 +146,21 @@ prevpow2(x::Integer) = oftype(x,x < 0 ? -prevpow2(unsigned(-x)) : prevpow2(unsig
 
 ispow2(x::Integer) = ((x<=0) == (x&(x-1)))
 
-# smallest integer n for which a^n >= x
-function nextpow(a, x)
-    n = iceil(log(x) ./ log(a))
-    return n - int(a.^(n-1) .>= x) # guard against roundoff error, e.g., with a=5 and x=125
+# smallest a^n >= x, with integer n
+function nextpow(a::Real, x::Real)
+    (a <= 1 || x <= 0) && throw(DomainError())
+    x <= 1 && return one(a)
+    n = iceil(log(a, x))
+    p = a^(n-1)
+    # guard against roundoff error, e.g., with a=5 and x=125
+    p >= x ? p : a^n
 end
-# largest integer n for which a^n <= x
-function prevpow(a, x)
-    n = ifloor(log(x) ./ log(a))
-    return n + int(a.^(n+1) .<= x)
+# largest a^n <= x, with integer n
+function prevpow(a::Real, x::Real)
+    (a <= 1 || x < 1) && throw(DomainError())
+    n = ifloor(log(a, x))
+    p = a^(n+1)
+    p <= x ? p : a^n
 end
 
 # decimal digits in an unsigned integer

doc/stdlib/base.rst

@@ -2657,19 +2657,23 @@ Mathematical Functions
 
 .. function:: nextpow2(n)
 
-   Next power of two not less than ``n``
+   The smallest power of two not less than ``n``. Returns 0 for ``n==0``, and returns
+   ``-nextpow2(-n)`` for negative arguments.
 
 .. function:: prevpow2(n)
 
-   Previous power of two not greater than ``n``
+   The largest power of two not greater than ``n``. Returns 0 for ``n==0``, and returns
+   ``-prevpow2(-n)`` for negative arguments.
 
-.. function:: nextpow(a, n)
+.. function:: nextpow(a, x)
 
-   Next power of ``a`` not less than ``n``
+   The smallest ``a^n`` not less than ``x``, where ``n`` is a non-negative integer.
+   ``a`` must be greater than 1, and ``x`` must be greater than 0.
 
-.. function:: prevpow(a, n)
+.. function:: prevpow(a, x)
 
-   Previous power of ``a`` not greater than ``n``
+   The largest ``a^n`` not greater than ``x``, where ``n`` is a non-negative integer.
+   ``a`` must be greater than 1, and ``x`` must not be less than 1.
 
 .. function:: nextprod([k_1,k_2,...], n)
 

test/numbers.jl

@@ -1563,3 +1563,16 @@ for i = -100:100
     @test nextpow2(i) == nextpow2(big(i))
     @test prevpow2(i) == prevpow2(big(i))
 end
+
+@test nextpow(2,1) == 1
+@test prevpow(2,1) == 1
+@test nextpow(3,243) == 243
+@test prevpow(3,243) == 243
+@test nextpow(3,241) == 243
+@test prevpow(3,244) == 243
+for a = -1:1
+    @test_throws nextpow(a, 2)
+    @test_throws prevpow(a, 2)
+end
+@test_throws nextpow(2,0)
+@test_throws prevpow(2,0)