[WIP] use RandomTest to define random distributions for tests

Project.toml

@@ -7,8 +7,11 @@ InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+RandomExtensions = "fb686558-2515-59ef-acaa-46db3789a887"
+RandomTest = "b75900cc-ad60-4ba3-b7dc-d2abb275d94a"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
+RandomExtensions = "0.4.2"
 julia = "1"

src/AbstractAlgebra.jl

@@ -100,6 +100,8 @@ import Base: Array, abs, acos, acosh, adjoint, asin, asinh, atan, atanh, bin,
              +, -, *, ==, ^, &, |, <<, >>, ~, <=, >=, <, >, //, /, !=
 
 using Random: Random, AbstractRNG
+using RandomExtensions: RandomExtensions, make
+using RandomTest
 
 export elem_type, parent_type
 

src/Generic.jl

@@ -6,6 +6,8 @@ import LinearAlgebra: det, issymmetric, norm,
 import LinearAlgebra: lu, lu!, tr
 
 using Markdown, Random, InteractiveUtils
+using RandomExtensions: RandomExtensions, make
+using RandomTest: RandomTest, Sized, Nat, test
 
 import Base: Array, abs, asin, asinh, atan, atanh, axes, bin, checkbounds, cmp, conj,
              convert, copy, cos, cosh, dec, deepcopy, deepcopy_internal,

src/generic/Fraction.jl

@@ -968,16 +968,33 @@ end
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, S::AbstractAlgebra.FracField, v...)
+RandomExtensions.maketype(R::AbstractAlgebra.FracField, _) = elem_type(R)
+
+function RandomExtensions.make(S::AbstractAlgebra.FracField, vs...)
    R = base_ring(S)
-   n = rand(rng, R, v...)
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(S, vs[1]) # forward to default Make constructor
+   else
+      make(S, make(R, vs...))
+   end
+end
+
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{
+                 <:RandomExtensions.Make2{<:RingElement, <:AbstractAlgebra.FracField}})
+   S, v = sp[][1:end]
+   R = base_ring(S)
+   n = rand(rng, v)
    d = R()
    while iszero(d)
-      d = rand(rng, R, v...)
+      d = rand(rng, v)
    end
    return S(n, d)
 end
 
+rand(rng::AbstractRNG, S::AbstractAlgebra.FracField, v...) =
+   rand(rng, make(S, v...))
+
 rand(S::AbstractAlgebra.FracField, v...) = rand(Random.GLOBAL_RNG, S, v...)
 
 ###############################################################################

src/generic/LaurentPoly.jl

@@ -241,12 +241,30 @@ end
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, S::LaurentPolyWrapRing, degrees_range, v...)
-   m = minimum(degrees_range)
-   degrees_range = degrees_range .- m
-   LaurentPolyWrap(rand(rng, S.polyring, degrees_range, v...), m)
+RandomExtensions.maketype(S::LaurentPolyWrapRing, _, _) = elem_type(S)
+
+function RandomExtensions.make(S::LaurentPolyWrapRing, v1, vs...)
+   R = S.polyring
+   if length(vs) == 1 && vs[1] isa Integer && elem_type(R) == Random.gentype(v1)
+      RandomExtensions.Make(S, v1, vs[1]) # forward to default Make constructor
+   else
+      degrees_range = v1
+      m = minimum(degrees_range)
+      degrees_range = degrees_range .- m
+      make(S, make(R, degrees_range, vs...), m)
+   end
 end
 
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{<:RandomExtensions.Make3{<:LaurentPolyWrap,
+                                                                 <:LaurentPolyWrapRing}})
+   v, m = sp[][2:end]
+   LaurentPolyWrap(rand(rng, v), m)
+end
+
+rand(rng::AbstractRNG, S::LaurentPolyWrapRing, degrees_range, v...) =
+   rand(rng, make(S, degrees_range, v...))
+
 rand(S::LaurentPolyWrapRing, degrees_range, v...) =
    rand(Random.GLOBAL_RNG, S, degrees_range, v...)
 

src/generic/LaurentSeries.jl

@@ -1484,29 +1484,39 @@ end
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, S::LaurentSeriesRing, val_range::UnitRange{Int}, v...)
+const LaurentSeriesRingOrField = Union{LaurentSeriesRing,LaurentSeriesField}
+
+RandomExtensions.maketype(S::LaurentSeriesRingOrField, ::UnitRange{Int}, _) = elem_type(S)
+
+function RandomExtensions.make(S::LaurentSeriesRingOrField, val_range::UnitRange{Int}, vs...)
    R = base_ring(S)
