From 4fdd039827d03b402e86b54cf763dd2b96ce3382 Mon Sep 17 00:00:00 2001 From: Chris Rackauckas - Beep Boop Edition Date: Sat, 8 Aug 2026 18:39:17 +0000 Subject: [PATCH] Document MATLAB solver API and enable strict QA (#94) Co-authored-by: ChrisRackauckas-Claude --- .github/workflows/Documentation.yml | 18 +++ Project.toml | 16 +-- README.md | 21 ++- docs/Project.toml | 8 ++ docs/make.jl | 18 +++ docs/src/index.md | 47 ++++++- src/MATLABDiffEq.jl | 199 ++++++++++++++++++++++++---- test/interface_tests.jl | 30 +++++ test/jet_tests.jl | 22 +-- test/matlab_runtime_tests.jl | 12 +- test/qa/Project.toml | 2 +- test/qa/qa.jl | 31 +---- 12 files changed, 333 insertions(+), 91 deletions(-) create mode 100644 .github/workflows/Documentation.yml create mode 100644 docs/Project.toml create mode 100644 docs/make.jl diff --git a/.github/workflows/Documentation.yml b/.github/workflows/Documentation.yml new file mode 100644 index 0000000..030c5a4 --- /dev/null +++ b/.github/workflows/Documentation.yml @@ -0,0 +1,18 @@ +name: "Documentation" + +on: + push: + branches: + - master + tags: '*' + pull_request: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref_name != github.event.repository.default_branch || github.ref != 'refs/tags/v*' }} + +jobs: + build-and-deploy-docs: + name: "Documentation" + uses: "SciML/.github/.github/workflows/documentation.yml@v1" + secrets: "inherit" diff --git a/Project.toml b/Project.toml index d9ccb17..240aecd 100644 --- a/Project.toml +++ b/Project.toml @@ -3,23 +3,23 @@ uuid = "e2752cbe-bcf4-5895-8727-84ebc14a76bd" version = "1.6.3" [deps] -DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e" MATLAB = "10e44e05-a98a-55b3-a45b-ba969058deb6" -ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" +ModelingToolkitBase = "7771a370-6774-4173-bd38-47e70ca0b839" PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a" -Reexport = "189a3867-3050-52da-a836-e630ba90ab69" SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +SciMLPublic = "431bcebd-1456-4ced-9d72-93c2757fff0b" +Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" [compat] -DiffEqBase = "6.122, 7" MATLAB = "0.8.1, 0.9, 0.10" -ModelingToolkit = "11.22" +ModelingToolkitBase = "1.30" ParameterizedFunctions = "5" PrecompileTools = "1.1" -Reexport = "1" SafeTestsets = "0.1, 1" -SciMLBase = "3.27" -SciMLTesting = "2.1" +SciMLBase = "3.28.4" +SciMLPublic = "1" +SciMLTesting = "2.4" +Symbolics = "7.34" Test = "<0.0.1, 1" julia = "1.10" diff --git a/README.md b/README.md index 22d495a..1032677 100644 --- a/README.md +++ b/README.md @@ -37,9 +37,8 @@ that MATLAB can handle: If you need arbitrary precision or GPU computing, use the native Julia solvers from [DifferentialEquations.jl](https://docs.sciml.ai/DiffEqDocs/stable/) instead. -Note that the algorithms are defined to have the same name as the MATLAB algorithms, -but are not exported. Thus to use `ode45`, you would specify the algorithm as -`MATLABDiffEq.ode45()`. +The algorithms have the same names as their MATLAB counterparts. They are public but not +exported, so use qualified names such as `MATLABDiffEq.ode45()`. ### Available Solvers @@ -60,7 +59,7 @@ but are not exported. Thus to use `ode45`, you would specify the algorithm as ## Example ```julia -using MATLABDiffEq, ParameterizedFunctions +using MATLAB, MATLABDiffEq, ParameterizedFunctions, SciMLBase f = @ode_def LotkaVolterra begin dx = 1.5x - x*y @@ -91,14 +90,14 @@ is done. Thus you can simply call the same ODE function and time it directly. This is done by: ```julia -@time MATLABDiffEq.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") +@time MATLAB.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") ``` To be even more pedantic, you can play around in the actual MATLAB session by using ``` -MATLABDiffEq.show_msession() +MATLAB.show_msession() ``` ## Overhead Amount @@ -106,7 +105,7 @@ MATLABDiffEq.show_msession() Generally, for long enough problems the overhead is minimal. Example: ```julia -using DiffEqBase, ParameterizedFunctions, MATLABDiffEq +using MATLAB, MATLABDiffEq, ParameterizedFunctions, SciMLBase f = @ode_def_bare RigidBodyBench begin dy1 = -2*y2*y3 dy2 = 1.25*y1*y3 @@ -132,16 +131,16 @@ julia> @time sol = solve(prob, alg); julia> @time sol = solve(prob, alg); 0.065460 seconds (38.84 k allocations: 1.556 MB) -julia> @time MATLABDiffEq.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") +julia> @time MATLAB.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") 0.058249 seconds (11 allocations: 528 bytes) -julia> @time MATLABDiffEq.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") +julia> @time MATLAB.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") 0.060367 seconds (11 allocations: 528 bytes) -julia> @time MATLABDiffEq.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") +julia> @time MATLAB.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") 0.060171 seconds (11 allocations: 528 bytes) -julia> @time MATLABDiffEq.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") +julia> @time MATLAB.eval_string("[t,u] = $(algstr)(diffeqf,tspan,u0,options);") 0.058928 seconds (11 allocations: 528 bytes) ``` diff --git a/docs/Project.toml b/docs/Project.toml new file mode 100644 index 0000000..ce9e9a9 --- /dev/null +++ b/docs/Project.toml @@ -0,0 +1,8 @@ +[deps] +Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +MATLABDiffEq = "e2752cbe-bcf4-5895-8727-84ebc14a76bd" + +[compat] +Documenter = "1" +MATLABDiffEq = "1.6" +julia = "1.10" diff --git a/docs/make.jl b/docs/make.jl new file mode 100644 index 0000000..7b2cd1f --- /dev/null +++ b/docs/make.jl @@ -0,0 +1,18 @@ +using Documenter +using MATLABDiffEq + +DocMeta.setdocmeta!(MATLABDiffEq, :DocTestSetup, :(using MATLABDiffEq); recursive = true) + +makedocs(; + modules = [MATLABDiffEq], + sitename = "MATLABDiffEq.jl", + doctest = true, + checkdocs = :exports, + format = Documenter.HTML(; + canonical = "https://docs.sciml.ai/MATLABDiffEq/stable/", + prettyurls = get(ENV, "CI", "false") == "true", + ), + pages = ["Home" => "index.md"], +) + +deploydocs(; repo = "github.com/SciML/MATLABDiffEq.jl.git", push_preview = true) diff --git a/docs/src/index.md b/docs/src/index.md index c21c3a8..588d902 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -1,5 +1,48 @@ +```@meta +CurrentModule = MATLABDiffEq +``` + # MATLABDiffEq.jl -```@autodocs -Modules = [MATLABDiffEq] +MATLABDiffEq provides SciML algorithm markers that solve ODE problems with MATLAB's ODE +routines. It is primarily intended for comparing implementations and migrating MATLAB +models; native Julia solvers are the recommended choice for production workloads. + +## Basic Usage + +Load `SciMLBase` for the problem and solve interfaces, then pass a qualified MATLABDiffEq +algorithm to `solve`: + +```julia +using MATLABDiffEq, SciMLBase + +function lorenz!(du, u, p, t) + du[1] = 10.0 * (u[2] - u[1]) + du[2] = u[1] * (28.0 - u[3]) - u[2] + du[3] = u[1] * u[2] - (8 / 3) * u[3] +end + +prob = ODEProblem(lorenz!, [1.0, 0.0, 0.0], (0.0, 100.0)) +sol = solve(prob, MATLABDiffEq.ode45(); reltol = 1.0e-6, abstol = 1.0e-8) +``` + +The MATLAB engine must be installed and available to MATLAB.jl. MATLABDiffEq accepts +`Float64`, standard integer, and `Complex{Float64}` state values. Callbacks are not +supported. + +## Public API + +Algorithm types are public but not exported, which avoids collisions with similarly named +algorithms from other solver packages. Use them through the `MATLABDiffEq` namespace. + +```@docs +MATLABAlgorithm +ode23 +ode45 +ode113 +ode23s +ode23t +ode23tb +ode15s +ode15i ``` diff --git a/src/MATLABDiffEq.jl b/src/MATLABDiffEq.jl index 120dba5..5d4edde 100644 --- a/src/MATLABDiffEq.jl +++ b/src/MATLABDiffEq.jl @@ -1,10 +1,14 @@ module MATLABDiffEq -using Reexport -@reexport using DiffEqBase -using MATLAB, ModelingToolkit -using PrecompileTools -import SciMLBase +using MATLAB: eval_string, get_default_msession, get_mvariable, get_variable, jarray, + jvector, put_variable +using ModelingToolkitBase: equations, independent_variables, modelingtoolkitize, parameters, + unknowns +using PrecompileTools: @compile_workload, @setup_workload +using SciMLBase: AbstractODEAlgorithm, AbstractODEProblem, DEStats, build_solution +import SciMLBase: __solve +using SciMLPublic: @public +using Symbolics: MATLABTarget, build_function # MATLAB only supports Float64 arrays. Check if a type is MATLAB-compatible. # Note: We specifically accept standard Julia integer types that MATLAB can convert, @@ -46,25 +50,165 @@ function _check_matlab_compatible(u0, tspan)::Nothing return nothing end -# Handle ModelingToolkit API changes: states -> unknowns -if isdefined(ModelingToolkit, :unknowns) - const mtk_states = ModelingToolkit.unknowns -else - const mtk_states = ModelingToolkit.states -end +""" + MATLABAlgorithm + +Abstract supertype for the ODE algorithm markers provided by MATLABDiffEq. + +Concrete subtypes select the MATLAB routine used by `SciMLBase.solve`. Downstream code may +dispatch on `MATLABAlgorithm` to identify MATLAB-backed ODE algorithms. External subtyping +is not supported: the bridge derives the MATLAB routine name from the concrete Julia type, +so MATLABDiffEq must own and test every subtype. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode45() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" +abstract type MATLABAlgorithm <: AbstractODEAlgorithm end + +""" + ode23() -abstract type MATLABAlgorithm <: SciMLBase.AbstractODEAlgorithm end +Select MATLAB's low-order explicit Runge-Kutta ODE solver. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode23() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode23 <: MATLABAlgorithm end + +""" + ode45() + +Select MATLAB's variable-step explicit Runge-Kutta `(4, 5)` ODE solver. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode45() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode45 <: MATLABAlgorithm end + +""" + ode113() + +Select MATLAB's variable-order Adams-Bashforth-Moulton ODE solver. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode113() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode113 <: MATLABAlgorithm end + +""" + ode23s() + +Select MATLAB's low-order Rosenbrock solver for stiff ODEs. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode23s() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode23s <: MATLABAlgorithm end + +""" + ode23t() + +Select MATLAB's trapezoidal-rule solver for moderately stiff ODEs. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode23t() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode23t <: MATLABAlgorithm end + +""" + ode23tb() + +Select MATLAB's TR-BDF2 solver for stiff ODEs. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode23tb() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode23tb <: MATLABAlgorithm end + +""" + ode15s() + +Select MATLAB's variable-order BDF/NDF solver for stiff ODEs. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode15s() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode15s <: MATLABAlgorithm end + +""" + ode15i() + +Select MATLAB's solver for fully implicit differential equations. + +Pass the resulting marker to `SciMLBase.solve`; configure tolerances and saved output with +the usual SciML solve keywords. + +# Examples + +```jldoctest +julia> MATLABDiffEq.ode15i() isa MATLABDiffEq.MATLABAlgorithm +true +``` +""" struct ode15i <: MATLABAlgorithm end -function DiffEqBase.__solve( - prob::SciMLBase.AbstractODEProblem{uType, tupType, isinplace}, +@public MATLABAlgorithm, ode23, ode45, ode113, ode23s, ode23t, ode23tb, ode15s, ode15i + +function __solve( + prob::AbstractODEProblem{uType, tupType, isinplace}, alg::AlgType, timeseries = [], ts = [], @@ -107,12 +251,12 @@ function DiffEqBase.__solve( sys = modelingtoolkitize(prob) - matstr = ModelingToolkit.build_function( + matstr = build_function( map(x -> x.rhs, equations(sys)), - mtk_states(sys), + unknowns(sys), parameters(sys), independent_variables(sys)[1], - target = ModelingToolkit.MATLABTarget() + target = MATLABTarget() ) # Send the variables @@ -152,7 +296,7 @@ function DiffEqBase.__solve( stats = buildDEStats(solstats) - return SciMLBase.build_solution( + return build_solution( prob, alg, ts, @@ -163,15 +307,24 @@ function DiffEqBase.__solve( end """ - buildDEStats(solverstats::Dict{String, <:Any}) -> SciMLBase.DEStats + buildDEStats(solverstats::Dict{String, <:Any}) -> DEStats Convert MATLAB ODE solver statistics dictionary to SciMLBase.DEStats. -The function extracts statistics from the MATLAB solver output and maps them -to the corresponding fields in SciMLBase.DEStats. Missing keys default to 0. +This internal bridge helper maps the counters returned by a MATLAB ODE solver to the +corresponding fields in `DEStats`. Missing keys default to zero. + +# Arguments + +- `solverstats`: Solver statistics keyed by the MATLAB field names `"nfevals"`, + `"nfailed"`, `"nsteps"`, `"nsolves"`, `"npds"`, and `"ndecomps"`. + +# Returns + +- A `DEStats` value populated from the available MATLAB counters. """ -function buildDEStats(solverstats::Dict{String, <:Any})::SciMLBase.DEStats - destats = SciMLBase.DEStats(0) +function buildDEStats(solverstats::Dict{String, <:Any})::DEStats + destats = DEStats(0) destats.nf = Int(get(solverstats, "nfevals", 0)) destats.nreject = Int(get(solverstats, "nfailed", 0)) destats.naccept = Int(get(solverstats, "nsteps", 0)) diff --git a/test/interface_tests.jl b/test/interface_tests.jl index 1aa6607..e17c050 100644 --- a/test/interface_tests.jl +++ b/test/interface_tests.jl @@ -2,6 +2,7 @@ # These tests verify type checking and interface compliance using MATLABDiffEq +using SciMLBase using Test @testset "Interface Compatibility" begin @@ -106,4 +107,33 @@ using Test @test MATLABDiffEq.ode15s() isa MATLABDiffEq.MATLABAlgorithm @test MATLABDiffEq.ode15i() isa MATLABDiffEq.MATLABAlgorithm end + + @testset "Public algorithm interface" begin + algorithm_types = ( + MATLABDiffEq.ode23, + MATLABDiffEq.ode45, + MATLABDiffEq.ode113, + MATLABDiffEq.ode23s, + MATLABDiffEq.ode23t, + MATLABDiffEq.ode23tb, + MATLABDiffEq.ode15s, + MATLABDiffEq.ode15i, + ) + + @test all(T -> T <: MATLABDiffEq.MATLABAlgorithm, algorithm_types) + @test all( + T -> Docs.doc(Docs.Binding(MATLABDiffEq, nameof(T))) !== nothing, + algorithm_types, + ) + @test Docs.doc(Docs.Binding(MATLABDiffEq, :MATLABAlgorithm)) !== nothing + if isdefined(Base, :ispublic) + @test Base.ispublic(MATLABDiffEq, :MATLABAlgorithm) + @test all(T -> Base.ispublic(MATLABDiffEq, nameof(T)), algorithm_types) + end + + @test hasmethod( + SciMLBase.__solve, + Tuple{SciMLBase.AbstractODEProblem, MATLABDiffEq.ode45}, + ) + end end diff --git a/test/jet_tests.jl b/test/jet_tests.jl index 7319fd9..41726c0 100644 --- a/test/jet_tests.jl +++ b/test/jet_tests.jl @@ -5,7 +5,7 @@ # (test/qa/qa.jl); this file holds the functional type-stability checks. using Test -using DiffEqBase +using SciMLBase # Import buildDEStats for testing - we need to access it from the module # Since MATLABDiffEq requires MATLAB, we'll test the function pattern directly @@ -16,8 +16,8 @@ using DiffEqBase # This verifies the function returns the correct type # Create a mock buildDEStats that matches the module implementation - function buildDEStats_test(solverstats::Dict{String, <:Any})::DiffEqBase.Stats - destats = DiffEqBase.Stats(0) + function buildDEStats_test(solverstats::Dict{String, <:Any})::SciMLBase.DEStats + destats = SciMLBase.DEStats(0) destats.nf = Int(get(solverstats, "nfevals", 0)) destats.nreject = Int(get(solverstats, "nfailed", 0)) destats.naccept = Int(get(solverstats, "nsteps", 0)) @@ -38,7 +38,7 @@ using DiffEqBase ) result = buildDEStats_test(full_stats) - @test result isa DiffEqBase.Stats + @test result isa SciMLBase.DEStats @test result.nf == 100 @test result.nreject == 5 @test result.naccept == 95 @@ -49,7 +49,7 @@ using DiffEqBase # Test with empty stats (all defaults) empty_stats = Dict{String, Any}() result_empty = buildDEStats_test(empty_stats) - @test result_empty isa DiffEqBase.Stats + @test result_empty isa SciMLBase.DEStats @test result_empty.nf == 0 @test result_empty.nreject == 0 @test result_empty.naccept == 0 @@ -66,7 +66,7 @@ using DiffEqBase # These don't require MATLAB # Define the algorithm types as they are in the module - abstract type MATLABAlgorithm <: DiffEqBase.AbstractODEAlgorithm end + abstract type MATLABAlgorithm <: SciMLBase.AbstractODEAlgorithm end struct ode23_test <: MATLABAlgorithm end struct ode45_test <: MATLABAlgorithm end struct ode113_test <: MATLABAlgorithm end @@ -78,9 +78,9 @@ using DiffEqBase # Verify type hierarchy @test ode45_test <: MATLABAlgorithm - @test ode45_test <: DiffEqBase.AbstractODEAlgorithm + @test ode45_test <: SciMLBase.AbstractODEAlgorithm @test ode23_test() isa MATLABAlgorithm - @test ode113_test() isa DiffEqBase.AbstractODEAlgorithm + @test ode113_test() isa SciMLBase.AbstractODEAlgorithm # Verify all algorithm types are concrete @test isconcretetype(ode23_test) @@ -116,8 +116,8 @@ using DiffEqBase @testset "Return type inference" begin # Test that return types can be inferred correctly - function buildDEStats_test2(solverstats::Dict{String, <:Any})::DiffEqBase.Stats - destats = DiffEqBase.Stats(0) + function buildDEStats_test2(solverstats::Dict{String, <:Any})::SciMLBase.DEStats + destats = SciMLBase.DEStats(0) destats.nf = Int(get(solverstats, "nfevals", 0)) destats.nreject = Int(get(solverstats, "nfailed", 0)) destats.naccept = Int(get(solverstats, "nsteps", 0)) @@ -130,6 +130,6 @@ using DiffEqBase # Verify return type is inferred as concrete return_types = Base.return_types(buildDEStats_test2, (Dict{String, Any},)) @test length(return_types) == 1 - @test return_types[1] == DiffEqBase.Stats + @test return_types[1] == SciMLBase.DEStats end end diff --git a/test/matlab_runtime_tests.jl b/test/matlab_runtime_tests.jl index 1609092..e7e8645 100644 --- a/test/matlab_runtime_tests.jl +++ b/test/matlab_runtime_tests.jl @@ -4,7 +4,7 @@ # MSession is impossible, so the engine-dependent smoke tests are skipped with a # notice rather than failing. Where a working MATLAB engine is present the full # solve path runs and must succeed. -using DiffEqBase, MATLABDiffEq, ParameterizedFunctions, MATLAB, Test +using MATLAB, MATLABDiffEq, ParameterizedFunctions, SciMLBase, Test # `libmx_size == 0` means MATLAB.jl was built without a MATLAB installation # (the build-time CI fallback), so the engine libraries were never loaded. @@ -31,8 +31,8 @@ end p = [1.5, 1, 3, 1] tspan = (0.0, 10.0) u0 = [1.0, 1.0] - prob = ODEProblem(f, u0, tspan, p) - sol = solve(prob, MATLABDiffEq.ode45()) + prob = SciMLBase.ODEProblem(f, u0, tspan, p) + sol = SciMLBase.solve(prob, MATLABDiffEq.ode45()) @test length(sol.t) > 0 function lorenz(du, u, p, t) @@ -42,8 +42,8 @@ end end u0 = [1.0; 0.0; 0.0] tspan = (0.0, 100.0) - prob = ODEProblem(lorenz, u0, tspan) - sol = solve(prob, MATLABDiffEq.ode45()) + prob = SciMLBase.ODEProblem(lorenz, u0, tspan) + sol = SciMLBase.solve(prob, MATLABDiffEq.ode45()) @test length(sol.t) > 0 algs = [ @@ -57,7 +57,7 @@ end ] for alg in algs - sol = solve(prob, alg()) + sol = SciMLBase.solve(prob, alg()) @test length(sol.t) > 0 end end diff --git a/test/qa/Project.toml b/test/qa/Project.toml index b07e6f0..a6ff803 100644 --- a/test/qa/Project.toml +++ b/test/qa/Project.toml @@ -10,6 +10,6 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" Aqua = "0.8" JET = "0.9, 0.10, 0.11" SafeTestsets = "0.1, 1" -SciMLTesting = "2.1" +SciMLTesting = "2.4" Test = "<0.0.1, 1" julia = "1.10" diff --git a/test/qa/qa.jl b/test/qa/qa.jl index d7fcd0c..86406ce 100644 --- a/test/qa/qa.jl +++ b/test/qa/qa.jl @@ -1,30 +1,3 @@ -using SciMLTesting, MATLABDiffEq, JET, Test +using MATLABDiffEq, SciMLTesting -run_qa( - MATLABDiffEq; - explicit_imports = true, - api_docs_kwargs = (; rendered = true), - ei_kwargs = (; - # DiffEqBase.__solve (SciMLBase-owned) is the documented solver extension - # point re-exported by DiffEqBase, and the Symbolics-owned MATLABTarget is - # reached through ModelingToolkit; both are accessed through a re-exporter - # that is not the owner. - all_qualified_accesses_via_owners = (; - ignore = ( - :__solve, :MATLABTarget, - ), - ), - # Still non-public upstream: __solve (SciMLBase) and MATLABTarget - # (Symbolics). Drop once they are declared public. - all_qualified_accesses_are_public = (; - ignore = ( - :__solve, :MATLABTarget, - ), - ), - ), - # no_implicit_imports: the module deliberately `@reexport using DiffEqBase` - # and `using MATLAB`/`ModelingToolkit`/`PrecompileTools`; making every name - # explicit is a large, risky refactor against heavy deps. Tracked in - # https://github.com/SciML/MATLABDiffEq.jl/issues/85 - ei_broken = (:no_implicit_imports,), -) +run_qa(MATLABDiffEq)