Allow AbstractUnitRange (#1399)

docs/src/laurent_mpolynomial.md

@@ -96,7 +96,7 @@ derivative(p::LaurentMPolyRingElem, i::Int)
 ```
 
 ```julia
-rand(R::LaurentMPolyRingElem, length_range::UnitRange{Int}, exp_range::UnitRange{Int}, v...)
+rand(R::LaurentMPolyRingElem, length_range::AbstractUnitRange{Int}, exp_range::AbstractUnitRange{Int}, v...)
 ```
 
 The choice of canonical unit for Laurent polynomials includes the product

docs/src/mpolynomial.md

@@ -930,7 +930,7 @@ Note that zero coefficients may currently be generated, leading to less than
 the requested number of terms.
 
 ```julia
-rand(R::MPolyRing, exp_range::UnitRange{Int}, term_range::UnitRange{Int}, v...)
+rand(R::MPolyRing, exp_range::AbstractUnitRange{Int}, term_range::AbstractUnitRange{Int}, v...)
 ```
 
 **Examples**

docs/src/polynomial.md

@@ -1071,7 +1071,7 @@ parameters are used to construct coefficients as elements of the coefficient
 ring.
 
 ```julia
-rand(R::PolyRing, deg_range::UnitRange{Int}, v...)
+rand(R::PolyRing, deg_range::AbstractUnitRange{Int}, v...)
 rand(R::PolyRing, deg::Int, v...)
 ```
 

docs/src/rand.md

@@ -59,7 +59,7 @@ For example, here is the implementation of `make` for polynomial rings such as
 the above:
 
 ```julia
-function RandomExtensions.make(S::PolyRing, deg_range::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::PolyRing, deg_range::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, deg_range, vs[1]) # forward to default Make constructor
@@ -81,14 +81,14 @@ To help `make` we tell it the type of object we are hoping to randomly
 generate.
 
 ```julia
-RandomExtensions.maketype(S::PolyRing, dr::UnitRange{Int}, _) = elem_type(S)
+RandomExtensions.maketype(S::PolyRing, dr::AbstractUnitRange{Int}, _) = elem_type(S)
 ```
 
 Finally we implement the actual random generation itself.
 
 ```julia
 # define rand for make(S, deg_range, v)
-function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{<:RingElement,<:PolyRing,UnitRange{Int}}})
+function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{<:RingElement, <:PolyRing, <:AbstractUnitRange{Int}}})
    S, deg_range, v = sp[][1:end]
    R = base_ring(S)
    f = S()
@@ -118,7 +118,7 @@ As mentioned above, we define a simplified random generator that saves the user
 having to create make instances.
 
 ```julia
-rand(rng::AbstractRNG, S::PolyRing, deg_range::UnitRange{Int}, v...) =
+rand(rng::AbstractRNG, S::PolyRing, deg_range::AbstractUnitRange{Int}, v...) =
    rand(rng, make(S, deg_range, v...))
 
 rand(S::PolyRing, degs, v...) = rand(Random.GLOBAL_RNG, S, degs, v...)

docs/src/ring_interface.md

@@ -983,9 +983,9 @@ RandomExtensions.maketype(R::ConstPolyRing, _) = elem_type(R)
 rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make2{ConstPoly,ConstPolyRing}}) =
         sp[][1](rand(rng, sp[][2]))
 
-rand(rng::AbstractRNG, R::ConstPolyRing, n::UnitRange{Int}) = R(rand(rng, n))
+rand(rng::AbstractRNG, R::ConstPolyRing, n::AbstractUnitRange{Int}) = R(rand(rng, n))
 
-rand(R::ConstPolyRing, n::UnitRange{Int}) = rand(Random.GLOBAL_RNG, R, n)
+rand(R::ConstPolyRing, n::AbstractUnitRange{Int}) = rand(Random.GLOBAL_RNG, R, n)
 
 # Promotion rules
 

docs/src/series.md

