Merge 69a0763 into 45611bc

.travis.yml

@@ -4,7 +4,7 @@ os:
   - linux
 #  - osx
 julia:
-  - 0.6
+  - 0.7
   - nightly
 env:
   - GROUP=Regression
@@ -15,7 +15,6 @@ env:
 matrix:
   allow_failures:
     - julia: nightly
-  fast_finish: true
 notifications:
   email: false
 after_success:

REQUIRE

@@ -1,4 +1,4 @@
-julia 0.6
+julia 0.7-
 DiffEqBase 3.8.0
 DiffEqOperators
 Parameters 0.5.0

appveyor.yml

@@ -1,7 +1,7 @@
 environment:
   matrix:
-    - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
-    - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+    - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.7/julia-0.7-latest-win32.exe"
+    - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.7/julia-0.7-latest-win64.exe"
     - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 matrix:
   allow_failures:

src/OrdinaryDiffEq.jl

@@ -9,8 +9,10 @@ module OrdinaryDiffEq
 
   using MuladdMacro
 
+  using LinearAlgebra
+
   # Interfaces
-  import DiffEqBase: solve, solve!, init, step!, build_solution, initialize!
+  import DiffEqBase: solve!, step!, initialize!
 
   # Internal utils
   import DiffEqBase: ODE_DEFAULT_NORM, ODE_DEFAULT_ISOUTOFDOMAIN, ODE_DEFAULT_PROG_MESSAGE, ODE_DEFAULT_UNSTABLE_CHECK
@@ -22,8 +24,6 @@ module OrdinaryDiffEq
   using Parameters, GenericSVD, ForwardDiff, RecursiveArrayTools,
         NLsolve, Juno, Roots, DataStructures, DiffEqDiffTools
 
-  import Base: linspace
-
   import ForwardDiff.Dual
 
   # Required by temporary fix in not in-place methods with 12+ broadcasts
@@ -164,7 +164,7 @@ module OrdinaryDiffEq
 
   export GenericIIF1, GenericIIF2
 
-  export LawsonEuler, NorsettEuler, ETD1, ETDRK2, ETDRK3, ETDRK4, HochOst4, Exp4, EPIRK4s3A, EPIRK4s3B, 
+  export LawsonEuler, NorsettEuler, ETD1, ETDRK2, ETDRK3, ETDRK4, HochOst4, Exp4, EPIRK4s3A, EPIRK4s3B,
          EPIRK5s3, EXPRB53s3, EPIRK5P1, EPIRK5P2, ETD2
 
   export SymplecticEuler, VelocityVerlet, VerletLeapfrog, PseudoVerletLeapfrog,

src/alg_utils.jl

@@ -1,7 +1,7 @@
 isautodifferentiable(alg::OrdinaryDiffEqAlgorithm) = true
 
 isfsal(alg::OrdinaryDiffEqAlgorithm) = true
-isfsal{MType,VType,fsal}(tab::ExplicitRKTableau{MType,VType,fsal}) = fsal
+isfsal(tab::DiffEqBase.ExplicitRKTableau{MType,VType,fsal}) where {MType,VType,fsal} = fsal
 # isfsal(alg::CompositeAlgorithm) = isfsal(alg.algs[alg.current])
 isfsal(alg::FunctionMap) = false
 isfsal(alg::Rodas4) = false
@@ -51,13 +51,13 @@ qmax_default(alg::CompositeAlgorithm) = minimum(qmax_default.(alg.algs))
 qmax_default(alg::DP8) = 6
 
 get_chunksize(alg::OrdinaryDiffEqAlgorithm) = error("This algorithm does not have a chunk size defined.")
-get_chunksize{CS,AD}(alg::OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS,AD}) = CS
-get_chunksize{CS,AD}(alg::OrdinaryDiffEqImplicitAlgorithm{CS,AD}) = CS
+get_chunksize(alg::OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS,AD}) where {CS,AD} = CS
+get_chunksize(alg::OrdinaryDiffEqImplicitAlgorithm{CS,AD}) where {CS,AD} = CS
 # get_chunksize(alg::CompositeAlgorithm) = get_chunksize(alg.algs[alg.current_alg])
 
 alg_autodiff(alg::OrdinaryDiffEqAlgorithm) = error("This algorithm does not have an autodifferentiation option defined.")
