//==============================================================================
//	
//	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;
	}

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

	/**
	 * Copy a double array.
	 * @param array The array to be cloned
	 * @param copy The destination array (should exist and be same size)
	 */
	public static void copyDoubleArray(double array[], double copyTo[])
	{
		int i, n;
		// Do nothing for null pointers
		if (array == null)
			return;
		// Otherwise copy
		n = array.length;
		for (i = 0; i < n; i++) {
			copyTo[i] = array[i];
		}
	}

	/**
	 * Copy an integer array.
	 * @param array The array to be cloned
	 * @param copy The destination array (should exist and be same size)
	 */
	public static void copyIntArray(int array[], int copyTo[])
	{
		int i, n;
		// Do nothing for null pointers
		if (array == null)
			return;
		// Otherwise copy
		n = array.length;
		for (i = 0; i < n; i++) {
			copyTo[i] = array[i];
		}
	}

	/**
	 * Test if two double arrays are equal.
	 */
	public static boolean doubleArraysAreEqual(double array1[], double array2[])
	{
		int i, n;
		if (array1 == null)
			return (array2 == null);
		n = array1.length;
		if (n != array2.length)
			return false;
		for (i = 0; i < n; i++) {
			if (array1[i] != array2[i])
				return false;
			;
		}
		return true;
	}

	/**
	 * Test if two int arrays are equal.
	 */
	public static boolean intArraysAreEqual(int array1[], int array2[])
	{
		int i, n;
		if (array1 == null)
			return (array2 == null);
		n = array1.length;
		if (n != array2.length)
			return false;
		for (i = 0; i < n; i++) {
			if (array1[i] != array2[i])
				return false;
		}
		return true;
	}

	/**
	 * Returns true if int array 'array' contains value 'val'.
	 */
	public static boolean intArrayContains(int val, int[] array)
	{
		for (int i = 0; i < array.length; i++)
			if (val == array[i])
				return true;
		return false;
	}
}