@@ -735,7 +735,7 @@ valuations is provided. The maximum precision of the ring is used as a bound on
 the precision. Other parameters are used to construct random coefficients.
 
 ```julia
-rand(R::SeriesRing, val_range::UnitRange{Int}, v...)
+rand(R::SeriesRing, val_range::AbstractUnitRange{Int}, v...)
 ```
 
 **Examples**

src/AbsMSeries.jl

@@ -151,7 +151,7 @@ end
 RandomExtensions.maketype(S::MSeriesRing, _, _) = elem_type(S)
 
 function RandomExtensions.make(S::MSeriesRing,
-                                      term_range::UnitRange{Int}, vs...)
+                                      term_range::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, term_range, vs[1])
@@ -161,7 +161,7 @@ function RandomExtensions.make(S::MSeriesRing,
 end
 
 function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{
-                  <:RingElement,<:MSeriesRing,UnitRange{Int}}})
+                  <:RingElement, <:MSeriesRing, <:AbstractUnitRange{Int}}})
    S, term_range, v = sp[][1:end]
    f = S()
    g = gens(S)
@@ -196,7 +196,7 @@ function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{
 end
 
 function rand(rng::AbstractRNG, S::MSeriesRing,
-                                             term_range::UnitRange{Int}, v...)
+                                             term_range::AbstractUnitRange{Int}, v...)
    rand(rng, make(S, term_range, v...))
 end
 

src/FreeAssAlgebra.jl

@@ -158,8 +158,8 @@ end
 RandomExtensions.maketype(S::AbstractAlgebra.FreeAssAlgebra, _, _, _) = elem_type(S)
 
 function RandomExtensions.make(S::AbstractAlgebra.FreeAssAlgebra,
-                               term_range::UnitRange{Int},
-                               exp_bound::UnitRange{Int}, vs...)
+                               term_range::AbstractUnitRange{Int},
+                               exp_bound::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, term_range, exp_bound, vs[1])
@@ -169,7 +169,7 @@ function RandomExtensions.make(S::AbstractAlgebra.FreeAssAlgebra,
 end
 
 function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make4{
-                 <:NCRingElement,<:AbstractAlgebra.FreeAssAlgebra,UnitRange{Int},UnitRange{Int}}})
+                 <:NCRingElement, <:AbstractAlgebra.FreeAssAlgebra, <:AbstractUnitRange{Int}, <:AbstractUnitRange{Int}}})
    S, term_range, exp_bound, v = sp[][1:end]
    f = S()
    g = gens(S)
@@ -187,7 +187,7 @@ function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make4{
 end
 
 function rand(rng::AbstractRNG, S::AbstractAlgebra.FreeAssAlgebra,
-              term_range::UnitRange{Int}, exp_bound::UnitRange{Int}, v...)
+              term_range::AbstractUnitRange{Int}, exp_bound::AbstractUnitRange{Int}, v...)
    m = make(S, term_range, exp_bound, v...)
    rand(rng, m)
 end

src/LaurentMPoly.jl

@@ -96,8 +96,8 @@ function RandomExtensions.maketype(S::AbstractAlgebra.LaurentMPolyRing, _, _, _)
 end
 
 function RandomExtensions.make(S::AbstractAlgebra.LaurentMPolyRing,
-                               term_range::UnitRange{Int},
-                               exp_bound::UnitRange{Int},
+                               term_range::AbstractUnitRange{Int},
+                               exp_bound::AbstractUnitRange{Int},
                                vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
@@ -110,8 +110,8 @@ end
 function rand(rng::AbstractRNG,
               sp::SamplerTrivial{<:Make4{<:RingElement,
                                          <:AbstractAlgebra.LaurentMPolyRing,
-                                         UnitRange{Int},
-                                         UnitRange{Int}}})
+                                         <:AbstractUnitRange{Int},
+                                         <:AbstractUnitRange{Int}}})
    S, term_range, exp_bound, v = sp[][1:end]
    f = zero(S)
    g = gens(S)
@@ -128,7 +128,7 @@ function rand(rng::AbstractRNG,
 end
 
 function rand(rng::AbstractRNG, S::AbstractAlgebra.LaurentMPolyRing,
-              term_range::UnitRange{Int}, exp_bound::UnitRange{Int}, v...)
+              term_range::AbstractUnitRange{Int}, exp_bound::AbstractUnitRange{Int}, v...)
    rand(rng, make(S, term_range, exp_bound, v...))
 end
 

