specialize Newton on static arrays

```julia
using StaticArrays
using NonlinearSolve

function f(x, _)
    F1 = (x[1] + 3) * (x[2]^3 - 7) + 18
    F2 = sin(x[2] * exp(x[1]) - 1)
    SA[F1,F2]
end

function f!(F, x)
    F[1] = (x[1] + 3) * (x[2]^3 - 7) + 18
    F[2] = sin(x[2] * exp(x[1]) - 1)
    nothing
end

x0 = [0.1; 1.2]
x0s = SVector{size(x0)...}(x0)
x0m = MVector{size(x0)...}(x0)
prob = NonlinearProblem{false}(f, x0s)

using NLsolve, BenchmarkTools
@Btime sol = solve(prob,NewtonRaphson()); # 320.000 ns (2 allocations: 128 bytes)
@Btime nlsolve(f!, x0m); # 1.460 μs (35 allocations: 1.36 KiB)
```

Author: ChrisRackauckas

src/scalar.jl

@@ -1,12 +1,17 @@
-function SciMLBase.solve(prob::NonlinearProblem{<:Number}, alg::NewtonRaphson, args...; xatol = nothing, xrtol = nothing, maxiters = 1000, kwargs...)
+function SciMLBase.solve(prob::NonlinearProblem{<:Union{Number,SVector}}, alg::NewtonRaphson, args...; xatol = nothing, xrtol = nothing, maxiters = 1000, kwargs...)
   f = Base.Fix2(prob.f, prob.p)
   x = float(prob.u0)
   fx = float(prob.u0)
   T = typeof(x)
-  atol = xatol !== nothing ? xatol : oneunit(T) * (eps(one(T)))^(4//5)
-  rtol = xrtol !== nothing ? xrtol : eps(one(T))^(4//5)
+  atol = xatol !== nothing ? xatol : oneunit(eltype(T)) * (eps(one(eltype(T))))^(4//5)
+  rtol = xrtol !== nothing ? xrtol : eps(one(eltype(T)))^(4//5)
+
+  if typeof(x) <: Number
+    xo = oftype(one(eltype(x)), Inf)
+  else
+    xo = map(x->oftype(one(eltype(x)), Inf),x)
+  end
 
-  xo = oftype(x, Inf)
   for i in 1:maxiters
     if alg_autodiff(alg)
       fx, dfx = value_derivative(f, x)
@@ -52,7 +57,7 @@ end
 function SciMLBase.solve(prob::NonlinearProblem{<:Number, iip, <:Dual{T,V,P}}, alg::NewtonRaphson, args...; kwargs...) where {iip, T, V, P}
   sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)
   return SciMLBase.build_solution(prob, alg, Dual{T,V,P}(sol.u, partials), sol.resid; retcode=sol.retcode)
-  
+
 end
 function SciMLBase.solve(prob::NonlinearProblem{<:Number, iip, <:AbstractArray{<:Dual{T,V,P}}}, alg::NewtonRaphson, args...; kwargs...) where {iip, T, V, P}
   sol, partials = scalar_nlsolve_ad(prob, alg, args...; kwargs...)

src/utils.jl

@@ -224,6 +224,9 @@ function value_derivative(f::F, x::R) where {F,R}
     ForwardDiff.value(out), ForwardDiff.extract_derivative(T, out)
 end
 
+# Todo: improve this dispatch
+value_derivative(f::F, x::SVector) where F = f(x),ForwardDiff.jacobian(f, x)
+
 value(x) = x
 value(x::Dual) = ForwardDiff.value(x)
 value(x::AbstractArray{<:Dual}) = map(ForwardDiff.value, x)