diff --git a/docs/make.jl b/docs/make.jl
index 03fa360a..491f1f45 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -23,6 +23,7 @@ makedocs(
         "Extending" => "extending.md",
     ],
     warnonly = [:cross_references, :missing_docs],
+    checkdocs=:exports,
 )
 
 deploydocs(repo = "github.com/JuliaMath/Polynomials.jl.git")
diff --git a/docs/src/index.md b/docs/src/index.md
index 6d27da12..e37560d5 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -575,8 +575,7 @@ internally when converting to the `FactoredPolynomial` type:
 julia> p = Polynomial([24, -50, 35, -10, 1])
 Polynomial(24 - 50*x + 35*x^2 - 10*x^3 + x^4)
 
-julia> q = convert(FactoredPolynomial, p) # noisy form of `factor`:
-FactoredPolynomial((x - 4.0000000000000036) * (x - 1.0000000000000002) * (x - 2.9999999999999942) * (x - 2.0000000000000018))
+julia> q = convert(FactoredPolynomial, p);  # noisy form of `factor` subject to floating point vagaries
 
 julia> map(x -> round(x, digits=10), q)
 FactoredPolynomial((x - 4.0) * (x - 2.0) * (x - 3.0) * (x - 1.0))
diff --git a/docs/src/reference.md b/docs/src/reference.md
index f7c7a2f3..a4ab2d43 100644
--- a/docs/src/reference.md
+++ b/docs/src/reference.md
@@ -98,9 +98,12 @@ gcd
 derivative
 integrate
 roots
+residues
+poles
 companion
 fit
 vander
+ArnoldiFit
 ```
 
 ## Plotting
diff --git a/ext/PolynomialsRecipesBaseExt.jl b/ext/PolynomialsRecipesBaseExt.jl
index 02ef3e37..ca9e3c8e 100644
--- a/ext/PolynomialsRecipesBaseExt.jl
+++ b/ext/PolynomialsRecipesBaseExt.jl
@@ -62,7 +62,7 @@ end
 
     xlims = get(plotattributes, :xlims, (nothing, nothing))
     ylims = get(plotattributes, :ylims, (nothing, nothing))
-    rational_function_trim(pq, a, b, xlims, ylims)    
+    rational_function_trim(pq, a, b, xlims, ylims)
 
 end
 
@@ -84,10 +84,10 @@ function rational_function_trim(pq, a, b, xlims, ylims)
     dpq = derivative(p//q)
     p′,q′ = lowest_terms(dpq)
 
-    λs = Multroot.multroot(q).values
+    λs = Polynomials.Multroot.multroot(q).values
     λs = isempty(λs) ? λs : real.(filter(isapproxreal, λs))
 
-    cps = Multroot.multroot(p′).values
+    cps = Polynomials.Multroot.multroot(p′).values
     cps = isempty(cps) ? cps : real.(filter(isapproxreal, cps))
     cps = isempty(cps) ? cps : filter(!toobig(pq), cps)
 
diff --git a/src/common.jl b/src/common.jl
index b5465360..59de5e26 100644
--- a/src/common.jl
+++ b/src/common.jl
@@ -704,7 +704,7 @@ isconstant(p::AbstractPolynomial) = degree(p) <= 0 && firstindex(p) == 0
     coeffs(::AbstractLaurentUnivariatePolynomial)
 
 For a dense, univariate polynomial return the coefficients ``(a_0, a_1, \\dots, a_n)``
-as an interable. This may be a vector or tuple, and may alias the
+as an iterable. This may be a vector or tuple, and may alias the
 polynomials coefficients.
 
 For a Laurent type polynomial (e.g. `LaurentPolynomial`, `SparsePolynomial`) return the coefficients ``(a_i, a_{i+1}, \\dots, a_j)`` where
diff --git a/src/polynomials/factored_polynomial.jl b/src/polynomials/factored_polynomial.jl
index f2fcdf14..067f61e0 100644
--- a/src/polynomials/factored_polynomial.jl
+++ b/src/polynomials/factored_polynomial.jl
@@ -30,8 +30,7 @@ FactoredPolynomial(x * (x - 3) * (x - 1))
 julia> p = Polynomial([24, -50, 35, -10, 1])
 Polynomial(24 - 50*x + 35*x^2 - 10*x^3 + x^4)
 
-julia> q = convert(FactoredPolynomial, p) # noisy form of `factor`:
-FactoredPolynomial((x - 4.0000000000000036) * (x - 1.0000000000000002) * (x - 2.9999999999999942) * (x - 2.0000000000000018))
+julia> q = convert(FactoredPolynomial, p); # noisy form of `factor`, subject to floating point issues
 
 julia> map(x->round(x, digits=12), q) # map works over factors and leading coefficient -- not coefficients in the standard basis
 FactoredPolynomial((x - 4.0) * (x - 2.0) * (x - 3.0) * (x - 1.0))
diff --git a/src/polynomials/multroot.jl b/src/polynomials/multroot.jl
index aad8884c..07e803e9 100644
--- a/src/polynomials/multroot.jl
+++ b/src/polynomials/multroot.jl
@@ -33,20 +33,14 @@ julia> using Polynomials
 julia> p = fromroots([sqrt(2), sqrt(2), sqrt(2), 1, 1])
 Polynomial(-2.8284271247461907 + 11.656854249492383*x - 19.07106781186548*x^2 + 15.485281374238573*x^3 - 6.242640687119286*x^4 + 1.0*x^5)
 
-julia> roots(p)
-5-element Vector{ComplexF64}:
-  0.999999677417768 + 0.0im
- 1.0000003225831504 + 0.0im
- 1.4141705716005881 + 0.0im
- 1.4142350577588914 - 3.722737728087131e-5im
- 1.4142350577588914 + 3.722737728087131e-5im
+julia> roots(p) |> unique |> length # all are distinct
+5
 
 julia> m = Polynomials.Multroot.multroot(p);
 
-julia> Dict(m.values .=> m.multiplicities)
-Dict{Float64, Int64} with 2 entries:
-  1.41421 => 3
-  1.0     => 2
+julia> ind = sortperm(m.values); ks = round.(m.values[ind];digits=6); vs = m.multiplicities[ind]; [ks .=> vs]
+1-element Vector{Vector{Pair{Float64, Int64}}}:
+ [1.0 => 2, 1.414214 => 3]
 ```
 
 ## Extended help