src/MPoly.jl

@@ -1300,8 +1300,8 @@ end
 
 RandomExtensions.maketype(S::AbstractAlgebra.MPolyRing, _, _, _) = elem_type(S)
 
-function RandomExtensions.make(S::AbstractAlgebra.MPolyRing, term_range::UnitRange{Int},
-                               exp_bound::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::AbstractAlgebra.MPolyRing, term_range::AbstractUnitRange{Int},
+                               exp_bound::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, term_range, exp_bound, vs[1])
@@ -1311,7 +1311,7 @@ function RandomExtensions.make(S::AbstractAlgebra.MPolyRing, term_range::UnitRan
 end
 
 function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make4{
-                 <:RingElement,<:AbstractAlgebra.MPolyRing,UnitRange{Int},UnitRange{Int}}})
+                 <:RingElement, <:AbstractAlgebra.MPolyRing, <:AbstractUnitRange{Int}, <:AbstractUnitRange{Int}}})
    S, term_range, exp_bound, v = sp[][1:end]
    f = S()
    g = gens(S)
@@ -1328,7 +1328,7 @@ function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make4{
 end
 
 function rand(rng::AbstractRNG, S::AbstractAlgebra.MPolyRing,
-              term_range::UnitRange{Int}, exp_bound::UnitRange{Int}, v...)
+              term_range::AbstractUnitRange{Int}, exp_bound::AbstractUnitRange{Int}, v...)
    rand(rng, make(S, term_range, exp_bound, v...))
 end
 

src/NCPoly.jl

@@ -677,9 +677,9 @@ end
 #
 ###############################################################################
 
-RandomExtensions.maketype(S::NCPolyRing, dr::UnitRange{Int}, _) = elem_type(S)
+RandomExtensions.maketype(S::NCPolyRing, dr::AbstractUnitRange{Int}, _) = elem_type(S)
 
-function RandomExtensions.make(S::NCPolyRing, deg_range::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::NCPolyRing, deg_range::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, deg_range, vs[1]) # forward to default Make constructor
@@ -691,7 +691,7 @@ end
 function rand(rng::AbstractRNG,
               sp::SamplerTrivial{<:Make3{<:NCPolyRingElem,
                                          <:NCPolyRing,
-                                         UnitRange{Int}}})
+                                         <:AbstractUnitRange{Int}}})
    S, deg_range, v = sp[][1:end]
    R = base_ring(S)
    f = S()
@@ -702,7 +702,7 @@ function rand(rng::AbstractRNG,
    return f
 end
 
-rand(rng::AbstractRNG, S::NCPolyRing, deg_range::UnitRange{Int}, v...) =
+rand(rng::AbstractRNG, S::NCPolyRing, deg_range::AbstractUnitRange{Int}, v...) =
    rand(rng, make(S, deg_range, v...))
 
 rand(S::NCPolyRing, deg_range, v...) = rand(Random.GLOBAL_RNG, S, deg_range, v...)

src/Poly.jl

@@ -3291,11 +3291,11 @@ end
 #
 ###############################################################################
 
-RandomExtensions.maketype(S::PolyRing, dr::UnitRange{Int}, _) = elem_type(S)
+RandomExtensions.maketype(S::PolyRing, dr::AbstractUnitRange{Int}, _) = elem_type(S)
 
 RandomExtensions.maketype(S::PolyRing, deg::Int, _) = elem_type(S)
 
-function RandomExtensions.make(S::PolyRing, deg_range::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::PolyRing, deg_range::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, deg_range, vs[1]) # forward to default Make constructor
@@ -3314,7 +3314,7 @@ function RandomExtensions.make(S::PolyRing, deg::Int, vs...)
 end
 
 # define rand for make(S, deg_range, v)
-function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{<:RingElement,<:PolyRing,UnitRange{Int}}})
+function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{<:RingElement, <:PolyRing, <:AbstractUnitRange{Int}}})
    S, deg_range, v = sp[][1:end]
    R = base_ring(S)
    len = 1 + rand(rng, deg_range)
