import java.util.ArrayList;
import java.util.List;
import org.apache.commons.math3.analysis.UnivariateFunction;
import org.apache.commons.math3.analysis.integration.SimpsonIntegrator;
import org.apache.commons.math3.analysis.integration.UnivariateIntegrator;
interface TestCase 
{
	public Object run(List<Object> params) throws Exception;
	public List<Object> getParams();
	public void printResult(Object result) throws Exception;
}
public class TimeCostCalculator 
{
	public TimeCostCalculator() 
	  {
	}
	/** 
  * 計(jì)算指定對象的運(yùn)行時(shí)間開銷。 
  * 
  * @param testCase 指定被測對象。 
  * @return 返回sub.run的時(shí)間開銷，單位為s。 
  * @throws Exception 
  */
	private double calcTimeCost(TestCase testCase) throws Exception 
	  {
		List<Object> params = testCase.getParams();
		long startTime = System.nanoTime();
		Object result = testCase.run(params);
		long stopTime = System.nanoTime();
		testCase.printResult(result);
		double timeCost = (stopTime - startTime) * 1.0e-9;
		return timeCost;
	}
	public void runTest(TestCase testCase) throws Exception 
	  {
		double timeCost = calcTimeCost(testCase);
		System.out.println("時(shí)間開銷：: " + timeCost + "s");
		System.out.println("-------------------------------------------------------------------------------");
	}
	public static void main(String[] args) throws Exception 
	  {
		TimeCostCalculator tcc = new TimeCostCalculator();
		tcc.runTest(new CalcSimpsonIntegrator());
	}
}
/** 
 * 使用辛普森法求解數(shù)值積分。Apache.Common.Math3中所用的辛普森法是采用逼近法，即先對整個(gè)積分區(qū)間用矩形積分，然后將區(qū)間分解為4份，再次積分，比較兩次積分的差值，若想對誤差大于某個(gè)預(yù)訂數(shù)值， 
 * 則認(rèn)為還需要繼續(xù)細(xì)分區(qū)間，因此會(huì)將區(qū)間以2倍再次細(xì)分后求積分，并將結(jié)果與前一次積分的結(jié)果比較，直至差值小于指定的誤差，就停止。 
 * @author kingfox 
 * 
 */
class CalcSimpsonIntegrator implements TestCase 
{
	public CalcSimpsonIntegrator() 
	  {
		System.out.print("本算例用于測試使用辛普森法計(jì)算積分。正在初始化計(jì)算數(shù)據(jù) ... ...");
		inputData = new double[arrayLength];
		for (int index = 0; index < inputData.length; index++)  // 鏂滃潯鍑芥暟 
		{
			inputData[index] = Math.sin(2 * Math.PI * index * MyFunction.factor * 4);
		}
		func = new MyFunction();
		integrator = new SimpsonIntegrator();
		System.out.println("初始化完成!");
	}
	@Override 
	  public Object run(List<Object> params) throws Exception 
	  {
		double result = ((SimpsonIntegrator)(params.get(1))).integrate(steps, (UnivariateFunction)(params.get(0)), lower, upper);
		return result;
	}
	/** 
  * 獲取運(yùn)行參數(shù) 
  * @return List對象，第一個(gè)元素是求積函數(shù)，第二個(gè)參數(shù)是積分器。 
  */
	@Override 
	  public List<Object> getParams() 
	  {
		List<Object> params = new ArrayList<Object>();
		params.add(func);
		params.add(integrator);
		return params;
	}
	@Override 
	  public void printResult(Object result) throws Exception 
	  {
		System.out.println(">>> integration value: " + result);
	}
	UnivariateFunction func = null;
	UnivariateIntegrator integrator = null;
	class MyFunction implements UnivariateFunction 
	  {
		@Override 
		   public double value(double x) 
		   {
			//     double y = x * factor;   // 1. 
			//     double y = 4.0 * x * x * x - 3.0 * x * x + 2.0 * x - 1.0;  // 2. 
			//     double y = -1.0 * Math.sin(x) + 2.0 * Math.cos(x) - 3.0;   // 3. 
			double y = inputData[(int)(x / factor)];
			// 4. 
			//     System.out.println(x + ", " + y); 
			return y;
		}
		private static final double factor = 0.0001;
	}
	private double[] inputData = null;
	private static final int arrayLength = 5000;
	private static final double lower = 0.0;
	//  private static final double upper = 2.0 * Math.PI;   // 3. 
	private static final double upper = (arrayLength - 1) * MyFunction.factor;
	// 1. 2. 4. 
	private static final int steps = 1000000;
}