Merge remote-tracking branch 'remotes/hypoactiv/master'

Closes #102

Author: vladimir-ch

backtracking.go

@@ -32,7 +32,7 @@ type Backtracking struct {
 	initG    float64
 }
 
-func (b *Backtracking) Init(loc LinesearchLocation, step float64, _ *FunctionInfo) EvaluationType {
+func (b *Backtracking) Init(loc LinesearchLocation, step float64, _ *ProblemInfo) EvaluationType {
 	if step <= 0 {
 		panic("backtracking: bad step size")
 	}

bfgs.go

@@ -41,7 +41,7 @@ type BFGS struct {
 // NOTE: This method exists so that it's easier to use a bfgs algorithm because
 // it implements Method
 
-func (b *BFGS) Init(loc *Location, f *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error) {
+func (b *BFGS) Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error) {
 	if b.LinesearchMethod == nil {
 		b.LinesearchMethod = &Bisection{}
 	}
@@ -51,7 +51,7 @@ func (b *BFGS) Init(loc *Location, f *FunctionInfo, xNext []float64) (Evaluation
 	b.linesearch.Method = b.LinesearchMethod
 	b.linesearch.NextDirectioner = b
 
-	return b.linesearch.Init(loc, f, xNext)
+	return b.linesearch.Init(loc, p, xNext)
 }
 
 func (b *BFGS) Iterate(loc *Location, xNext []float64) (EvaluationType, IterationType, error) {

bisection.go

@@ -26,7 +26,7 @@ type Bisection struct {
 	maxGrad  float64
 }
 
-func (b *Bisection) Init(loc LinesearchLocation, step float64, _ *FunctionInfo) EvaluationType {
+func (b *Bisection) Init(loc LinesearchLocation, step float64, _ *ProblemInfo) EvaluationType {
 	if loc.Derivative >= 0 {
 		panic("bisection: init G non-negative")
 	}

cg.go

@@ -94,7 +94,7 @@ type CG struct {
 	gradPrevNorm float64
 }
 
-func (cg *CG) Init(loc *Location, funcInfo *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error) {
+func (cg *CG) Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error) {
 	if cg.IterationRestartFactor < 0 {
 		panic("cg: IterationRestartFactor is negative")
 	}
@@ -125,7 +125,7 @@ func (cg *CG) Init(loc *Location, funcInfo *FunctionInfo, xNext []float64) (Eval
 	cg.linesearch.Method = cg.LinesearchMethod
 	cg.linesearch.NextDirectioner = cg
 
-	return cg.linesearch.Init(loc, funcInfo, xNext)
+	return cg.linesearch.Init(loc, p, xNext)
 }
 
 func (cg *CG) Iterate(loc *Location, xNext []float64) (EvaluationType, IterationType, error) {

gradientdescent.go

@@ -18,7 +18,7 @@ type GradientDescent struct {
 	linesearch *Linesearch
 }
 
-func (g *GradientDescent) Init(loc *Location, f *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error) {
+func (g *GradientDescent) Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error) {
 	if g.StepSizer == nil {
 		g.StepSizer = &QuadraticStepSize{}
 	}
@@ -31,7 +31,7 @@ func (g *GradientDescent) Init(loc *Location, f *FunctionInfo, xNext []float64)
 	g.linesearch.Method = g.LinesearchMethod
 	g.linesearch.NextDirectioner = g
 
-	return g.linesearch.Init(loc, f, xNext)
+	return g.linesearch.Init(loc, p, xNext)
 }
 
 func (g *GradientDescent) Iterate(loc *Location, xNext []float64) (EvaluationType, IterationType, error) {

interfaces.go

@@ -4,34 +4,14 @@
 
 package optimize
 
-import "github.com/gonum/matrix/mat64"
-
-// Function evaluates the objective function at the given location. F
-// must not modify x.
-type Function interface {
-	Func(x []float64) (obj float64)
-}
-
-// Gradient evaluates the gradient at x and stores the result in-place in grad.
-// Grad must not modify x.
-type Gradient interface {
-	Grad(x, grad []float64)
-}
-
-// Hessian evaluates the Hessian at x and stores the result in-place in hess.
-// Hess must not modify x.
-type Hessian interface {
-	Hess(x []float64, hess *mat64.SymDense)
-}
-
 // LinesearchMethod is a type that can perform a line search. Typically, these
 // methods will not be called by the user directly, as they will be called by
 // a Linesearch struct.
 type LinesearchMethod interface {
 	// Init initializes the linesearch method. LinesearchLocation contains the
 	// function information at step == 0, and step contains the first step length
 	// as specified by the NextDirectioner.
-	Init(loc LinesearchLocation, step float64, f *FunctionInfo) EvaluationType
+	Init(loc LinesearchLocation, step float64, p *ProblemInfo) EvaluationType
 
 	// Finished takes in the function result at the most recent linesearch location,
 	// and returns true if the line search has been concluded.
@@ -62,7 +42,7 @@ type NextDirectioner interface {
 // A Method can optimize an objective function.
 type Method interface {
 	// Initializes the method and returns the first location to evaluate
-	Init(loc *Location, f *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error)
+	Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error)
 
 	// Stores the next location to evaluate in xNext
 	Iterate(loc *Location, xNext []float64) (EvaluationType, IterationType, error)

lbfgs.go

@@ -38,7 +38,7 @@ type LBFGS struct {
 	rhoHist []float64   // last Store iterations of rho
 }
 
-func (l *LBFGS) Init(loc *Location, f *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error) {
+func (l *LBFGS) Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error) {
 	if l.LinesearchMethod == nil {
 		l.LinesearchMethod = &Bisection{}
 	}
@@ -47,7 +47,7 @@ func (l *LBFGS) Init(loc *Location, f *FunctionInfo, xNext []float64) (Evaluatio
 	}
 	l.linesearch.Method = l.LinesearchMethod
 	l.linesearch.NextDirectioner = l
-	return l.linesearch.Init(loc, f, xNext)
+	return l.linesearch.Init(loc, p, xNext)
 }
 
 func (l *LBFGS) Iterate(loc *Location, xNext []float64) (EvaluationType, IterationType, error) {

linesearch.go

@@ -21,13 +21,13 @@ type Linesearch struct {
 	initX []float64
 	dir   []float64
 
-	funcInfo *FunctionInfo
+	probInfo *ProblemInfo
 
 	lastEvalType EvaluationType
 	iterType     IterationType
 }
 
-func (ls *Linesearch) Init(loc *Location, f *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error) {
+func (ls *Linesearch) Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error) {
 	ls.initX = resize(ls.initX, len(loc.X))
 	copy(ls.initX, loc.X)
 
@@ -45,9 +45,9 @@ func (ls *Linesearch) Init(loc *Location, f *FunctionInfo, xNext []float64) (Eva
 		F:          loc.F,
 		Derivative: projGrad,
 	}
-	evalType := ls.Method.Init(lsLoc, stepSize, f)
+	evalType := ls.Method.Init(lsLoc, stepSize, p)
 	floats.AddScaledTo(xNext, ls.initX, stepSize, ls.dir)
-	ls.funcInfo = f
+	ls.probInfo = p
 	ls.lastEvalType = evalType
 	ls.iterType = MinorIteration
 	return evalType, ls.iterType, nil
@@ -120,7 +120,7 @@ func (ls *Linesearch) initNextLinesearch(loc *Location, xNext []float64) (Evalua
 		F:          loc.F,
 		Derivative: projGrad,
 	}
-	evalType := ls.Method.Init(lsLoc, stepsize, ls.funcInfo)
+	evalType := ls.Method.Init(lsLoc, stepsize, ls.probInfo)
 	floats.AddScaledTo(xNext, ls.initX, stepsize, ls.dir)
 	// Compare the starting point for the current iteration with the next
 	// evaluation point to make sure that rounding errors do not prevent progress.

local.go

@@ -49,22 +49,25 @@ import (
 // function evaluations. If you would like to put limits on this, for example
 // maximum runtime or maximum function evaluations, please modify the Settings
 // input struct.
-func Local(f Function, initX []float64, settings *Settings, method Method) (*Result, error) {
+func Local(p Problem, initX []float64, settings *Settings, method Method) (*Result, error) {
+	if p.Func == nil {
+		panic("optimize: objective function is undefined")
+	}
 	if len(initX) == 0 {
 		panic("optimize: initial X has zero length")
 	}
 
 	startTime := time.Now()
-	funcInfo := newFunctionInfo(f)
+
 	if method == nil {
-		method = getDefaultMethod(funcInfo)
+		method = getDefaultMethod(&p)
 	}
-	if err := funcInfo.satisfies(method); err != nil {
+	if err := p.satisfies(method); err != nil {
 		return nil, err
 	}
 
-	if funcInfo.IsStatuser {
-		_, err := funcInfo.statuser.Status()
+	if p.Status != nil {
+		_, err := p.Status()
 		if err != nil {
 			return nil, err
 		}
@@ -84,7 +87,7 @@ func Local(f Function, initX []float64, settings *Settings, method Method) (*Res
 	}
 
 	stats := &Stats{}
-	optLoc, evalType, err := getStartingLocation(funcInfo, method, initX, stats, settings)
+	optLoc, evalType, err := getStartingLocation(&p, method, initX, stats, settings)
 	if err != nil {
 		return nil, err
 	}
@@ -106,7 +109,7 @@ func Local(f Function, initX []float64, settings *Settings, method Method) (*Res
 		// The starting location is not good enough, we need to perform a
 		// minimization. The optimal location will be stored in-place in
 		// optLoc.
-		status, err = minimize(settings, method, funcInfo, stats, optLoc, startTime)
+		status, err = minimize(settings, method, &p, stats, optLoc, startTime)
 	}
 
 	if settings.Recorder != nil && err == nil {
@@ -121,30 +124,30 @@ func Local(f Function, initX []float64, settings *Settings, method Method) (*Res
 	}, err
 }
 
-func minimize(settings *Settings, method Method, funcInfo *functionInfo, stats *Stats, optLoc *Location, startTime time.Time) (status Status, err error) {
+func minimize(settings *Settings, method Method, p *Problem, stats *Stats, optLoc *Location, startTime time.Time) (status Status, err error) {
 	loc := &Location{}
 	copyLocation(loc, optLoc)
 	xNext := make([]float64, len(loc.X))
 
 	methodStatus, methodIsStatuser := method.(Statuser)
 
-	evalType, iterType, err := method.Init(loc, &funcInfo.FunctionInfo, xNext)
+	evalType, iterType, err := method.Init(loc, newProblemInfo(p), xNext)
 	if err != nil {
 		return Failure, err
 	}
 
 	for {
-		if funcInfo.IsStatuser {
+		if p.Status != nil {
 			// Check the function status before evaluating.
-			status, err = funcInfo.statuser.Status()
+			status, err = p.Status()
 			if err != nil || status != NotTerminated {
 				return
 			}
 		}
 
 		// Perform evalType evaluation of the function at xNext and store the
 		// result in location.
-		evaluate(funcInfo, evalType, xNext, loc, stats)
+		evaluate(p, evalType, xNext, loc, stats)
 		// Update the stats and optLoc.
 		update(loc, optLoc, stats, iterType, startTime)
 		// Get the convergence status before recording the new location.
@@ -198,15 +201,15 @@ func copyLocation(dst, src *Location) {
 	}
 }
 
-func getDefaultMethod(funcInfo *functionInfo) Method {
-	if funcInfo.IsGradient {
+func getDefaultMethod(p *Problem) Method {
+	if p.Grad != nil {
 		return &BFGS{}
 	}
 	return &NelderMead{}
 }
 
 // getStartingLocation allocates and initializes the starting location for the minimization.
-func getStartingLocation(funcInfo *functionInfo, method Method, initX []float64, stats *Stats, settings *Settings) (*Location, EvaluationType, error) {
+func getStartingLocation(p *Problem, method Method, initX []float64, stats *Stats, settings *Settings) (*Location, EvaluationType, error) {
 	dim := len(initX)
 	loc := &Location{
 		X: make([]float64, dim),
@@ -250,7 +253,7 @@ func getStartingLocation(funcInfo *functionInfo, method Method, initX []float64,
 		if loc.Hessian != nil {
 			evalType |= HessEvaluation
 		}
-		evaluate(funcInfo, evalType, loc.X, loc, stats)
+		evaluate(p, evalType, loc.X, loc, stats)
 	}
 
 	if math.IsNaN(loc.F) {
@@ -345,11 +348,11 @@ func invalidate(loc *Location) {
 	}
 }
 
-// evaluate evaluates the function given by f at xNext, stores the answer into
+// evaluate evaluates the problem given by p at xNext, stores the answer into
 // loc and updates stats. If loc.X is not equal to xNext, then unused fields of
 // loc are set to NaN.
 // evaluate panics if the function does not support the requested evalType.
-func evaluate(f *functionInfo, evalType EvaluationType, xNext []float64, loc *Location, stats *Stats) {
+func evaluate(p *Problem, evalType EvaluationType, xNext []float64, loc *Location, stats *Stats) {
 	if !floats.Equal(loc.X, xNext) {
 		if evalType == NoEvaluation {
 			// Optimizers should not request NoEvaluation at a new location.
@@ -362,17 +365,17 @@ func evaluate(f *functionInfo, evalType EvaluationType, xNext []float64, loc *Lo
 
 	toEval := evalType
 	if evalType&FuncEvaluation != 0 {
-		loc.F = f.function.Func(loc.X)
+		loc.F = p.Func(loc.X)
 		stats.FuncEvaluations++
 		toEval &= ^FuncEvaluation
 	}
 	if evalType&GradEvaluation != 0 {
-		f.gradient.Grad(loc.X, loc.Gradient)
+		p.Grad(loc.X, loc.Gradient)
 		stats.GradEvaluations++
 		toEval &= ^GradEvaluation
 	}
 	if evalType&HessEvaluation != 0 {
-		f.hessian.Hess(loc.X, loc.Hessian)
+		p.Hess(loc.X, loc.Hessian)
 		stats.HessEvaluations++
 		toEval &= ^HessEvaluation
 	}

neldermead.go

@@ -81,7 +81,7 @@ type NelderMead struct {
 	reflectedValue float64    // Value at the last reflection point
 }
 
-func (n *NelderMead) Init(loc *Location, f *FunctionInfo, xNext []float64) (EvaluationType, IterationType, error) {
+func (n *NelderMead) Init(loc *Location, p *ProblemInfo, xNext []float64) (EvaluationType, IterationType, error) {
 	dim := len(loc.X)
 	if cap(n.vertices) < dim+1 {
 		n.vertices = make([][]float64, dim+1)