-alg_autodiff{CS,AD}(alg::OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS,AD}) = AD
-alg_autodiff{CS,AD}(alg::OrdinaryDiffEqImplicitAlgorithm{CS,AD}) = AD
+alg_autodiff(alg::OrdinaryDiffEqAdaptiveImplicitAlgorithm{CS,AD}) where {CS,AD} = AD
+alg_autodiff(alg::OrdinaryDiffEqImplicitAlgorithm{CS,AD}) where {CS,AD} = AD
 # alg_autodiff(alg::CompositeAlgorithm) = alg_autodiff(alg.algs[alg.current_alg])
 get_current_alg_autodiff(alg, cache) = alg_autodiff(alg)
 get_current_alg_autodiff(alg::CompositeAlgorithm, cache) = alg_autodiff(alg.algs[cache.current])
@@ -294,7 +294,7 @@ qsteady_max_default(alg::AN5) = 3//2
 qsteady_max_default(alg::JVODE) = 3//2
 qsteady_max_default(alg::QNDF1) = 2//1
 
-FunctionMap_scale_by_time{scale_by_time}(alg::FunctionMap{scale_by_time}) = scale_by_time
+FunctionMap_scale_by_time(alg::FunctionMap{scale_by_time}) where {scale_by_time} = scale_by_time
 
 # SSP coefficients
 """

src/algorithms.jl

@@ -1,4 +1,4 @@
-abstract type OrdinaryDiffEqAlgorithm <: AbstractODEAlgorithm end
+abstract type OrdinaryDiffEqAlgorithm <: DiffEqBase.AbstractODEAlgorithm end
 abstract type OrdinaryDiffEqAdaptiveAlgorithm <: OrdinaryDiffEqAlgorithm end
 abstract type OrdinaryDiffEqCompositeAlgorithm <: OrdinaryDiffEqAlgorithm end
 
@@ -17,7 +17,7 @@ abstract type OrdinaryDiffEqAdamsVarOrderVarStepAlgorithm <: OrdinaryDiffEqAdapt
 
 struct FunctionMap{scale_by_time} <: OrdinaryDiffEqAlgorithm end
 Base.@pure function Discrete(;apply_map=false,scale_by_time=false)
-    warn("Discrete is deprecated. Use FunctionMap instead.")
+    @warn("Discrete is deprecated. Use FunctionMap instead.")
     FunctionMap{scale_by_time}()
 end
 Base.@pure FunctionMap(;scale_by_time=false) = FunctionMap{scale_by_time}()
@@ -729,7 +729,7 @@ struct GeneralRosenbrock{CS,AD,F,TabType} <: OrdinaryDiffEqRosenbrockAdaptiveAlg
 end
 
 Base.@pure GeneralRosenbrock(;chunk_size=0,autodiff=true,
-                    factorization=lufact!,tableau=ROSENBROCK_DEFAULT_TABLEAU) =
+                    factorization=lu!,tableau=ROSENBROCK_DEFAULT_TABLEAU) =
                     GeneralRosenbrock{chunk_size,autodiff,typeof(factorization),typeof(tableau)}(tableau,factorization)
 
 ######################################

src/bdf_utils.jl

@@ -7,10 +7,10 @@ function U!(k, cache)
       if typeof(cache) <: OrdinaryDiffEqMutableCache
         @. U[j,r] = inv(factorial(j)) * prod([m-r for m in 0:(j-1)])
       else
-        U[j,r] = inv(factorial(j)) * prod([m-r for m in 0:(j-1)]) 
+        U[j,r] = inv(factorial(j)) * prod([m-r for m in 0:(j-1)])
       end
     end
-  end  
+  end
 end
 
 function R!(k, ρ, cache)
@@ -39,8 +39,8 @@ end
 function D2!(u, uprev, k, cache)
   @unpack D, D2 = cache
   if typeof(cache) <: OrdinaryDiffEqMutableCache
-    @. D2[1,1] = (u - uprev) - D[1,1] 
+    @. D2[1,1] = (u - uprev) - D[1,1]
   else
-    D2[1,1] = (u - uprev) - D[1,1] 
+    D2[1,1] = (u - uprev) - D[1,1]
   end
 end