Jump to content

  • Log In with Google      Sign In   
  • Create Account

Hat container class


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
No replies to this topic

#1 AngleWyrm   Members   -  Reputation: 554

Like
0Likes
Like

Posted 18 March 2013 - 04:14 PM

What is this Hat container?

 

The hat container gets it's name from the act of pulling names from a hat. It is a container that returns items randomly, based on probability weights. The items can be either come up again like rolling dice, or be drawn only once, like drawing cards from a deck. Probability weights can be assigned (and altered) for each item in the container. And the container's contents can be altered on the fly without affecting performance.

 

Basic uses of the hat

package examples;
import hat.Hat;

public class BasicUses 
{
  public static void run()
  {
    System.out.println("--|Basic Usage|--------------------------------------------------------------");
    System.out.println("Some simple uses of the hat container");
    
    // put some data into a hat and then get a random item
    String[] names = {"Alice", "Betty", "Celia", "Darcy"};
    Hat<String> hatOfNames = new Hat<String>(names);
    for(int i = 0; i < 10; ++i){
      System.out.print( hatOfNames.get() + " " ); // get a random item from hat
    }
    System.out.println();
    
    // assign different chance weights to items in a hat
    Hat<String> weightedNames = new Hat<String>();
    weightedNames.put("Alice", 5); // 5 chances out of the sum of all chances in the hat
    weightedNames.put("Betty", 3); // 3 chances
    weightedNames.put("Celia", 1); // 1 chance
    weightedNames.put("Darcy");    // default behavior of 1 chance
    for(int i = 0; i < 10; ++i){
      System.out.print( weightedNames.get() + " " ); // draw a name
    }
    System.out.println();
    
    // draw names randomly from a pre-existing data set
    Hat<Integer> index = new Hat<Integer>();
    Integer[] chanceWeights = {50, 30, 10, 10}; // using 100 chances to simulate percentages
    for(int i = 0; i < 4; ++i){
      index.put(i, chanceWeights[i]); // assigning chance weights when inserting items in hat
    }
    for(int i = 0; i < 10; ++i){
      System.out.print( names[index.get()] + " " ); // draw a name using a random index
    }    
  }

} 

 

More uses can be seen on the github at https://github.com/AngleWyrm/Hat/tree/master/src/examples

 

Hat container source

package hat;
import java.util.Random;
import java.util.Vector;

public class Hat<T>
{
// Public Interface -------------------------------------------------------

public Hat(){
rng = new Random();
tree = new Vector<Node>();
}
public Hat(T[] _inputArray){
rng = new Random();
tree = new Vector<Node>();

for(T item : _inputArray){
tree.add(new Node(item));
update_weights(tree.size()-1);
}
}

public int size(){
return tree.size();
}

public void put(T in){
put(in, 1);
}
public void put(T in, int chances){
Node newNode = new Node(in, chances);
tree.add(newNode);
update_weights(tree.size()-1);
}
public T get(){
// roll a random point on the sum of all chance weights [0,family_weight)
int target = rng.nextInt(tree.elementAt(0).family_weight);

// find the matching index in the tree
int index = find_index(0, target);
return tree.elementAt(index).item;
}

public T pull()
{
// get random item
int random_weight = rng.nextInt(tree.elementAt(0).family_weight);
int index = find_index( 0, random_weight );

T buffer = tree.elementAt(index).item;
erase(index);
return buffer;
};	

public void print(int index)
{
System.out.println("\r" + tree.elementAt(index).item
+ "(" + tree.elementAt(index).chance_weight
+ "/" + tree.elementAt(index).family_weight + ")");

if(2*index+1 < tree.size()){ // has son
System.out.println("\tson[" + (2*index+1) + "]:" + tree.elementAt(2*index+1).item);
}
if(2*(index+1) < tree.size()) { // also has daughter
System.out.println("\tdaughter[" + (2*(index+1)) + "]:" + tree.elementAt(2*(index+1)).item);
}
};

public boolean isEmpty(){
return tree.isEmpty();
}

// Erase a given index [0,tree.size) by over-writing with last item
public void erase(int index)
{
// quick clear if removing only entry in tree
if(tree.size() <= 1){
tree.clear();
return;
}

// Copy last item into current item
tree.elementAt(index).copy(tree.elementAt(tree.size()-1));
update_weights(index);

tree.removeElementAt(tree.size()-1);

// update replacement node's old parents
if( (tree.size() % 2) >= 0 ) { // then odd number, old size was even (female node)
update_weights( (tree.size()-1)/2 ); // update old parent of female
}
else { // was a male node
update_weights( tree.size()/2 - 1 ); // update old parent of male
}
}


// Internal functions -----------------------------------------------------

private int find_index( int index, int target ){
// divide weight into three groups: Self, Son & Daughter, and test each

// Testing self
int sum = tree.elementAt(index).chance_weight;
if( target < sum )
{
return index; // found within self
} // else outside self, must be in children

// Testing son (first-born is always a son)
sum += tree.elementAt( 2*index+1 ).family_weight;
if( target < sum )
{
return find_index( 2*index+1, target - tree.elementAt(index).chance_weight );
} // else not in son's range

// Testing daughter
sum += tree.elementAt( 2*(index+1) ).family_weight;
if( target < sum )
{
return find_index( 2*(index+1),
target - tree.elementAt(index).chance_weight - tree.elementAt( 2*index+1 ).family_weight );
}

// possible to reach here if a custom random number generator is used,
// and it fails to deliver a number in the correct range
return 0;
};

private void update_weights(int index){
// update the weight of the currently indexed node
tree.elementAt(index).family_weight = tree.elementAt(index).chance_weight;

// First, update self with children's weights
// daughters are found at 2(x+1)
if( 2*(index+1) < tree.size() )
{ // add daughter's weight to family
tree.elementAt(index).family_weight += tree.elementAt(2*(index+1)).family_weight;
} // else no daughter

// sons are found at 2x+1
if( 2*index+1 < tree.size() )
{ // add son
tree.elementAt(index).family_weight += tree.elementAt( 2*index+1 ).family_weight;
} // else no son

// Second, update parents with self
// check for parents, and update them
if( index > 0 ) // not the root mother (has parent)
{
// calculate distance to parent
if( (index % 2)>=0 ) { // is a male node
update_weights( (index-1)/2 ); // update parent
}
else { // is a female node
update_weights( index/2 - 1 ); // update parent
}
} // else this is the root mother (no parents)

}


// Variables --------------------------------------------------------------

class Node{
T item;
int chance_weight;
int family_weight;

Node(T in){
item = in;
chance_weight = family_weight = 1;
}
Node(T in, int chances){
item = in;
chance_weight = family_weight = chances;
}

public void copy (Node other){
item = other.item;
chance_weight = other.chance_weight;
family_weight = other.family_weight;
}
}	
Vector<Node> tree;
Random rng;
}

 

pretty cool, huh?


Edited by AngleWyrm, 19 March 2013 - 09:49 PM.

--"I'm not at home right now, but" = lights on, but no ones home

Sponsor:



Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS