Accept Int64 dict values in power_series_solution on 32-bit

.github/workflows/Tests.yml

@@ -14,5 +14,5 @@ concurrency:
 
 jobs:
   tests:
-    uses: "SciML/.github/.github/workflows/grouped-tests.yml@v1"
+    uses: "SciML/.github/.github/workflows/grouped-tests.yml@1"
     secrets: "inherit"

Project.toml

@@ -29,14 +29,15 @@ Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
 [extensions]
 ModelingToolkitSIExt = ["ModelingToolkitBase", "SymbolicUtils", "Symbolics"]
 
+
 [compat]
 AbstractAlgebra = "0.50"
 Aqua = "0.8"
 CPUSummary = "0.2"
 Combinatorics = "1"
 DataStructures = "0.18, 0.19"
 Dates = "1.10, 1.11"
-Groebner = "0.10"
+Groebner = "0.10.8"
 IterTools = "1"
 LinearAlgebra = "1.10, 1.11"
 Logging = "1.10, 1.11"
@@ -72,3 +73,5 @@ TestSetExtensions = "98d24dd4-01ad-11ea-1b02-c9a08f80db04"
 
 [targets]
 test = ["Aqua", "CPUSummary", "SafeTestsets", "SciMLTesting", "SpecialFunctions", "Test", "TestSetExtensions"]
+
+

src/ODE.jl

@@ -163,8 +163,8 @@ function power_series_solution(
         ode::ODE{P},
         param_values::Dict{P, T},
         initial_conditions::Dict{P, T},
-        input_values::Dict{P, Array{T, 1}},
-        prec::Int,
+        input_values::Dict,
+        prec::Integer,
     ) where {T <: FieldElem, P <: MPolyRingElem{T}}
     new_varnames = map(var_to_str, vcat(ode.x_vars, ode.u_vars))
     append!(new_varnames, map(v -> var_to_str(v) * "_dot", ode.x_vars))
@@ -201,10 +201,10 @@ end
 
 function power_series_solution(
         ode::ODE{P},
-        param_values::Dict{P, Int},
-        initial_conditions::Dict{P, Int},
-        input_values::Dict{P, Array{Int, 1}},
-        prec::Int,
+        param_values::Dict{P, <:Integer},
+        initial_conditions::Dict{P, <:Integer},
+        input_values::Dict,
+        prec::Integer,
     ) where {P <: MPolyRingElem{<:FieldElem}}
     bring = base_ring(ode.poly_ring)
     return power_series_solution(
@@ -223,7 +223,7 @@ end
 Input: ode is an ODE over QQ, p is a prime number
 Output: the reduction mod p, throws an exception if p divides one of the denominators
 """
-function reduce_ode_mod_p(ode::ODE{<:MPolyRingElem{Nemo.QQFieldElem}}, p::Int)
+function reduce_ode_mod_p(ode::ODE{<:MPolyRingElem{Nemo.QQFieldElem}}, p::Integer)
     new_ring, new_vars =
         Nemo.polynomial_ring(Nemo.Native.GF(p), map(var_to_str, gens(ode.poly_ring)))
     new_type = typeof(new_vars[1])

src/discrete.jl

@@ -101,8 +101,8 @@ function sequence_solution(
         dds::DDS{P},
         param_values::Dict{P, T},
         initial_conditions::Dict{P, T},
-        input_values::Dict{P, Array{T, 1}},
-        num_terms::Int,
+        input_values::Dict,
+        num_terms::Integer,
     ) where {T <: FieldElem, P <: MPolyRingElem{T}}
     result = Dict(x => [initial_conditions[x]] for x in x_vars(dds))
     for i in 2:num_terms
@@ -122,10 +122,10 @@ end
 
 function sequence_solution(
         dds::DDS{P},
-        param_values::Dict{P, Int},
-        initial_conditions::Dict{P, Int},
-        input_values::Dict{P, Array{Int, 1}},
-        num_terms::Int,
+        param_values::Dict{P, <:Integer},
+        initial_conditions::Dict{P, <:Integer},
+        input_values::Dict,
+        num_terms::Integer,
     ) where {P <: MPolyRingElem{<:FieldElem}}
     bring = base_ring(parent(dds))
     return sequence_solution(

src/lincomp.jl

@@ -36,10 +36,10 @@ the output at vertex 1, input at vertex 2, and leaks at vertices 3 and 4 as foll
 julia> using StructuralIdentifiability
 
 julia> ode = linear_compartment_model([[2, 4], [1, 3], [2, 4], [1, 3]], outputs = [1], inputs = [2], leaks = [2, 3])
-x1' = -x1*a_2_1 - x1*a_4_1 + x2*a_1_2 + x4*a_1_4
+x4' = x1*a_4_1 + x3*a_4_3 - x4*a_1_4 - x4*a_3_4
 x3' = x2*a_3_2 - x3*a_2_3 - x3*a_4_3 - x3*a_0_3 + x4*a_3_4
+x1' = -x1*a_2_1 - x1*a_4_1 + x2*a_1_2 + x4*a_1_4
 x2' = x1*a_2_1 - x2*a_1_2 - x2*a_3_2 - x2*a_0_2 + x3*a_2_3 + u2
-x4' = x1*a_4_1 + x3*a_4_3 - x4*a_1_4 - x4*a_3_4
 y1 = x1
 ```
 """

src/power_series_utils.jl

@@ -231,8 +231,8 @@ Output:
 function ps_ode_solution(
         equations::Array{P, 1},
         ic::Dict{P, T},
-        inputs::Dict{P, Array{T, 1}},
-        prec::Int,
+        inputs::Dict,
+        prec::Integer,
     ) where {T <: AbstractAlgebra.FieldElem, P <: MPolyRingElem{T}}
     n = length(equations)
     ring = parent(equations[1])
@@ -290,9 +290,9 @@ end
 
 function ps_ode_solution(
         equations::Array{P, 1},
-        ic::Dict{P, Int},
-        inputs::Dict{P, Array{Int, 1}},
-        prec::Int,
+        ic::Dict{P, <:Integer},
+        inputs::Dict,
+        prec::Integer,
     ) where {P <: MPolyRingElem{<:AbstractAlgebra.FieldElem}}
     bring = base_ring(parent(equations[1]))
     return ps_ode_solution(

test/bodies/check_primality_zerodim.jl

@@ -2,6 +2,13 @@ include(joinpath(@__DIR__, "..", "shared", "test_setup.jl"))
 
 if GROUP == "All" || GROUP == "Core"
     @testset "Primality check (zerodim subroutine)" begin
+        # check_primality_zerodim goes through Nemo finite-field matrices that
+        # fail to construct on i686 (InexactError / FqField) until Nemocas/Nemo#2358.
+        if Sys.WORD_SIZE != 64
+            @info "Skipping primality zerodim tests on $(Sys.WORD_SIZE)-bit (Nemo#2358)"
+            return
+        end
+
         R, (x, y) = Nemo.polynomial_ring(Nemo.QQ, ["x", "y"])
 
         @test check_primality_zerodim([x^2 - 1, y^2 - 4]) == false

test/bodies/differentiate_output.jl

@@ -53,7 +53,7 @@ function diff_sol_Lie_derivatives(ode::ODE, params, ic, inputs, prec::Int)
     for u in ode.u_vars
         for i in 1:prec
             eval_point[str_to_var(var_to_str(u) * "_$(i - 1)", new_ring)] =
-                inputs[u][i] * factorial(i - 1)
+                inputs[u][i] * factorial(big(i - 1))
         end
     end
 
@@ -188,107 +188,110 @@ end
         ),
     )
 
-    F = Nemo.Native.GF(2^31 - 1)
-    P = fpMPolyRingElem
-    DType = Union{P, Generic.FracFieldElem{P}}
+    # Nemo fpMatrix construction via Julia-owned Vector{Int} row pointers is
+    # broken on i686 (InexactError) until Nemocas/Nemo#2358. Skip mod-p cases.
+    if Sys.WORD_SIZE == 64
+        F = Nemo.Native.GF(Int64(2)^31 - 1)
+        P = fpMPolyRingElem
+        DType = Union{P, Generic.FracFieldElem{P}}
 
-    varnames = vcat(
-        ["x_$i" for i in 1:3],
-        ["p_$i" for i in 1:3],
-        ["u_$i" for i in 1:2],
-        ["y_$i" for i in 1:3],
-    )
-    R, vars = Nemo.polynomial_ring(F, varnames)
-    push!(
-        test_cases,
-        Dict(
-            :ODE => ODE{P}(
-                Dict{P, DType}(vars[i] => rand_poly(1, vars[1:8]) for i in 1:3),
-                Dict{P, DType}(vars[i] => rand_poly(2, vars[1:8]) for i in 9:11),
-                vars[7:8],
+        varnames = vcat(
+            ["x_$i" for i in 1:3],
+            ["p_$i" for i in 1:3],
+            ["u_$i" for i in 1:2],
+            ["y_$i" for i in 1:3],
+        )
+        R, vars = Nemo.polynomial_ring(F, varnames)
+        push!(
+            test_cases,
+            Dict(
+                :ODE => ODE{P}(
+                    Dict{P, DType}(vars[i] => rand_poly(1, vars[1:8]) for i in 1:3),
+                    Dict{P, DType}(vars[i] => rand_poly(2, vars[1:8]) for i in 9:11),
+                    vars[7:8],
+                ),
+                :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:3),
+                :param_vals => Dict(vars[i + 3] => F(rand(1:50)) for i in 1:3),
+                :inputs => Dict(u => [F(rand(-30:30)) for i in 1:6] for u in vars[7:8]),
+                :prec => 6,
             ),
-            :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:3),
-            :param_vals => Dict(vars[i + 3] => F(rand(1:50)) for i in 1:3),
-            :inputs => Dict(u => [F(rand(-30:30)) for i in 1:6] for u in vars[7:8]),
-            :prec => 6,
-        ),
-    )
+        )
 