@@ -3351,7 +3351,7 @@ function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make3{<:RingElement,<:PolyR
    return f
 end
 
-rand(rng::AbstractRNG, S::PolyRing, deg_range::UnitRange{Int}, v...) =
+rand(rng::AbstractRNG, S::PolyRing, deg_range::AbstractUnitRange{Int}, v...) =
    rand(rng, make(S, deg_range, v...))
 
 rand(rng::AbstractRNG, S::PolyRing, deg::Int, v...) =

src/RelSeries.jl

@@ -1367,9 +1367,9 @@ end
 #
 ###############################################################################
 
-RandomExtensions.maketype(S::SeriesRing, ::UnitRange{Int}, _) = elem_type(S)
+RandomExtensions.maketype(S::SeriesRing, ::AbstractUnitRange{Int}, _) = elem_type(S)
 
-function RandomExtensions.make(S::SeriesRing, val_range::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::SeriesRing, val_range::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, val_range, vs[1]) # forward to default Make constructor
@@ -1379,7 +1379,7 @@ function RandomExtensions.make(S::SeriesRing, val_range::UnitRange{Int}, vs...)
 end
 
 function rand(rng::AbstractRNG,
-              sp::SamplerTrivial{<:Make3{<:RingElement, <:SeriesRing, UnitRange{Int}}})
+              sp::SamplerTrivial{<:Make3{<:RingElement, <:SeriesRing, <:AbstractUnitRange{Int}}})
    S, val_range, v = sp[][1:end]
    R = base_ring(S)
    f = S()
@@ -1390,7 +1390,7 @@ function rand(rng::AbstractRNG,
    return shift_left(f, rand(rng, val_range))
 end
 
-rand(rng::AbstractRNG, S::SeriesRing, val_range::UnitRange{Int}, v...) =
+rand(rng::AbstractRNG, S::SeriesRing, val_range::AbstractUnitRange{Int}, v...) =
    rand(rng, make(S, val_range, v...))
 
 rand(S::SeriesRing, val_range, v...) = rand(Random.GLOBAL_RNG, S, val_range, v...)

src/generic/LaurentSeries.jl

@@ -1751,9 +1751,9 @@ end
 
 const LaurentSeriesRingOrField = Union{LaurentSeriesRing,LaurentSeriesField}
 
-RandomExtensions.maketype(S::LaurentSeriesRingOrField, ::UnitRange{Int}, _) = elem_type(S)
+RandomExtensions.maketype(S::LaurentSeriesRingOrField, ::AbstractUnitRange{Int}, _) = elem_type(S)
 
-function RandomExtensions.make(S::LaurentSeriesRingOrField, val_range::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::LaurentSeriesRingOrField, val_range::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
      Make(S, val_range, vs[1]) # forward to default Make constructor
@@ -1765,7 +1765,7 @@ end
 function rand(rng::AbstractRNG,
               sp::SamplerTrivial{<:Make3{<:RingElement,
                                          <:LaurentSeriesRingOrField,
-                                         UnitRange{Int}}})
+                                         <:AbstractUnitRange{Int}}})
    S, val_range, v = sp[][1:end]
    R = base_ring(S)
    f = S()
