analysis/org.eclipse.stem.util.analysis/src/org/eclipse/stem/util/analysis/ModelParameters.java - stem/org.eclipse.stem - Git at Google

 /**
  *
  */
 package org.eclipse.stem.util.analysis;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;


 /*******************************************************************************
  * Copyright (c) 2007, 2008 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/


 /**
  * This class holds all the parameters that we might want to estimate
  * and their standard deviations and variances.
  */
 public class ModelParameters {

 	/**
 	 * All model parameters are stored in this map
 	 */
 	private final HashMap<String, Parameter> parameters = new HashMap<String, Parameter>();


 	/**
 	 * All selected data as a List<double[][]> keyed by location
 	 * for display. The double indices are data[state][chartIndex][time]
 	 * where state indicates either raw data (state=0) or the selected time region of the data (state=1)
 	 * chart index selected for each of the state variables S,E,I,R (chartIndex 0-3)
 	 */
 	private final HashMap<String, List<double[][]> > selectedData = new HashMap<String, List<double[][]>>();

 	/**
 	 * All selected regression as a List<double[][]> keyed by location
 	 * for display. The double indices are data[state][time]
 	 * where state indicates either x axis (state=0) or y axis (state=1)
 	 * chart index selected for each of the state equations (chartIndex 0-3)
 	 */
 	private final HashMap<String, List<double[][]> > regressionData = new HashMap<String, List<double[][]>>();


 	/**
 	 * All selected fits to the regression as a List<double[][]> keyed by location
 	 * for display. The double indices are data[state][time]
 	 * where state indicates either x axis (state=0) or y axis (state=1)
 	 * chart index selected for each of the state equations (chartIndex 0-3)
 	 */
 	private final HashMap<String, List<double[][]> > fittedData = new HashMap<String, List<double[][]>>();


 	/**
 	 * the reference population density
 	 * required to do an average across locations with varying density
 	 */
 	public static final double REFERENCE_POPULATION_DENSITY = 100.0;


 	/**
 	 * empty constructor
 	 */
 	public ModelParameters() {
 		// Nothing here
 	}


 	/**
 	 * average the data in a map of model parameters
 	 * @param parameterIdMap
 	 * @return the averaged modelParameters
 	 */
 	public ModelParameters average(Map<String,ModelParameters> parameterIdMap) {
 		//Iterator<String> iter = parameterIdMap.keySet().iterator();
 		for (Entry<String,ModelParameters> entry : parameterIdMap.entrySet()) {

 			//while((iter!=null)&&(iter.hasNext())) {
 			//String key = iter.next();
 			ModelParameters parms = entry.getValue();
 			this.accumulateNumerator(parms);
 			this.accumulateDenominator(parms);

 			// and for display purposes save the data, by location, that went into the fit
 			Iterator<String> iter2 = parms.selectedData.keySet().iterator();
 			while((iter2!=null)&&(iter2.hasNext())) {
 				String id = iter2.next();
 				List<double[][]> data = parms.selectedData.get(id);
 				this.selectedData.put(id, data);
 			}
 			// and for display purposes save the regression, by location, that went into the fit
 			Iterator<String> iter3 = parms.regressionData.keySet().iterator();
 			while((iter3!=null)&&(iter3.hasNext())) {
 				String id = iter3.next();
 				List<double[][]> data = parms.regressionData.get(id);
 				this.regressionData.put(id, data);
 			}

 			// and for display purposes save the fitted data, by location, that went into the fit
 			Iterator<String> iter4 = parms.fittedData.keySet().iterator();
 			while((iter4!=null)&&(iter4.hasNext())) {
 				String id = iter4.next();
 				List<double[][]> data = parms.fittedData.get(id);
 				this.fittedData.put(id, data);
 			}
 		}// all locations
 		this.average();
 		this.calculateStdAvg();
 		return this;
 	}


 	HashMap <String, Double> numerators = new HashMap<String, Double>();

 	/**
 	 * accumulate numerator values from another ModelParameters instance for calculating average
 	 * @param other
 	 */
 	@SuppressWarnings("boxing")
 	private void accumulateNumerator(ModelParameters other) {

 		for(Parameter parm : other.getParameters().values()) {
 			if(numerators.containsKey(parm.name))
 				numerators.put(parm.name,
 						numerators.get(parm.name) + (parm.value / parm.variance));
 			else
 				numerators.put(parm.name,
 						parm.value / parm.variance);
 		}
 	}

 	HashMap <String, Double> denominators = new HashMap<String, Double>();

 	/**
 	 * accumulate denominator values from another ModelParameters instance for calculating average
 	 * @param other
 	 */
 	@SuppressWarnings("boxing")
 	private void accumulateDenominator(ModelParameters other) {

 		for(Parameter parm : other.getParameters().values()) {
 			if(denominators.containsKey(parm.name))
 				denominators.put(parm.name,
 						denominators.get(parm.name) + (1.0 / parm.variance));
 			else
 				denominators.put(parm.name,
 						(1.0 / parm.variance));
 		}
 	}

 	/**
 	 * divide to get average
 	 */
 	private void average() {
 		for(String parm : this.numerators.keySet()) {
 			double num = numerators.get(parm).doubleValue();
 			double denom = denominators.get(parm).doubleValue();
 			this.addParameter(parm, new Parameter(parm, num / denom  ));
 		}// for
 	}// average

 	/**
 	 * find std of each parameter average
 	 */
 	@SuppressWarnings("boxing")
 	private void calculateStdAvg() {
 		for(String parm : this.numerators.keySet()) {
 			Parameter p = this.getParameter(parm);
 			p.stddev = Math.sqrt(1.0 / denominators.get(parm));
 		}

 		// I assume the += below was a bug? - SED
 		/*		stdBeta += Math.sqrt(1/denominatorBeta);
 		stdAlpha += Math.sqrt(1/denominatorAlpha);
 		stdGamma += Math.sqrt(1/denominatorGamma);
 		stdEpsilon += Math.sqrt(1/denominatorEpsilon);
 		stdBeta2 += Math.sqrt(1/denominatorBeta2);
 		stdAlpha2 += Math.sqrt(1/denominatorAlpha2);
 		stdGamma2 += Math.sqrt(1/denominatorGamma2);
 		stdEpsilon2 += Math.sqrt(1/denominatorEpsilon2);
 		stdLambda += Math.sqrt(1/denominatorLambda);
 		 */
 	}


 	/**
 	 * add a new parameter to the map
 	 * @param name Parameter name
 	 * @param parm Parameter instance
 	 */
 	public void addParameter(String name, Parameter parm) {
 		this.parameters.put(name, parm);
 	}

 	/**
 	 * add selected data for display
 	 * @param name location name
 	 * @param data the selected data
 	 */
 	public void addSelectedData(String name, List<double[][]> data) {
 		this.selectedData.put(name, data);
 	}

 	/**
 	 * add selected regression for display
 	 * @param name location name
 	 * @param data the selected data
 	 */
 	public void addRegressionData(String name, List<double[][]> data) {
 		this.regressionData.put(name, data);
 	}


 	/**
 	 * add fitted data for display
 	 * @param name location name
 	 * @param data the selected data
 	 */
 	public void addFittedData(String name, List<double[][]> data) {
 		this.fittedData.put(name, data);
 	}


 	/**
 	 * Returns the raw data (state 0) and the selected data (state 1)
 	 * for each of the state variables S,E,I,R (chartIndex 0-3)
 	 * @param id
 	 * @param chartIndex
 	 * @param state
 	 * @return the data to plot
 	 */
 	public double[] getDataValues(String id, int chartIndex, int state) {
 		List<double[][]> dataList = selectedData.get(id);
 		double[][] data = dataList.get(chartIndex);
 		// pick the right data for the right chart
 		return data[state];
 	}

 	/**
 	 * Returns the regression data (x = state 0, y = state 1)
 	 * for each of the state equations (chartIndex 0-3)
 	 * @param id
 	 * @param chartIndex
 	 * @param state
 	 * @return the data to plot
 	 */
 	public double[] getRegressionValues(String id, int chartIndex, int state) {
 		List<double[][]> dataList = regressionData.get(id);
 		double[][] data = dataList.get(chartIndex);
 		// pick the right data for the right chart
 		return data[state];
 	}

 	/**
 	 * Returns the fitted data (x = state 0, y = state 1)
 	 * for each of the state equations (chartIndex 0-3)
 	 * @param id
 	 * @param chartIndex
 	 * @param state
 	 * @return the data to plot
 	 */
 	public double[] getFittedValues(String id, int chartIndex, int state) {
 		List<double[][]> dataList = fittedData.get(id);
 		double[][] data = dataList.get(chartIndex);
 		// pick the right data for the right chart
 		return data[state];
 	}

 	/**
 	 * validate the key
 	 * @param id
 	 * @return true if valid
 	 */
 	public boolean validDataID(String id) {
 		boolean retVal = false;
 		if ((id != null)&&(selectedData.containsKey(id))) retVal = true;
 		return retVal;
 	}

 	/**
 	 * Returns the location IDs for which we analyzed data and
 	 * stored the lists of selected data
 	 * @return the location keys
 	 */
 	public String[] getDataLocations() {
 		Set<String> keys = selectedData.keySet();
 		// pick the right data for the right chart
 		String[] ids = new String[keys.size()];
 		Iterator<String> iter = keys.iterator();
 		int i = 0;
 		while(iter!=null&&iter.hasNext()) {
 			ids[i] = iter.next();
 			i++;
 		}
 		Arrays.sort(ids);
 		return ids;
 	}


 	/**
 	 * Return the parameters
 	 * @return Map<String, Parameter> The parameters
 	 */

 	public Map<String, Parameter> getParameters() {
 		return this.parameters;
 	}

 	/**
 	 * Returns the specified parameter
 	 * @param p The parameter name
 	 * @return Parameter
 	 */

 	public Parameter getParameter(String p) {
 		return this.parameters.get(p);
 	}
 	/**
 	 * containsParameter Check if the given parameter is in this model
 	 *
 	 * @param p The parameter
 	 * @return boolean True if p is in the model
 	 */

 	public boolean containsParameter(String p) {
 		return this.parameters.containsKey(p);
 	}
 	/**
 	 * return values as a string
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		StringBuffer buffer = new StringBuffer();

 		for(Parameter parm:this.parameters.values()) {
 			buffer.append(parm.name).append("=").append(parm.value).append("\n");
 			buffer.append("deviation(").append(parm.name).append(")").append("=").append(parm.stddev).append("\n");
 			buffer.append("variance(").append(parm.name).append(")").append("=").append(parm.variance).append("\n");
 		}
 		return buffer.toString();
 	}

 }
	/**
	*
	*/
	package org.eclipse.stem.util.analysis;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;


	/*******************************************************************************
	* Copyright (c) 2007, 2008 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/


	/**
	* This class holds all the parameters that we might want to estimate
	* and their standard deviations and variances.
	*/
	public class ModelParameters {

	/**
	* All model parameters are stored in this map
	*/
	private final HashMap<String, Parameter> parameters = new HashMap<String, Parameter>();


	/**
	* All selected data as a List<double[][]> keyed by location
	* for display. The double indices are data[state][chartIndex][time]
	* where state indicates either raw data (state=0) or the selected time region of the data (state=1)
	* chart index selected for each of the state variables S,E,I,R (chartIndex 0-3)
	*/
	private final HashMap<String, List<double[][]> > selectedData = new HashMap<String, List<double[][]>>();

	/**
	* All selected regression as a List<double[][]> keyed by location
	* for display. The double indices are data[state][time]
	* where state indicates either x axis (state=0) or y axis (state=1)
	* chart index selected for each of the state equations (chartIndex 0-3)
	*/
	private final HashMap<String, List<double[][]> > regressionData = new HashMap<String, List<double[][]>>();


	/**
	* All selected fits to the regression as a List<double[][]> keyed by location
	* for display. The double indices are data[state][time]
	* where state indicates either x axis (state=0) or y axis (state=1)
	* chart index selected for each of the state equations (chartIndex 0-3)
	*/
	private final HashMap<String, List<double[][]> > fittedData = new HashMap<String, List<double[][]>>();




	/**
	* the reference population density
	* required to do an average across locations with varying density
	*/
	public static final double REFERENCE_POPULATION_DENSITY = 100.0;


	/**
	* empty constructor
	*/
	public ModelParameters() {
	// Nothing here
	}


	/**
	* average the data in a map of model parameters
	* @param parameterIdMap
	* @return the averaged modelParameters
	*/
	public ModelParameters average(Map<String,ModelParameters> parameterIdMap) {
	//Iterator<String> iter = parameterIdMap.keySet().iterator();
	for (Entry<String,ModelParameters> entry : parameterIdMap.entrySet()) {

	//while((iter!=null)&&(iter.hasNext())) {
	//String key = iter.next();
	ModelParameters parms = entry.getValue();
	this.accumulateNumerator(parms);
	this.accumulateDenominator(parms);

	// and for display purposes save the data, by location, that went into the fit
	Iterator<String> iter2 = parms.selectedData.keySet().iterator();
	while((iter2!=null)&&(iter2.hasNext())) {
	String id = iter2.next();
	List<double[][]> data = parms.selectedData.get(id);
	this.selectedData.put(id, data);
	}
	// and for display purposes save the regression, by location, that went into the fit
	Iterator<String> iter3 = parms.regressionData.keySet().iterator();
	while((iter3!=null)&&(iter3.hasNext())) {
	String id = iter3.next();
	List<double[][]> data = parms.regressionData.get(id);
	this.regressionData.put(id, data);
	}

	// and for display purposes save the fitted data, by location, that went into the fit
	Iterator<String> iter4 = parms.fittedData.keySet().iterator();
	while((iter4!=null)&&(iter4.hasNext())) {
	String id = iter4.next();
	List<double[][]> data = parms.fittedData.get(id);
	this.fittedData.put(id, data);
	}
	}// all locations
	this.average();
	this.calculateStdAvg();
	return this;
	}


	HashMap <String, Double> numerators = new HashMap<String, Double>();

	/**
	* accumulate numerator values from another ModelParameters instance for calculating average
	* @param other
	*/
	@SuppressWarnings("boxing")
	private void accumulateNumerator(ModelParameters other) {

	for(Parameter parm : other.getParameters().values()) {
	if(numerators.containsKey(parm.name))
	numerators.put(parm.name,
	numerators.get(parm.name) + (parm.value / parm.variance));
	else
	numerators.put(parm.name,
	parm.value / parm.variance);
	}
	}

	HashMap <String, Double> denominators = new HashMap<String, Double>();

	/**
	* accumulate denominator values from another ModelParameters instance for calculating average
	* @param other
	*/
	@SuppressWarnings("boxing")
	private void accumulateDenominator(ModelParameters other) {

	for(Parameter parm : other.getParameters().values()) {
	if(denominators.containsKey(parm.name))
	denominators.put(parm.name,
	denominators.get(parm.name) + (1.0 / parm.variance));
	else
	denominators.put(parm.name,
	(1.0 / parm.variance));
	}
	}

	/**
	* divide to get average
	*/
	private void average() {
	for(String parm : this.numerators.keySet()) {
	double num = numerators.get(parm).doubleValue();
	double denom = denominators.get(parm).doubleValue();
	this.addParameter(parm, new Parameter(parm, num / denom ));
	}// for
	}// average

	/**
	* find std of each parameter average
	*/
	@SuppressWarnings("boxing")
	private void calculateStdAvg() {
	for(String parm : this.numerators.keySet()) {
	Parameter p = this.getParameter(parm);
	p.stddev = Math.sqrt(1.0 / denominators.get(parm));
	}

	// I assume the += below was a bug? - SED
	/* stdBeta += Math.sqrt(1/denominatorBeta);
	stdAlpha += Math.sqrt(1/denominatorAlpha);
	stdGamma += Math.sqrt(1/denominatorGamma);
	stdEpsilon += Math.sqrt(1/denominatorEpsilon);
	stdBeta2 += Math.sqrt(1/denominatorBeta2);
	stdAlpha2 += Math.sqrt(1/denominatorAlpha2);
	stdGamma2 += Math.sqrt(1/denominatorGamma2);
	stdEpsilon2 += Math.sqrt(1/denominatorEpsilon2);
	stdLambda += Math.sqrt(1/denominatorLambda);
	*/
	}


	/**
	* add a new parameter to the map
	* @param name Parameter name
	* @param parm Parameter instance
	*/
	public void addParameter(String name, Parameter parm) {
	this.parameters.put(name, parm);
	}

	/**
	* add selected data for display
	* @param name location name
	* @param data the selected data
	*/
	public void addSelectedData(String name, List<double[][]> data) {
	this.selectedData.put(name, data);
	}

	/**
	* add selected regression for display
	* @param name location name
	* @param data the selected data
	*/
	public void addRegressionData(String name, List<double[][]> data) {
	this.regressionData.put(name, data);
	}


	/**
	* add fitted data for display
	* @param name location name
	* @param data the selected data
	*/
	public void addFittedData(String name, List<double[][]> data) {
	this.fittedData.put(name, data);
	}


	/**
	* Returns the raw data (state 0) and the selected data (state 1)
	* for each of the state variables S,E,I,R (chartIndex 0-3)
	* @param id
	* @param chartIndex
	* @param state
	* @return the data to plot
	*/
	public double[] getDataValues(String id, int chartIndex, int state) {
	List<double[][]> dataList = selectedData.get(id);
	double[][] data = dataList.get(chartIndex);
	// pick the right data for the right chart
	return data[state];
	}

	/**
	* Returns the regression data (x = state 0, y = state 1)
	* for each of the state equations (chartIndex 0-3)
	* @param id
	* @param chartIndex
	* @param state
	* @return the data to plot
	*/
	public double[] getRegressionValues(String id, int chartIndex, int state) {
	List<double[][]> dataList = regressionData.get(id);
	double[][] data = dataList.get(chartIndex);
	// pick the right data for the right chart
	return data[state];
	}

	/**
	* Returns the fitted data (x = state 0, y = state 1)
	* for each of the state equations (chartIndex 0-3)
	* @param id
	* @param chartIndex
	* @param state
	* @return the data to plot
	*/
	public double[] getFittedValues(String id, int chartIndex, int state) {
	List<double[][]> dataList = fittedData.get(id);
	double[][] data = dataList.get(chartIndex);
	// pick the right data for the right chart
	return data[state];
	}

	/**
	* validate the key
	* @param id
	* @return true if valid
	*/
	public boolean validDataID(String id) {
	boolean retVal = false;
	if ((id != null)&&(selectedData.containsKey(id))) retVal = true;
	return retVal;
	}

	/**
	* Returns the location IDs for which we analyzed data and
	* stored the lists of selected data
	* @return the location keys
	*/
	public String[] getDataLocations() {
	Set<String> keys = selectedData.keySet();
	// pick the right data for the right chart
	String[] ids = new String[keys.size()];
	Iterator<String> iter = keys.iterator();
	int i = 0;
	while(iter!=null&&iter.hasNext()) {
	ids[i] = iter.next();
	i++;
	}
	Arrays.sort(ids);
	return ids;
	}



	/**
	* Return the parameters
	* @return Map<String, Parameter> The parameters
	*/

	public Map<String, Parameter> getParameters() {
	return this.parameters;
	}

	/**
	* Returns the specified parameter
	* @param p The parameter name
	* @return Parameter
	*/

	public Parameter getParameter(String p) {
	return this.parameters.get(p);
	}
	/**
	* containsParameter Check if the given parameter is in this model
	*
	* @param p The parameter
	* @return boolean True if p is in the model
	*/

	public boolean containsParameter(String p) {
	return this.parameters.containsKey(p);
	}
	/**
	* return values as a string
	* @see java.lang.Object#toString()
	*/
	@Override
	public String toString() {
	StringBuffer buffer = new StringBuffer();

	for(Parameter parm:this.parameters.values()) {
	buffer.append(parm.name).append("=").append(parm.value).append("\n");
	buffer.append("deviation(").append(parm.name).append(")").append("=").append(parm.stddev).append("\n");
	buffer.append("variance(").append(parm.name).append(")").append("=").append(parm.variance).append("\n");
	}
	return buffer.toString();
	}

	}