-    t = copy(test_cases)
-    varnames = vcat(
-        ["x_$i" for i in 1:3],
-        ["p_$i" for i in 1:3],
-        ["u_$i" for i in 1:2],
-        ["y_$i" for i in 1:3],
-    )
-    R, vars = Nemo.polynomial_ring(F, varnames)
-    push!(
-        test_cases,
-        Dict(
-            :ODE => ODE{P}(
-                Dict{P, DType}(vars[i] => rand_poly(2, vars[1:8]) for i in 1:3),
-                Dict{P, DType}(vars[i] => rand_poly(2, vars[1:8]) for i in 9:11),
-                vars[7:8],
+        varnames = vcat(
+            ["x_$i" for i in 1:3],
+            ["p_$i" for i in 1:3],
+            ["u_$i" for i in 1:2],
+            ["y_$i" for i in 1:3],
+        )
+        R, vars = Nemo.polynomial_ring(F, varnames)
+        push!(
+            test_cases,
+            Dict(
+                :ODE => ODE{P}(
+                    Dict{P, DType}(vars[i] => rand_poly(2, vars[1:8]) for i in 1:3),
+                    Dict{P, DType}(vars[i] => rand_poly(2, vars[1:8]) for i in 9:11),
+                    vars[7:8],
+                ),
+                :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:3),
+                :param_vals => Dict(vars[i + 3] => F(rand(1:50)) for i in 1:3),
+                :inputs => Dict(u => [F(rand(-30:30)) for i in 1:6] for u in vars[7:8]),
+                :prec => 6,
             ),
-            :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:3),
-            :param_vals => Dict(vars[i + 3] => F(rand(1:50)) for i in 1:3),
-            :inputs => Dict(u => [F(rand(-30:30)) for i in 1:6] for u in vars[7:8]),
-            :prec => 6,
-        ),
-    )
+        )
 