@@ -1776,7 +1776,7 @@ function rand(rng::AbstractRNG,
    return shift_left(f, rand(rng, val_range))
 end
 
-rand(rng::AbstractRNG, S::LaurentSeriesRingOrField, val_range::UnitRange{Int}, v...) =
+rand(rng::AbstractRNG, S::LaurentSeriesRingOrField, val_range::AbstractUnitRange{Int}, v...) =
    rand(rng, make(S, val_range, v...))
 
 rand(S::LaurentSeriesRingOrField, val_range, v...) =

src/generic/Matrix.jl

@@ -117,7 +117,7 @@ Base.@propagate_inbounds function getindex(M::MatElem, x::Integer)
    end
 end
 
-function Base.view(M::Mat{T}, rows::UnitRange{Int}, cols::UnitRange{Int}) where T <: NCRingElement
+function Base.view(M::Mat{T}, rows::AbstractUnitRange{Int}, cols::AbstractUnitRange{Int}) where T <: NCRingElement
    return MatSpaceView(view(M.entries, rows, cols), M.base_ring)
 end
 

src/generic/PuiseuxSeries.jl

@@ -707,23 +707,23 @@ end
 
 const PuiseuxSeriesRingOrField = Union{PuiseuxSeriesRing,PuiseuxSeriesField}
 
-RandomExtensions.maketype(S::PuiseuxSeriesRingOrField, ::UnitRange{Int}, _) = elem_type(S)
+RandomExtensions.maketype(S::PuiseuxSeriesRingOrField, ::AbstractUnitRange{Int}, _) = elem_type(S)
 
-RandomExtensions.make(S::PuiseuxSeriesRingOrField, val_range::UnitRange{Int},
-                      scale_range::UnitRange{Int}, vs...) =
+RandomExtensions.make(S::PuiseuxSeriesRingOrField, val_range::AbstractUnitRange{Int},
+                      scale_range::AbstractUnitRange{Int}, vs...) =
      make(S, scale_range, make(laurent_ring(S), val_range, vs...))
 
 function rand(rng::AbstractRNG,
               sp::SamplerTrivial{<:Make3{<:RingElement,
                                          <:PuiseuxSeriesRingOrField,
-                                         UnitRange{Int}}})
+                                         <:AbstractUnitRange{Int}}})
    S, scale_range, v = sp[][1:end]
    (first(scale_range) <= 0 || last(scale_range) <= 0) && error("Scale must be positive")
    return S(rand(rng, v), rand(rng, scale_range))
 end
 
-rand(rng::AbstractRNG, S::PuiseuxSeriesRingOrField, val_range::UnitRange{Int},
-     scale_range::UnitRange{Int}, v...) =
+rand(rng::AbstractRNG, S::PuiseuxSeriesRingOrField, val_range::AbstractUnitRange{Int},
+     scale_range::AbstractUnitRange{Int}, v...) =
         rand(rng, make(S, val_range, scale_range, v...))
 
 rand(S::PuiseuxSeriesRingOrField, val_range, scale_range, v...) =

src/generic/UnivPoly.jl

@@ -968,8 +968,8 @@ end
 
 RandomExtensions.maketype(S::AbstractAlgebra.UniversalPolyRing, _, _, _) = elem_type(S)
 
-function RandomExtensions.make(S::AbstractAlgebra.UniversalPolyRing, term_range::UnitRange{Int},
-                               exp_bound::UnitRange{Int}, vs...)
+function RandomExtensions.make(S::AbstractAlgebra.UniversalPolyRing, term_range::AbstractUnitRange{Int},
+                               exp_bound::AbstractUnitRange{Int}, vs...)
    R = base_ring(S)
    if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
       Make(S, term_range, exp_bound, vs[1])
@@ -979,7 +979,7 @@ function RandomExtensions.make(S::AbstractAlgebra.UniversalPolyRing, term_range:
 end
 
 function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make4{
-                 <:RingElement,<:AbstractAlgebra.UniversalPolyRing,UnitRange{Int},UnitRange{Int}}})
+                 <:RingElement, <:AbstractAlgebra.UniversalPolyRing, <:AbstractUnitRange{Int}, <:AbstractUnitRange{Int}}})
    S, term_range, exp_bound, v = sp[][1:end]
    f = S()
    g = gens(S)
@@ -996,7 +996,7 @@ function rand(rng::AbstractRNG, sp::SamplerTrivial{<:Make4{
 end
 
 function rand(rng::AbstractRNG, S::AbstractAlgebra.UniversalPolyRing,
-              term_range::UnitRange{Int}, exp_bound::UnitRange{Int}, v...)
+              term_range::AbstractUnitRange{Int}, exp_bound::AbstractUnitRange{Int}, v...)
    rand(rng, make(S, term_range, exp_bound, v...))
 end