view src/samer/maths/opt/State.java @ 0:bf79fb79ee13

Initial Mercurial check in.

/*
 *	Copyright (c) 2000, Samer Abdallah, King's College London.
 *	All rights reserved.
 *
 *	This software is provided AS iS and WITHOUT ANY WARRANTY; 
 *	without even the implied warranty of MERCHANTABILITY or 
 *	FITNESS FOR A PARTICULAR PURPOSE.
 */

package samer.maths.opt;
import  samer.maths.*;
import  samer.core.*;

public class State
{
	public Functionx	func;			// function
	public int			n;				// number of dimensions
	public double[]	h;				// search direction
	public Datum		P1, P2;		// two bracket points and a new point
	public double		alpha;		// step length
	public double		normh;		// some norm of h

	/** x must have an accessible array */
	public State( Vec x, Functionx func)
	{
		this.n = x.size();
		this.func = func;
		P1 = new Datum(n,x.array());
		P2 = new Datum(n);
		h = new double[n];
	}

	public void dispose() 
	{ 
		func.dispose(); 
		P1.dispose(); 
		P2.dispose(); 
		h=null; 
	}

	/** estimated step to minimum using cubic interpolation of current state */
	public final double cubic() { return Util.cubici(P1.f,P1.s,P2.f,P2.s,alpha); }

	/** evaluate at P1 */
	public final void evaluate() { func.evaluate(P1);	}

	/** move P1 to where P2 is now */
	public final void move() { P1.copy(P2); } // assert that P1.s<0 ?

	/** take step of length lambda from 
	    P1 in direction of h, evaluate and store in P2 */
	public void step(double lambda)
	{
		for (int i=0; i<n; i++) {
			P2.x[i] = P1.x[i] + lambda*h[i];
		}

		func.evaluate(P2);
		P2.s = Mathx.dot(P2.g,h);
		alpha=lambda;
	}

	/** evaluate at P2 */
	public final void eval2()
	{
		func.evaluate(P2);
		P2.s = Mathx.dot(P2.g,h);
	}

	/** evaluate slope at P1 using gradient at P1 */	
	public final void setSlope() { 
		double s1 = Mathx.dot(P1.g,h); 
		if (Double.isNaN(s1)) throw new Error( "slope 1 is NaN");
		if (s1>0) {
			Shell.trace(toString());
			Shell.trace("bad new slope="+s1);
		}
		P1.s = s1;
	}

	/** set slope at P2, assert new slope is negative */	
	public final void setSlope2(double s2)
	{
		if (Double.isNaN(s2)) throw new Error( "slope 2 is NaN");

		if (s2>0) {
			Shell.trace(" ***** BAD DIRECTION UPDATE **** ");
			Shell.trace(toString());
			Shell.trace("-- slope = "+s2);
		}
	
		P2.s=s2;
	}

	public String toString() {
		return append(new StringBuffer()).toString();
	}
	
	public double initialStep() {
		double step=2*Math.abs(P1.f/P1.s);
		if (Double.isNaN(step)) return 1;
		return Util.clip(0.01,step,1);
	}

	/** estimate initial step for line search after turn */
	public double nextStep()
	{
		double beta;

		if (P2.s<=P1.s) return 1;		
		if (P2.s>0) {
			// signal: 'overshoot, updhess'
			// expect beta between 0 and 1
			if (alpha<0.9) beta=alpha;
			else beta=cubic();
			if (Double.isNaN(beta) || Double.isInfinite(beta)) beta=1;
		} else {
			// signal: 'undershoot, updhess'
			double gamma=1.5*alpha; if (gamma<2) gamma=2;
			double delta=alpha*(P2.s-P1.s)-P2.s+(alpha>1?alpha:1);
			// double delta=uv-P2.s+(alpha>1?alpha:1);
			beta=cubic();
			if (Double.isNaN(beta) || Double.isInfinite(beta) || beta<alpha) beta=2*alpha+1e-5;
			beta*=1.2;
			if (gamma<beta) beta=gamma;
			if (delta<beta) beta=delta;
		}

		return beta;
	}

	public StringBuffer append(StringBuffer info) 
	{
		info.append(DoubleFormat.format(P1.f,4))
			.append(", ")
			.append(DoubleFormat.format(P1.s,4))
			.append("\t")
			.append(DoubleFormat.format(alpha,4))
			.append("\t")
			.append(DoubleFormat.format(P2.f,4))
			.append(", ")
			.append(DoubleFormat.format(P2.s,4))
			.append(" : "); // .append(this.info);
		return info;		
	}
}