prism-accumulation/prism/src/explicit/Utils.java

//==============================================================================
//	
//	Copyright (c) 2002-
//	Authors:
//	* Dave Parker <david.parker@comlab.ox.ac.uk> (University of Oxford)
//	
//------------------------------------------------------------------------------
//	
//	This file is part of PRISM.
//	
//	PRISM is free software; you can redistribute it and/or modify
//	it under the terms of the GNU General Public License as published by
//	the Free Software Foundation; either version 2 of the License, or
//	(at your option) any later version.
//	
//	PRISM is distributed in the hope that it will be useful,
//	but WITHOUT ANY WARRANTY; without even the implied warranty of
//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//	GNU General Public License for more details.
//	
//	You should have received a copy of the GNU General Public License
//	along with PRISM; if not, write to the Free Software Foundation,
//	Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//	
//==============================================================================

package explicit;

import java.util.BitSet;

public class Utils
{
	/**
	 * Compute the minimum or maximum value over a subset of an array of doubles.
	 * @param array: The array
	 * @param subset: The subset
	 * @param min: Min or max (true = min, false = max) 
	 */
	public static double minMaxOverArraySubset(double[] array, Iterable<Integer> subset, boolean min)
	{
		if (min)
			return minOverArraySubset(array, subset);
		else
			return maxOverArraySubset(array, subset);
	}
	
	/**
	 * Compute the minimum value over a subset of an array of doubles.
	 * @param array: The array
	 * @param subset: The subset
	 */
	public static double minOverArraySubset(double[] array, Iterable<Integer> subset)
	{
		double d;
		d = Double.POSITIVE_INFINITY;
		for (int j : subset) {
			if (array[j] < d)
				d = array[j];
		}
		return d;
	}
	
	/**
	 * Compute the maximum value over a subset of an array of doubles.
	 * @param array: The array
	 * @param subset: The subset
	 */
	public static double maxOverArraySubset(double[] array, Iterable<Integer> subset)
	{
		double d;
		d = Double.NEGATIVE_INFINITY;
		for (int j : subset) {
			if (array[j] > d)
				d = array[j];
		}
		return d;
	}
	
	/**
	 * Create an n-element array of doubles (0s and 1s) from a BitSet.
	 *  @param bs: The bitset specifying 0s and 1s
	 *  @param n: The size of the array.
	 */
	public static double[] bitsetToDoubleArray(BitSet bs, int n)
	{
		int i;
		double res[] = new double[n];
		for (i = 0; i < n; i++)
			res[i] = bs.get(i) ? 1.0 : 0.0;
		return res;
	}

	/**
	 * Extend a double array to be at least as big as requested size.
	 * @param array: The array to be resized
	 * @param nOld: The size of the old array (not necessarily array.length)
	 * @param nNew: The desired new size
	 * @param valNew: Value to initialise new elements with
	 * @return: The new array
	 */
	public static double[] extendDoubleArray(double array[], int nOld, int nNew, double valNew)
	{
		int i, n, n2;
		double[] arrayNew;
		// Do nothing for null pointers
		if (array == null)
			return null;
		// If array already long enough, just return 
		n = array.length;
		if (n > nNew)
			return array;
		// Create new array (of size nNew + some spare)
		n2 = nNew + 100;
		arrayNew = new double[n2];
		// Copy across old values
		for (i = 0; i < nOld; i++) {
			arrayNew[i] = array[i];
		}
		// Initialise new values
		for (i = nOld; i < nNew; i++) {
			arrayNew[i] = valNew;
		}
		return arrayNew;
	}

	/**
	 * Clone a double array.
	 * @param array: The array to be cloned
	 * @return: The new array
	 */
	public static double[] cloneDoubleArray(double array[])
	{
		int i, n;
		double[] arrayNew;
		// Do nothing for null pointers
		if (array == null)
			return null;
		// Otherwise copy and return
		n = array.length;
		arrayNew = new double[n];
		for (i = 0; i < n; i++) {
			arrayNew[i] = array[i];
		}
		return arrayNew;
	}
}