add standardtag mechanism to StochasticDiffEq implicit methods

Author: ChrisRackauckas

src/alg_utils.jl

@@ -256,6 +256,12 @@ OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,
 OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,Controller}) where {CS,AD,Controller} = Val(CS)
 OrdinaryDiffEq.get_chunksize(alg::StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,Controller}) where {CS,AD,Controller} = Val(CS)
 
+@static if isdefined(OrdinaryDiffEq,:standardtag)
+    standardtag(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller},
+                            StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,Controller}}
+                            ) where {CS,AD,FDT,ST,Controller} = ST
+end
+
 @static if isdefined(OrdinaryDiffEq,:alg_difftype)
     OrdinaryDiffEq.alg_difftype(alg::Union{StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller},
                                 StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,Controller}}) where {CS,AD,FDT,Controller} = FDT

src/algorithms.jl

@@ -6,16 +6,16 @@ abstract type StochasticDiffEqRODEAlgorithm <: AbstractRODEAlgorithm end
 abstract type StochasticDiffEqRODEAdaptiveAlgorithm <: StochasticDiffEqRODEAlgorithm end
 abstract type StochasticDiffEqRODECompositeAlgorithm <: StochasticDiffEqRODEAlgorithm end
 
-abstract type StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller} <: StochasticDiffEqAdaptiveAlgorithm end
-abstract type StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,Controller} <: StochasticDiffEqAlgorithm end
+abstract type StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller} <: StochasticDiffEqAdaptiveAlgorithm end
+abstract type StochasticDiffEqNewtonAlgorithm{CS,AD,FDT,ST,Controller} <: StochasticDiffEqAlgorithm end
 
 abstract type StochasticDiffEqJumpAlgorithm <: StochasticDiffEqAlgorithm end
 abstract type StochasticDiffEqJumpAdaptiveAlgorithm <: StochasticDiffEqAlgorithm end
-abstract type StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller} <: StochasticDiffEqJumpAdaptiveAlgorithm end
+abstract type StochasticDiffEqJumpNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller} <: StochasticDiffEqJumpAdaptiveAlgorithm end
 
 abstract type StochasticDiffEqJumpDiffusionAlgorithm <: StochasticDiffEqAlgorithm end
 abstract type StochasticDiffEqJumpDiffusionAdaptiveAlgorithm <: StochasticDiffEqAlgorithm end
-abstract type StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,FDT,Controller} <: StochasticDiffEqJumpDiffusionAdaptiveAlgorithm end
+abstract type StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm{CS,AD,FDT,ST,Controller} <: StochasticDiffEqJumpDiffusionAdaptiveAlgorithm end
 
 abstract type IteratedIntegralApprox end
 struct IICommutative <:  IteratedIntegralApprox end
@@ -625,7 +625,7 @@ This is a theta method which defaults to theta=1 or the Trapezoid method on the
 This method defaults to symplectic=false, but when true and theta=1/2 this is the implicit Midpoint method on the drift term and is symplectic in distribution.
 Can handle all forms of noise, including non-diagonal, scalar, and colored noise. Uses a 1.0/1.5 heuristic for adaptive time stepping.
 """
-struct ImplicitEM{CS,AD,F,F2,FDT,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller}
+struct ImplicitEM{CS,AD,F,F2,FDT,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller}
   linsolve::F
   nlsolve::F2
   theta::T2
@@ -634,13 +634,15 @@ struct ImplicitEM{CS,AD,F,F2,FDT,T2,Controller} <: StochasticDiffEqNewtonAdaptiv
   symplectic::Bool
 end
 ImplicitEM(;chunk_size=0,autodiff=true,diff_type=Val{:central},
+                          standardtag = Val{true}(),
                           linsolve=DEFAULT_LINSOLVE,nlsolve=NLNewton(),
                           extrapolant=:constant,
                           theta = 1,symplectic=false,
                           new_jac_conv_bound = 1e-3,
                           controller = :Predictive) =
                           ImplicitEM{chunk_size,autodiff,
                           typeof(linsolve),typeof(nlsolve),diff_type,
+                          OrdinaryDiffEq._unwrap_val(standardtag),
                           typeof(new_jac_conv_bound),controller}(
                           linsolve,nlsolve,
                           symplectic ? 1/2 : theta,
@@ -655,7 +657,7 @@ This is a theta method which defaults to theta=1/2 or the Trapezoid method on th
 This method defaults to symplectic=false, but when true and theta=1 this is the implicit Midpoint method on the drift term and is symplectic in distribution.
 Can handle all forms of noise, including non-diagonal, scalar, and colored noise. Uses a 1.0/1.5 heuristic for adaptive time stepping.
 """
-struct ImplicitEulerHeun{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller}
+struct ImplicitEulerHeun{CS,AD,F,FDT,ST,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller}
   linsolve::F
   nlsolve::N
   theta::T2
