Fix copy method for StatefulJacobianOperator with Tuple parameters (#753)

* Fix copy method for StatefulJacobianOperator with Tuple parameters

- Add `_safe_copy` helper functions to handle immutable types (Tuple,
  NamedTuple, Number) that don't need copying
- Fix the `Base.copy` method for `StatefulJacobianOperator` to use
  `_safe_copy(J.p)` instead of `applicable(copy, J.p) ? copy(J.p) : J.p`
  which fails for Tuple types
- Fix typo: `nohting` -> `nothing` in `JacobianOperator.copy`

This fixes the JFNK (Jacobian-Free Newton-Krylov) example from the
documentation which was failing with:
  MethodError: no method matching copy(::NTuple{4, Float64})

Fixes #752

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

* Add regression test for issue #752 and fix stale ForwardDiff dependency

- Add regression test for copy(StatefulJacobianOperator) with Tuple and
  NamedTuple parameters to prevent future regressions
- Test the _safe_copy helper functions for Tuple, NamedTuple, Number,
  and Array types
- Remove ForwardDiff from main deps (it's only needed for tests, already
  in extras)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

---------

Co-authored-by: ChrisRackauckas <[email protected]>
Co-authored-by: Claude Opus 4.5 <[email protected]>

Author: 3 people

lib/SciMLJacobianOperators/Project.toml

@@ -1,7 +1,7 @@
 name = "SciMLJacobianOperators"
 uuid = "19f34311-ddf3-4b8b-af20-060888a46c0e"
-authors = ["Avik Pal <[email protected]> and contributors"]
 version = "0.1.12"
+authors = ["Avik Pal <[email protected]> and contributors"]
 
 [deps]
 ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"

lib/SciMLJacobianOperators/src/SciMLJacobianOperators.jl

@@ -404,22 +404,30 @@ function get_dense_ad(ad::AutoSparse)
     return dense_ad
 end
 
+# Helper functions for safe copying of parameters
+# Tuples and NamedTuples are immutable and don't need copying
+# Numbers are immutable as well
+_safe_copy(x::Tuple) = x
+_safe_copy(x::NamedTuple) = x
+_safe_copy(x::Number) = x
+_safe_copy(x) = copy(x)
+
 function Base.copy(J::JacobianOperator{iip, T}) where {iip, T}
-    return JacobianOperator{iip,T}(
+    return JacobianOperator{iip, T}(
         J.mode,
         J.jvp_op,
         J.vjp_op,
         J.size,
         J.input_cache === nothing ? nothing : copy(J.input_cache),
-        J.output_cache === nothing ? nohting : copy(J.output_cache)
+        J.output_cache === nothing ? nothing : copy(J.output_cache)
     )
 end
 
 function Base.copy(J::StatefulJacobianOperator)
     return StatefulJacobianOperator(
         copy(J.jac_op),
         J.u === nothing ? nothing : copy(J.u),
-        applicable(copy, J.p) ? copy(J.p) : J.p
+        _safe_copy(J.p)
     )
 end
 
@@ -429,10 +437,8 @@ function Base.copy(J::StatefulJacobianNormalFormOperator{T}) where {T}
         J.jvp_operator === nothing ? nothing : copy(J.jvp_operator),
         J.cache === nothing ? nothing : copy(J.cache)
     )
-
 end
 
-
 export JacobianOperator, VecJacOperator, JacVecOperator
 export StatefulJacobianOperator
 export StatefulJacobianNormalFormOperator

lib/SciMLJacobianOperators/test/core_tests.jl

@@ -311,3 +311,95 @@ end
     @test check_no_stale_explicit_imports(SciMLJacobianOperators) === nothing
     @test check_all_qualified_accesses_via_owners(SciMLJacobianOperators) === nothing
 end
+
+@testitem "Copy with Tuple parameters (Issue #752)" begin
+    using ADTypes, SciMLBase, ForwardDiff, FiniteDiff
+    using SciMLJacobianOperators
+    using SciMLJacobianOperators: _safe_copy
+
+    # Test _safe_copy helper functions
+    @testset "_safe_copy helpers" begin
+        # Tuples should be returned as-is (immutable)
+        t = (1.0, 2.0, 3.0, 4.0)
+        @test _safe_copy(t) === t
+
+        # NamedTuples should be returned as-is (immutable)
+        nt = (a = 1.0, b = 2.0)
+        @test _safe_copy(nt) === nt
+
+        # Numbers should be returned as-is (immutable)
+        @test _safe_copy(42.0) === 42.0
+        @test _safe_copy(42) === 42
+
+        # Arrays should be copied
+        arr = [1.0, 2.0, 3.0]
+        arr_copy = _safe_copy(arr)
+        @test arr_copy == arr
+        @test arr_copy !== arr  # Different object
+    end
+
+    # Test copy(StatefulJacobianOperator) with Tuple parameter
+    # This is a regression test for issue #752 where JFNK failed with:
+    # MethodError: no method matching copy(::NTuple{4, Float64})
+    @testset "copy(StatefulJacobianOperator) with Tuple p" begin
+        # Brusselator-like problem setup with Tuple parameters
+        function brusselator_f(du, u, p)
+            α, β, γ, δ = p
+            du[1] = α + u[1]^2 * u[2] - (β + 1) * u[1]
+            du[2] = β * u[1] - u[1]^2 * u[2]
+            return nothing
+        end
+
+        # Parameters as a Tuple (this is what caused issue #752)
+        p_tuple = (1.0, 3.0, 1.0, 1.0)
+        u0 = [1.0, 1.0]
+        fu0 = similar(u0)
+        brusselator_f(fu0, u0, p_tuple)
+
+        prob = NonlinearProblem(
+            NonlinearFunction{true}(brusselator_f), u0, p_tuple)
+
+        jac_op = JacobianOperator(
+            prob, fu0, u0; jvp_autodiff = AutoForwardDiff(), vjp_autodiff = AutoFiniteDiff())
+        sop = StatefulJacobianOperator(jac_op, u0, p_tuple)
+
+        # This should not throw MethodError: no method matching copy(::NTuple{4, Float64})
+        sop_copy = copy(sop)
+
+        @test sop_copy.p === p_tuple  # Same tuple (immutable, no copy needed)
+        @test sop_copy.u == u0
+        @test sop_copy.u !== sop.u  # Different array object (copied)
+
+        # Verify the copied operator still works
+        v = [1.0, 0.0]
+        result_original = sop * v
+        result_copy = sop_copy * v
+        @test result_original ≈ result_copy
+    end
+
+    # Test copy(StatefulJacobianOperator) with NamedTuple parameter
+    @testset "copy(StatefulJacobianOperator) with NamedTuple p" begin
+        function simple_f(du, u, p)
+            du[1] = p.a * u[1] + p.b * u[2]
+            du[2] = p.c * u[1] + p.d * u[2]
+            return nothing
+        end
+
+        p_namedtuple = (a = 1.0, b = 2.0, c = 3.0, d = 4.0)
+        u0 = [1.0, 1.0]
+        fu0 = similar(u0)
+        simple_f(fu0, u0, p_namedtuple)
+
+        prob = NonlinearProblem(
+            NonlinearFunction{true}(simple_f), u0, p_namedtuple)
+
+        jac_op = JacobianOperator(
+            prob, fu0, u0; jvp_autodiff = AutoForwardDiff(), vjp_autodiff = AutoFiniteDiff())
+        sop = StatefulJacobianOperator(jac_op, u0, p_namedtuple)
+
+        # This should not throw
+        sop_copy = copy(sop)
+
+        @test sop_copy.p === p_namedtuple  # Same NamedTuple (immutable)
+    end
+end