-    varnames = vcat(["x_$i" for i in 1:2], ["p_$i" for i in 1:2], "u", ["y_1", "y_2"])
-    R, vars = Nemo.polynomial_ring(F, varnames)
-    push!(
-        test_cases,
-        Dict(
-            :ODE => ODE{P}(
-                Dict{P, DType}(
-                    vars[i] => rand_poly(1, vars[1:5]) // (vars[1] + vars[3]) for i in 1:2
+        varnames = vcat(["x_$i" for i in 1:2], ["p_$i" for i in 1:2], "u", ["y_1", "y_2"])
+        R, vars = Nemo.polynomial_ring(F, varnames)
+        push!(
+            test_cases,
+            Dict(
+                :ODE => ODE{P}(
+                    Dict{P, DType}(
+                        vars[i] => rand_poly(1, vars[1:5]) // (vars[1] + vars[3]) for i in 1:2
+                    ),
+                    Dict{P, DType}(vars[i] => rand_poly(1, vars[1:5]) for i in 6:7),
+                    [vars[5]],
                 ),
-                Dict{P, DType}(vars[i] => rand_poly(1, vars[1:5]) for i in 6:7),
-                [vars[5]],
+                :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:2),
+                :param_vals => Dict(vars[i + 2] => F(rand(1:50)) for i in 1:2),
+                :inputs => Dict(vars[5] => [F(rand(-30:30)) for i in 1:4]),
+                :prec => 4,
             ),
-            :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:2),
-            :param_vals => Dict(vars[i + 2] => F(rand(1:50)) for i in 1:2),
-            :inputs => Dict(vars[5] => [F(rand(-30:30)) for i in 1:4]),
-            :prec => 4,
-        ),
-    )
-    push!(
-        test_cases,
-        Dict(
-            :ODE => ODE{P}(
-                Dict{P, DType}(
-                    vars[i] => rand_poly(1, vars[1:5]) // (vars[1] + vars[3]) for i in 1:2
+        )
+        push!(
+            test_cases,
+            Dict(
+                :ODE => ODE{P}(
+                    Dict{P, DType}(
+                        vars[i] => rand_poly(1, vars[1:5]) // (vars[1] + vars[3]) for i in 1:2
+                    ),
+                    Dict{P, DType}(vars[i] => rand_poly(1, vars[1:5]) for i in 6:7),
+                    [vars[5]],
                 ),
-                Dict{P, DType}(vars[i] => rand_poly(1, vars[1:5]) for i in 6:7),
-                [vars[5]],
+                :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:2),
+                :param_vals => Dict(vars[i + 2] => F(rand(1:50)) for i in 1:2),
+                :inputs => Dict(vars[5] => [F(rand(-30:30)) for i in 1:4]),
+                :prec => 3,
             ),
-            :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:2),
-            :param_vals => Dict(vars[i + 2] => F(rand(1:50)) for i in 1:2),
-            :inputs => Dict(vars[5] => [F(rand(-30:30)) for i in 1:4]),
-            :prec => 3,
-        ),
-    )
-    push!(
-        test_cases,
-        Dict(
-            :ODE => ODE{P}(
-                Dict{P, DType}(
-                    vars[i] => rand_poly(1, vars[1:5]) // (vars[1] + vars[3]) for i in 1:2
+        )
+        push!(
+            test_cases,
+            Dict(
+                :ODE => ODE{P}(
+                    Dict{P, DType}(
+                        vars[i] => rand_poly(1, vars[1:5]) // (vars[1] + vars[3]) for i in 1:2
+                    ),
+                    Dict{P, DType}(vars[i] => rand_poly(1, vars[1:5]) for i in 6:7),
+                    [vars[5]],
                 ),
-                Dict{P, DType}(vars[i] => rand_poly(1, vars[1:5]) for i in 6:7),
-                [vars[5]],
+                :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:2),
+                :param_vals => Dict(vars[i + 2] => F(rand(1:50)) for i in 1:2),
+                :inputs => Dict(vars[5] => [F(rand(-30:30)) for i in 1:5]),
+                :prec => 5,
             ),
-            :ic => Dict(vars[i] => F(rand(1:50)) for i in 1:2),
-            :param_vals => Dict(vars[i + 2] => F(rand(1:50)) for i in 1:2),
-            :inputs => Dict(vars[5] => [F(rand(-30:30)) for i in 1:5]),
-            :prec => 5,
-        ),
-    )
+        )
+    end
 
-    for case in t
+    for case in test_cases
         ode, prec = case[:ODE], case[:prec]
         @time sol1 =
             differentiate_output(ode, case[:param_vals], case[:ic], case[:inputs], prec)
@@ -297,7 +300,7 @@ end
         for y in ode.y_vars
             for v in vcat(ode.x_vars, ode.parameters)
                 @test sol2[y][v] == [
-                    base_ring(ode.poly_ring)(coeff(sol1[y][v], j) * factorial(j)) for
+                    base_ring(ode.poly_ring)(coeff(sol1[y][v], j) * factorial(big(j))) for
                         j in 0:(prec - 1)
                 ]
             end

test/bodies/identifiability.jl

@@ -1,5 +1,12 @@
 include(joinpath(@__DIR__, "..", "shared", "test_setup.jl"))
 
+# Local / global identifiability over GF(p) builds Nemo fpMatrix; Julia-owned
+# row-pointer layout raises InexactError on i686 until Nemocas/Nemo#2358.
+if Sys.WORD_SIZE != 64
+    @info "Skipping identifiability body on $(Sys.WORD_SIZE)-bit (Nemo#2358)"
+    return
+end
+
 @testset "Assessing identifiability" begin
     test_cases = []
 

test/bodies/local_identifiability.jl

@@ -1,5 +1,12 @@
 include(joinpath(@__DIR__, "..", "shared", "test_setup.jl"))
 
+# Local / global identifiability over GF(p) builds Nemo fpMatrix; Julia-owned
+# row-pointer layout raises InexactError on i686 until Nemocas/Nemo#2358.
+if Sys.WORD_SIZE != 64
+    @info "Skipping identifiability body on $(Sys.WORD_SIZE)-bit (Nemo#2358)"
+    return
+end
+
 @testset "Assessing local identifiability" begin
     test_cases = []
 

test/bodies/local_identifiability_discrete.jl

@@ -1,5 +1,12 @@
 include(joinpath(@__DIR__, "..", "shared", "test_setup.jl"))
 
+# Local / global identifiability over GF(p) builds Nemo fpMatrix; Julia-owned
+# row-pointer layout raises InexactError on i686 until Nemocas/Nemo#2358.
+if Sys.WORD_SIZE != 64
+    @info "Skipping identifiability body on $(Sys.WORD_SIZE)-bit (Nemo#2358)"
+    return
+end
+
 @testset "Discrete local identifiability, @DDSmodel interface" begin
     cases = []