@@ -664,13 +666,15 @@ struct ImplicitEulerHeun{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonA
   symplectic::Bool
 end
 ImplicitEulerHeun(;chunk_size=0,autodiff=true,diff_type=Val{:central},
+                          standardtag = Val{true}(),
                           linsolve=DEFAULT_LINSOLVE,nlsolve=NLNewton(),
                           extrapolant=:constant,
                           theta = 1,symplectic = false,
                           new_jac_conv_bound = 1e-3,
                           controller = :Predictive) =
                           ImplicitEulerHeun{chunk_size,autodiff,
                           typeof(linsolve),diff_type,
+                          OrdinaryDiffEq._unwrap_val(standardtag),
                           typeof(nlsolve),
                           typeof(new_jac_conv_bound),controller}(
                           linsolve,nlsolve,
@@ -686,7 +690,7 @@ Defaults to solving the Ito problem, but ImplicitRKMil(interpretation=:Stratonov
 This method defaults to symplectic=false, but when true and theta=1/2 this is the implicit Midpoint method on the drift term and is symplectic in distribution.
 Handles diagonal and scalar noise. Uses a 1.5/2.0 heuristic for adaptive time stepping.
 """
-struct ImplicitRKMil{CS,AD,F,FDT,N,T2,Controller,interpretation} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller}
+struct ImplicitRKMil{CS,AD,F,FDT,ST,N,T2,Controller,interpretation} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller}
   linsolve::F
   nlsolve::N
   theta::T2
@@ -695,13 +699,15 @@ struct ImplicitRKMil{CS,AD,F,FDT,N,T2,Controller,interpretation} <: StochasticDi
   symplectic::Bool
 end
 ImplicitRKMil(;chunk_size=0,autodiff=true,diff_type=Val{:central},
+                          standardtag = Val{true}()
                           linsolve=DEFAULT_LINSOLVE,nlsolve=NLNewton(),
                           extrapolant=:constant,
                           theta = 1,symplectic = false,
                           new_jac_conv_bound = 1e-3,
                           controller = :Predictive,interpretation=:Ito) =
                           ImplicitRKMil{chunk_size,autodiff,
                           typeof(linsolve),diff_type,
+                          OrdinaryDiffEq._unwrap_val(standardtag),
                           typeof(nlsolve),typeof(new_jac_conv_bound),
                           controller,interpretation}(
                           linsolve,nlsolve,
@@ -716,7 +722,7 @@ This is a theta method which defaults to theta=1 or the Trapezoid method on the
 This method defaults to symplectic=false, but when true and theta=1/2 this is the implicit Midpoint method on the drift term and is symplectic in distribution.
 Can handle all forms of noise, including non-diagonal, scalar, and colored noise. Uses a 1.0/1.5 heuristic for adaptive time stepping.
 """
-struct ISSEM{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller}
+struct ISSEM{CS,AD,F,FDT,ST,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller}
   linsolve::F
   nlsolve::N
   theta::T2
@@ -725,13 +731,15 @@ struct ISSEM{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgor
   symplectic::Bool
 end
 ISSEM(;chunk_size=0,autodiff=true,diff_type=Val{:central},
+                       standardtag = Val{true}(),
                        linsolve=DEFAULT_LINSOLVE,nlsolve=NLNewton(),
                        extrapolant=:constant,
                        theta = 1,symplectic=false,
                        new_jac_conv_bound = 1e-3,
                        controller = :Predictive) =
                        ISSEM{chunk_size,autodiff,
                        typeof(linsolve),diff_type,
+                       OrdinaryDiffEq._unwrap_val(standardtag),
                        typeof(nlsolve),
                        typeof(new_jac_conv_bound),controller}(
                        linsolve,nlsolve,
@@ -746,7 +754,7 @@ This is a theta method which defaults to theta=1 or the Trapezoid method on the
 This method defaults to symplectic=false, but when true and theta=1/2 this is the implicit Midpoint method on the drift term and is symplectic in distribution.
 Can handle all forms of noise, including non-diagonal,Q scalar, and colored noise. Uses a 1.0/1.5 heuristic for adaptive time stepping.
 """
-struct ISSEulerHeun{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller}
+struct ISSEulerHeun{CS,AD,F,FDT,ST,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller}
  linsolve::F
  nlsolve::N
  theta::T2
@@ -755,13 +763,15 @@ struct ISSEulerHeun{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdapti
  symplectic::Bool
 end
 ISSEulerHeun(;chunk_size=0,autodiff=true,diff_type=Val{:central},
+                      standardtag = Val{true}(),
                       linsolve=DEFAULT_LINSOLVE,nlsolve=NLNewton(),
                       extrapolant=:constant,
                       theta = 1,symplectic=false,
                       new_jac_conv_bound = 1e-3,
                       controller = :Predictive) =
                       ISSEulerHeun{chunk_size,autodiff,
                       typeof(linsolve),diff_type,
+                      OrdinaryDiffEq._unwrap_val(standardtag),
                       typeof(nlsolve),typeof(new_jac_conv_bound),controller}(
                       linsolve,nlsolve,
                       symplectic ? 1/2 : theta,
@@ -772,7 +782,7 @@ SKenCarp: Stiff Method
 Adaptive L-stable drift-implicit strong order 1.5 for additive Ito and Stratonovich SDEs with weak order 2.
 Can handle diagonal, non-diagonal and scalar additive noise.
 """
-struct SKenCarp{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,Controller}
+struct SKenCarp{CS,AD,F,FDT,ST,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAlgorithm{CS,AD,FDT,ST,Controller}
   linsolve::F
   nlsolve::N
   smooth_est::Bool
@@ -782,11 +792,13 @@ struct SKenCarp{CS,AD,F,FDT,N,T2,Controller} <: StochasticDiffEqNewtonAdaptiveAl
 end
 
 SKenCarp(;chunk_size=0,autodiff=true,diff_type=Val{:central},
+                   standardtag = Val{true}(),
                    linsolve=DEFAULT_LINSOLVE,nlsolve=NLNewton(),
                    smooth_est=true,extrapolant=:min_correct,
                    new_jac_conv_bound = 1e-3,controller = :Predictive,
                    ode_error_est = true) =
  SKenCarp{chunk_size,autodiff,typeof(linsolve),diff_type,
+        OrdinaryDiffEq._unwrap_val(standardtag),
         typeof(nlsolve),typeof(new_jac_conv_bound),controller}(
         linsolve,nlsolve,smooth_est,extrapolant,new_jac_conv_bound,
         ode_error_est)