Merge branch 'kellertuer/main-types' of github.com:JuliaManifolds/AlgorithmsInterface.jl into kellertuer/main-types

Author: kellertuer

src/interface/interface.jl

@@ -34,7 +34,7 @@ end
 @doc """
     solve(p::Problem, a::Algorithm; kwargs...)
 
-Solve the Solve the [`Problem`](@ref) `p` using the [`Algorithm`](@ref) `a`.
+Solve the [`Problem`](@ref) `p` using the [`Algorithm`](@ref) `a`.
 The keyword arguments `kwargs...` have to provide enough details such that
 the corresponding state initialisation [`initialize_state`](@ref)`(p,a)`
 returns a state.
@@ -60,6 +60,7 @@ function solve!(s::State, p::Problem, a::Algorithm; kwargs...)
         increment!(s)
         step!(p, a, s)
     end
+    return s
 end
 
 function step! end

test/newton.jl

@@ -0,0 +1,57 @@
+# Newton's method for finding roots of a function
+# wrapped as a very simple iterative algorithm
+
+using AlgorithmsInterface
+import AlgorithmsInterface: initialize_state, initialize_state!, is_finished, solve!, step!
+using Test
+
+# Defining the structs
+# ------------------
+struct RootFindingProblem <: Problem
+    f::Function
+    df::Function
+end
+
+struct NewtonMethod{S} <: Algorithm
+    stopping_criterion::S
+    # TODO: logging settings? stopping criterium initialization?
+end
+
+mutable struct NewtonState{S} <: State
+    iteration::Int
+    iterate::Float64
+    stopping_criterion::S
+end
+
+# Implementing the algorithm
+# --------------------------
+function initialize_state(::RootFindingProblem, algorithm::NewtonMethod)
+    return NewtonState(0, 1.0, algorithm.stopping_criterion) # hardcode initial guess to 1.0
+end
+function initialize_state!(::RootFindingProblem, algorithm::NewtonMethod, state::NewtonState)
+    state.iteration = 0
+    state.iterate = 1.0
+    state.stopping_criterion = algorithm.stopping_criterion
+end
+
+function step!(problem::RootFindingProblem, ::NewtonMethod, state::NewtonState)
+    state.iterate -= problem.f(state.iterate) / problem.df(state.iterate)
+    return state
+end
+
+# Testing the algorithm
+# ---------------------
+@testset "Babylonian square roots" begin
+    f(x, a) = x^2 - a
+    df(x, a) = 2x
+
+    a = 612.0
+    problem = RootFindingProblem(x -> f(x, a), x -> df(x, a))
+    algorithm1 = NewtonMethod(StopAfterIteration(8))
+    solution1 = solve(problem, algorithm1)
+    @test solution1.iterate ≈ sqrt(a)
+    algorithm2 = NewtonMethod(StopAfterIteration(10))
+    solution2 = solve(problem, algorithm2)
+    @test solution2.iterate ≈ sqrt(a)
+    @test abs(solution2.iterate - sqrt(a)) < abs(solution1.iterate - sqrt(a))
+end

test/runtests.jl

@@ -1,5 +1,7 @@
 using AlgorithmsInterface, Test
 
-@testset "AlgorithmsInterface.jl" begin
-
+let
+    @testset "Newton" begin
+        include("newton.jl")
+    end
 end