-   f = S()
-   x = gen(S)
-   for i = 0:S.prec_max - 1
-      f += rand(rng, R, v...)*x^i
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(S, val_range, vs[1]) # forward to default Make constructor
+   else
+      make(S, val_range, make(R, vs...))
    end
-   return shift_left(f, rand(rng, val_range))
 end
 
-function rand(rng::AbstractRNG, S::LaurentSeriesField, val_range::UnitRange{Int}, v...)
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{<:RandomExtensions.Make3{<:RingElement,
+                                                                 <:LaurentSeriesRingOrField,
+                                                                 UnitRange{Int}}})
+   S, val_range, v = sp[][1:end]
    R = base_ring(S)
    f = S()
    x = gen(S)
    for i = 0:S.prec_max - 1
-      f += rand(rng, R, v...)*x^i
+      f += rand(rng, v)*x^i
    end
    return shift_left(f, rand(rng, val_range))
 end
 
-function rand(S::Union{LaurentSeriesRing,LaurentSeriesField}, val_range, v...)
+rand(rng::AbstractRNG, S::LaurentSeriesRingOrField, val_range::UnitRange{Int}, v...) =
+   rand(rng, make(S, val_range, v...))
+
+rand(S::LaurentSeriesRingOrField, val_range, v...) =
    rand(Random.GLOBAL_RNG, S, val_range, v...)
-end
+
 
 ###############################################################################
 #

src/generic/MPoly.jl

@@ -4682,8 +4682,21 @@ function rand_ordering(rng::AbstractRNG=Random.GLOBAL_RNG)
    end
 end
 
-function rand(rng::AbstractRNG, S::AbstractAlgebra.MPolyRing,
-              term_range::UnitRange{Int}, exp_bound::UnitRange{Int}, v...)
+RandomExtensions.maketype(S::AbstractAlgebra.MPolyRing, _, _, _) = elem_type(S)
+
+function RandomExtensions.make(S::AbstractAlgebra.MPolyRing, term_range::UnitRange{Int},
+                               exp_bound::UnitRange{Int}, vs...)
+   R = base_ring(S)
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(S, term_range, exp_bound, vs[1])
+   else
+      make(S, term_range, exp_bound, make(R, vs...))
+   end
+end
+
+function rand(rng::AbstractRNG, sp::Random.SamplerTrivial{<:RandomExtensions.Make4{
+                 <:RingElement,<:AbstractAlgebra.MPolyRing,UnitRange{Int},UnitRange{Int}}})
+   S, term_range, exp_bound, v = sp[][1:end]
    f = S()
    g = gens(S)
    R = base_ring(S)
@@ -4692,12 +4705,17 @@ function rand(rng::AbstractRNG, S::AbstractAlgebra.MPolyRing,
       for j = 1:length(g)
          term *= g[j]^rand(rng, exp_bound)
       end
-      term *= rand(rng, R, v...)
+      term *= rand(rng, v)
       f += term
    end
    return f
 end
 
+function rand(rng::AbstractRNG, S::AbstractAlgebra.MPolyRing,
+              term_range::UnitRange{Int}, exp_bound::UnitRange{Int}, v...)
+   rand(rng, make(S, term_range, exp_bound, v...))
+end
+
 function rand(S::AbstractAlgebra.MPolyRing, term_range, exp_bound, v...)
    rand(Random.GLOBAL_RNG, S, term_range, exp_bound, v...)
 end

src/generic/Matrix.jl

@@ -5070,17 +5070,34 @@ Base.map(f, a::MatrixElem) = map_entries(f, a)
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, S::AbstractAlgebra.MatSpace, v...)
+RandomExtensions.maketype(S::AbstractAlgebra.MatSpace, _) = elem_type(S)
+
+function RandomExtensions.make(S::AbstractAlgebra.MatSpace, vs...)
+   R = base_ring(S)
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(S, vs[1]) # forward to default Make constructor
+   else
+      make(S, make(R, vs...))
+   end
+end
+
+
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{<:RandomExtensions.Make2{<:MatSpaceElem,
+                                                                 <:AbstractAlgebra.MatSpace}})
+   S, v = sp[][1:end]
    M = S()
    R = base_ring(S)
    for i = 1:nrows(M)
       for j = 1:ncols(M)
-         M[i, j] = rand(rng, R, v...)
+         M[i, j] = rand(rng, v)
       end
    end
    return M
 end
 
+rand(rng::AbstractRNG, S::AbstractAlgebra.MatSpace, v...) = rand(rng, make(S, v...))
+
 rand(S::AbstractAlgebra.MatSpace, v...) = rand(Random.GLOBAL_RNG, S, v...)
 
 function randmat_triu(rng::AbstractRNG, S::AbstractAlgebra.MatSpace, v...)

