showall -> showfull (#203)

Author: dpsanders

benchmark/benchmarks.jl

@@ -4,12 +4,12 @@
 - using PkgBenchmark
 
 - results = benchmarkpkg("IntervalArithmetic")
-- showall(results)
+- show(results)
 
 To compare the current version with a given release use `judge`:
 
 - results = judge("IntervalArithmetic", tag)
-- showall(results)
+- show(results)
 
 To export the benchmark results to a markdown file, do:
 

docs/src/rounding.md

@@ -33,7 +33,7 @@ julia> using IntervalArithmetic
 julia> II = Interval(0.1)
 [0.1, 0.100001]
 
-julia> showall(II)
+julia> showfull(II)
 Interval(0.1, 0.1)
 ```
 
@@ -59,7 +59,7 @@ then we can apply the function `f` to the interval `a` to obtain
 julia> f(a)
 [0.399999, 0.400001]
 
-julia> showall(f(a))
+julia> showfull(f(a))
 Interval(0.39999999999999997, 0.4)
 ```
 The result correctly contains the true 0.4.

docs/src/usage.md

@@ -28,7 +28,7 @@ By default, `Interval` objects contain `Float64`s, but the library also allows u
 julia> @biginterval(1, 2)
 [1, 2]₂₅₆
 
-julia> showall(ans)
+julia> showfull(ans)
 Interval(1.000000000000000000000000000000000000000000000000000000000000000000000000000000, 2.000000000000000000000000000000000000000000000000000000000000000000000000000000)
 ```
 
@@ -117,10 +117,10 @@ use the `Interval` constructor directly:
 julia> a = Interval(0.1)
 [0.1, 0.100001]
 
-julia> showall(a)
+julia> showfull(a)
 Interval(0.1, 0.1)
 ```
-Here, the `showall` function shows the internal representation of the interval,
+Here, the `showfull` function shows the internal representation of the interval,
 in a reproducible form that may be copied and pasted directly. It uses Julia's
 internal function (which, in turn, uses the so-called Grisu algorithm) to show
 exactly as many digits are required to give an unambiguous floating-point number.
@@ -133,7 +133,7 @@ julia> @interval "0.1"*2
 julia> @biginterval "0.1"*2
 [0.199999, 0.200001]₂₅₆
 
-julia> showall(ans)
+julia> showfull(ans)
 Interval(1.999999999999999999999999999999999999999999999999999999999999999999999999999983e-01, 2.000000000000000000000000000000000000000000000000000000000000000000000000000004e-01)
 
 ```
@@ -237,7 +237,7 @@ This may be changed globally using the `setprecision` function:
 julia> @interval 3π/2 + 1
 [5.71238, 5.71239]
 
-julia> showall(ans)
+julia> showfull(ans)
 Interval(5.71238898038469, 5.712388980384691)
 
 julia> setprecision(Interval, 256)
@@ -246,7 +246,7 @@ julia> setprecision(Interval, 256)
 julia> @interval 3π/2 + 1
 [5.71238, 5.71239]₂₅₆
 
-julia> showall(ans)
+julia> showfull(ans)
 Interval(5.712388980384689857693965074919254326295754099062658731462416888461724609429262, 5.712388980384689857693965074919254326295754099062658731462416888461724609429401)
 ```
 The subscript `256` at the end denotes the precision.
@@ -356,7 +356,7 @@ the following options, specified by keyword arguments (type `?setformat` to get
 
     - `:standard`: output of the form `[1.09999, 1.30001]`, rounded to the current number of significant figures
 
-    - `:full`: output of the form `Interval(1.0999999999999999, 1.3)`, as in the `showall` function
+    - `:full`: output of the form `Interval(1.0999999999999999, 1.3)`, as in the `showfull` function
 
     - `:midpoint`: output in the midpoint-radius form, e.g. `1.2 ± 0.100001`
 

src/IntervalArithmetic.jl

@@ -67,10 +67,10 @@ export
 
 
 if VERSION < v"1.0-dev"
-    import Base.showall
+    import Base.showfull
 end
 
-export showall
+export showfull
 
 import Base: rounding, setrounding, setprecision
 

src/display.jl

@@ -256,10 +256,10 @@ end
 
 for T in (Interval, DecoratedInterval)
     @eval show(io::IO, a::$T{S}) where S = print(io, representation(a))
-    @eval showall(io::IO, a::$T{S}) where S = print(io, representation(a, :full))
+    @eval showfull(io::IO, a::$T{S}) where S = print(io, representation(a, :full))
 end
 
 T = IntervalBox
 @eval show(io::IO, a::$T) = print(io, representation(a))
 @eval show(io::IO, ::MIME"text/plain", a::$T) = print(io, representation(a))
-@eval showall(io::IO, a::$T) = print(io, representation(a, :full))
+@eval showfull(io::IO, a::$T) = print(io, representation(a, :full))

test/display_tests/display.jl

@@ -162,25 +162,25 @@ setprecision(Interval, Float64)
     end
 end
 
-@testset "showall" begin
+@testset "showfull" begin
     setformat(:standard, decorations=false, sigfigs=6)
     setprecision(128)
 
     x = 0..1
     @test string(x) == "[0, 1]"
-    @test sprint(showall, x) == "Interval(0.0, 1.0)"
+    @test sprint(showfull, x) == "Interval(0.0, 1.0)"
 
     x = @biginterval(0, 1)
     @test string(x) == "[0, 1]₁₂₈"
-    @test sprint(showall, x) == "Interval(0.0, 1.0)"
+    @test sprint(showfull, x) == "Interval(0.0, 1.0)"
 
     x = DecoratedInterval(0, 1, dac)
     @test string(x) == "[0, 1]"
-    @test sprint(showall, x) == "DecoratedInterval(Interval(0.0, 1.0), dac)"
+    @test sprint(showfull, x) == "DecoratedInterval(Interval(0.0, 1.0), dac)"
 
     x = DecoratedInterval(big(0), big(1), def)
     @test string(x) == "[0, 1]₁₂₈"
-    @test sprint(showall, x) == "DecoratedInterval(Interval(0.0, 1.0), def)"
+    @test sprint(showfull, x) == "DecoratedInterval(Interval(0.0, 1.0), def)"
 
     setformat(decorations=true)
     @test string(x) == "[0, 1]₁₂₈_def"