This is so useful we'll bump it up to samskivert.
git-svn-id: https://samskivert.googlecode.com/svn/trunk@1854 6335cc39-0255-0410-8fd6-9bcaacd3b74c
This commit is contained in:
mdb
@@ -0,0 +1,298 @@
|
||||
//
|
||||
// $Id$
|
||||
//
|
||||
// samskivert library - useful routines for java programs
|
||||
// Copyright (C) 2001-2006 Michael Bayne
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or modify it
|
||||
// under the terms of the GNU Lesser General Public License as published
|
||||
// by the Free Software Foundation; either version 2.1 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This library 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
|
||||
// Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public
|
||||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
package com.samskivert.util;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
|
||||
import com.samskivert.Log;
|
||||
|
||||
/**
|
||||
* Provides miscellaneous utility routines to simplify obtaining useful random
|
||||
* number values and to centralize seeding and proper care and feeding of the
|
||||
* pseudo-random number generator.
|
||||
*/
|
||||
public class RandomUtil
|
||||
{
|
||||
/** The random number generator used by the methods in this class. */
|
||||
public static final Random rand = new Random();
|
||||
|
||||
/**
|
||||
* Returns a pseudorandom, uniformly distributed <code>int</code>
|
||||
* value between 0 (inclusive) and the specified value (exclusive).
|
||||
*
|
||||
* @param high the high value limiting the random number sought.
|
||||
*/
|
||||
public static int getInt (int high)
|
||||
{
|
||||
return rand.nextInt(high);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a pseudorandom, uniformly distributed <code>int</code>
|
||||
* value between <code>high</code> and <code>low</code>, exclusive of each.
|
||||
*/
|
||||
public static int getInt (int high, int low)
|
||||
{
|
||||
if (high - low - 1 <= 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Invalid range [high=" + high + ", low=" + low + "]");
|
||||
}
|
||||
return low + 1 + rand.nextInt(high - low - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a pseudorandom, uniformly distributed float value between
|
||||
* 0.0 (inclusive) and the specified value (exclusive).
|
||||
*
|
||||
* @param high the high value limiting the random number sought.
|
||||
*/
|
||||
public static float getFloat (float high)
|
||||
{
|
||||
return rand.nextFloat() * high;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pick a random index from the array, weighted by the value of the
|
||||
* corresponding array element.
|
||||
*
|
||||
* @param weights an array of non-negative integers.
|
||||
* @return an index into the array, or -1 if the sum of the weights
|
||||
* is less than 1.
|
||||
*
|
||||
* For example, passing in {1, 0, 3, 4} will return
|
||||
* <table><tr><td>0</td><td>1/8th of the time</td></tr>
|
||||
* <tr><td>1</td><td>never</td></tr>
|
||||
* <tr><td>2</td><td>3/8th of the time</td></tr>
|
||||
* <tr><td>3</td><td>half of the time</td></tr></table>
|
||||
*/
|
||||
public static int getWeightedIndex (int[] weights)
|
||||
{
|
||||
int sum = IntListUtil.sum(weights);
|
||||
if (sum < 1) {
|
||||
return -1;
|
||||
}
|
||||
int pick = getInt(sum);
|
||||
for (int ii=0, nn=weights.length; ii < nn; ii++) {
|
||||
pick -= weights[ii];
|
||||
if (pick < 0) {
|
||||
return ii;
|
||||
}
|
||||
}
|
||||
|
||||
// Impossible!
|
||||
Log.logStackTrace(new Throwable());
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pick a random index from the array, weighted by the value of the
|
||||
* corresponding array element.
|
||||
*
|
||||
* @param weights an array of non-negative floats.
|
||||
* @return an index into the array, or -1 if the sum of the weights
|
||||
* is less than or equal to 0.0 or any individual element is negative.
|
||||
*
|
||||
* For example, passing in {0.2, 0.0, 0.6, 0.8} will return
|
||||
* <table><tr><td>0</td><td>1/8th of the time</td></tr>
|
||||
* <tr><td>1</td><td>never</td></tr>
|
||||
* <tr><td>2</td><td>3/8th of the time</td></tr>
|
||||
* <tr><td>3</td><td>half of the time</td></tr></table>
|
||||
*/
|
||||
public static int getWeightedIndex (float[] weights)
|
||||
{
|
||||
float sum = 0.0f;
|
||||
for (int ii = 0; ii < weights.length; ii++) {
|
||||
if (weights[ii] < 0.0f) {
|
||||
return -1;
|
||||
}
|
||||
sum += weights[ii];
|
||||
}
|
||||
|
||||
if (sum <= 0.0) {
|
||||
return -1;
|
||||
}
|
||||
float pick = getFloat(sum);
|
||||
for (int ii=0, nn=weights.length; ii < nn; ii++) {
|
||||
pick -= weights[ii];
|
||||
if (pick < 0.0) {
|
||||
return ii;
|
||||
}
|
||||
}
|
||||
|
||||
// Impossible!
|
||||
Log.logStackTrace(new Throwable());
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied array of values. Even
|
||||
* weight is given to all elements of the array.
|
||||
*
|
||||
* @return a randomly selected item or null if the array is null or of
|
||||
* length zero.
|
||||
*/
|
||||
public static <T> T pickRandom (T[] values)
|
||||
{
|
||||
return (values == null || values.length == 0) ? null :
|
||||
values[getInt(values.length)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied array of values, not
|
||||
* including the specified skip object as a possible selection
|
||||
* (equality with the skipped object is referential rather than via
|
||||
* {@link Object#equals}). The element to be skipped must exist in the
|
||||
* array exactly once. Even weight is given to all elements of the
|
||||
* array except the skipped element.
|
||||
*
|
||||
* @return a randomly selected item or null if the array is null, of
|
||||
* length zero or contains only the skip item.
|
||||
*/
|
||||
public static <T> T pickRandom (T[] values, T skip)
|
||||
{
|
||||
if (values == null || values.length < 2) {
|
||||
return null;
|
||||
}
|
||||
int index = getInt(values.length-1);
|
||||
for (int ii = 0; ii <= index; ii++) {
|
||||
if (values[ii] == skip) {
|
||||
index++;
|
||||
}
|
||||
}
|
||||
return (index >= values.length) ? null : values[index];
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied {@link Collection}.
|
||||
*/
|
||||
public static <T> T pickRandom (Collection<T> values)
|
||||
{
|
||||
return pickRandom(values.iterator(), values.size());
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied List
|
||||
*
|
||||
* @return a randomly selected item.
|
||||
*/
|
||||
public static <T> T pickRandom (List<T> values)
|
||||
{
|
||||
int size = values.size();
|
||||
if (size == 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Must have at least one element [size=" + size + "]");
|
||||
}
|
||||
return values.get(getInt(size));
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied List. The specified skip
|
||||
* object will be skipped when selecting a random value. The skipped
|
||||
* object must exist exactly once in the List.
|
||||
*
|
||||
* @return a randomly selected item.
|
||||
*/
|
||||
public static <T> T pickRandom (List<T> values, T skip)
|
||||
{
|
||||
return pickRandom(values, skip, rand);
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied List. The specified skip
|
||||
* object will be skipped when selecting a random value. The skipped
|
||||
* object must exist exactly once in the List.
|
||||
*
|
||||
* @return a randomly selected item.
|
||||
*/
|
||||
public static <T> T pickRandom (List<T> values, T skip, Random r)
|
||||
{
|
||||
int size = values.size();
|
||||
if (size < 2) {
|
||||
throw new IllegalArgumentException(
|
||||
"Must have at least two elements [size=" + size + "]");
|
||||
}
|
||||
|
||||
int pick = r.nextInt(size - 1);
|
||||
for (int ii = 0; ii < size; ii++) {
|
||||
T val = values.get(ii);
|
||||
if ((val != skip) && (pick-- == 0)) {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied iterator (which must
|
||||
* iterate over exactly <code>count</code> objects.
|
||||
*
|
||||
* @return a randomly selected item.
|
||||
*
|
||||
* @exception NoSuchElementException thrown if the iterator provides
|
||||
* fewer than <code>count</code> elements.
|
||||
*/
|
||||
public static <T> T pickRandom (Iterator<T> iter, int count)
|
||||
{
|
||||
if (count < 1) {
|
||||
throw new IllegalArgumentException(
|
||||
"Must have at least one element [count=" + count + "]");
|
||||
}
|
||||
|
||||
T value = iter.next();
|
||||
for (int ii = 0, ll = getInt(count); ii < ll; ii++) {
|
||||
value = iter.next();
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Picks a random object from the supplied iterator (which must
|
||||
* iterate over exactly <code>count</code> objects. The specified skip
|
||||
* object will be skipped when selecting a random value. The skipped
|
||||
* object must exist exactly once in the set of objects returned by
|
||||
* the iterator.
|
||||
*
|
||||
* @return a randomly selected item.
|
||||
*
|
||||
* @exception NoSuchElementException thrown if the iterator provides
|
||||
* fewer than <code>count</code> elements.
|
||||
*/
|
||||
public static <T> T pickRandom (Iterator<T> iter, int count, T skip)
|
||||
{
|
||||
if (count < 2) {
|
||||
throw new IllegalArgumentException(
|
||||
"Must have at least two elements [count=" + count + "]");
|
||||
}
|
||||
|
||||
int index = getInt(count-1);
|
||||
T value = null;
|
||||
do {
|
||||
value = iter.next();
|
||||
if (value == skip) {
|
||||
value = iter.next();
|
||||
}
|
||||
} while (index-- > 0);
|
||||
return value;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user