src/generic/MatrixAlgebra.jl

@@ -344,18 +344,35 @@ end
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, S::AbstractAlgebra.MatAlgebra, v...)
+
+RandomExtensions.maketype(S::AbstractAlgebra.MatAlgebra, _) = elem_type(S)
+
+function RandomExtensions.make(S::AbstractAlgebra.MatAlgebra, vs...)
+   R = base_ring(S)
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(S, vs[1]) # forward to default Make constructor
+   else
+      make(S, make(R, vs...))
+   end
+end
+
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{<:RandomExtensions.Make2{<:AbstractAlgebra.MatAlgElem,
+                                                                 <:AbstractAlgebra.MatAlgebra}})
+   S, v = sp[][1:end]
    M = S()
    n = degree(M)
    R = base_ring(S)
    for i = 1:n
       for j = 1:n
-         M[i, j] = rand(rng, R, v...)
+         M[i, j] = rand(rng, v)
       end
    end
    return M
 end
 
+rand(rng::AbstractRNG, S::AbstractAlgebra.MatAlgebra, v...) = rand(rng, make(S, v...))
+
 rand(S::AbstractAlgebra.MatAlgebra, v...) = rand(Random.GLOBAL_RNG, S, v...)
 
 function randmat_triu(rng::AbstractRNG, S::AbstractAlgebra.MatAlgebra, v...)

src/generic/Module.jl

@@ -337,10 +337,26 @@ end
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, M::AbstractAlgebra.FPModule{T}, vals...) where T <: RingElement
+RandomExtensions.maketype(M::AbstractAlgebra.FPModule, _) = elem_type(M)
+
+function RandomExtensions.make(M::AbstractAlgebra.FPModule, vs...)
    R = base_ring(M)
-   v = [rand(rng, R, vals...) for i in 1:ngens(M)]
-   return M(v)
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(M, vs[1]) # forward to default Make constructor
+   else
+      make(M, make(R, vs...))
+   end
+end
+
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{<:RandomExtensions.Make2{
+                 <:AbstractAlgebra.FPModuleElem, <:AbstractAlgebra.FPModule}})
+   M, vals = sp[][1:end]
+   M(rand(rng, vals, ngens(M)))
+end
+
+function rand(rng::AbstractRNG, M::AbstractAlgebra.FPModule{T}, vals...) where T <: RingElement
+   rand(rng, make(M, vals...))
 end
 
 rand(M::AbstractAlgebra.FPModule, vals...) = rand(Random.GLOBAL_RNG, M, vals...)

src/generic/NCPoly.jl

@@ -694,19 +694,35 @@ end
 #
 ###############################################################################
 
-function rand(rng::AbstractRNG, S::AbstractAlgebra.NCPolyRing, deg_range::UnitRange{Int}, v...)
+RandomExtensions.maketype(S::AbstractAlgebra.NCPolyRing, dr::UnitRange{Int}, _) = elem_type(S)
+
+function RandomExtensions.make(S::AbstractAlgebra.NCPolyRing, deg_range::UnitRange{Int}, vs...)
+   R = base_ring(S)
+   if length(vs) == 1 && elem_type(R) == Random.gentype(vs[1])
+      RandomExtensions.Make(S, deg_range, vs[1]) # forward to default Make constructor
+   else
+      make(S, deg_range, make(R, vs...))
+   end
+end
+
+function rand(rng::AbstractRNG,
+              sp::Random.SamplerTrivial{<:RandomExtensions.Make3{<:AbstractAlgebra.NCPolyElem,
+                                                                 <:AbstractAlgebra.NCPolyRing,
+                                                                 UnitRange{Int}}})
+   S, deg_range, v = sp[][1:end]
    R = base_ring(S)
    f = S()
    x = gen(S)
    for i = 0:rand(rng, deg_range)
-      f += rand(rng, R, v...)*x^i
+      f += rand(rng, v)*x^i
    end
    return f
 end
 
-function rand(S::AbstractAlgebra.NCPolyRing, deg_range, v...)
-   rand(Random.GLOBAL_RNG, S, deg_range, v...)
-end
+rand(rng::AbstractRNG, S::AbstractAlgebra.NCPolyRing, deg_range::UnitRange{Int}, v...) =
+   rand(rng, make(S, deg_range, v...))
+
+rand(S::AbstractAlgebra.NCPolyRing, deg_range, v...) = rand(Random.GLOBAL_RNG, S, deg_range, v...)
 
 ###############################################################################
 #