SimplexTable

java.lang.Object
- edu.stanford.math.plex.SimplexTable

All Implemented Interfaces:

java.lang.Iterable<Simplex>
```
public class SimplexTable
extends java.lang.Object
implements java.lang.Iterable<Simplex>
```
A SimplexTable is an interning table for instances of Simplex. That is, the simplices in the table are both key and value. There is no removal operation, and putting a simplex equivalent to one already in the table throws an IllegalArgumentException. The largest table we can make will hold around 976M simplices. Attempting to add a simplex to table that is full throwns an IllegalStateException.

Version:

$Id$

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class SimplexTable.SimpleTableIterator
Instances provide Iterator for non-destructive iterating over entries.

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`SimplexTable.SimpleTableIterator` Instances provide Iterator for non-destructive iterating over entries.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`entry_limit`
`protected static double`	`LOAD_FACTOR`
`protected int`	`mask`
`protected int`	`MAX_ENTRY_LIMIT`
`protected int`	`MAX_TABLE_SIZE`
`protected int`	`size`
`protected Simplex[]`	`table`

Constructor Summary

Constructors
Modifier Constructor and Description

protected SimplexTable()

SimplexTable(int limit)
Make a new SimplexTable.

Constructors
Modifier	Constructor and Description
`protected`	`SimplexTable()`
	`SimplexTable(int limit)` Make a new SimplexTable.

Method Summary

Methods
Modifier and Type	Method and Description
`Simplex`	`get(Simplex s)` Get the interned version of the Simplex s.
`Simplex`	`getInterned(Simplex s)` Return the interned version of a Simplex.
`protected void`	`grow_table(int newLimit)`
`java.util.Iterator<Simplex>`	`iterator()` Make an iterator for the table.
`int`	`limit()` The number of simplices that can be interned before growing the table.
`Simplex`	`put(Simplex s)` Intern a Simplex.
`int`	`size()` The number of simplices that have been interned.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - size
```
protected int size
```
  - entry_limit
```
protected int entry_limit
```
  - mask
```
protected int mask
```
  - table
```
protected Simplex[] table
```
  - LOAD_FACTOR
```
protected static final double LOAD_FACTOR
```
    See Also:
    Constant Field Values
  - MAX_TABLE_SIZE
```
protected int MAX_TABLE_SIZE
```
  - MAX_ENTRY_LIMIT
```
protected int MAX_ENTRY_LIMIT
```
- Constructor Detail
  - SimplexTable
```
protected SimplexTable()
```
  - SimplexTable
```
public SimplexTable(int limit)
```
    Make a new SimplexTable.
    You must make sure that limit is as large as the number of simplices you will be storing in the table, as the table will NOT grow, and attempting to add simplices past the limit throws an exception which isn't caught in the Persistence algorithm.
    
    Parameters:
    limit - An upper bound on the number of simplices that will be interned in the table -- must be less than or equal to MAX_ENTRY_LIMIT (which is about 976M).
    
    Throws:
    
    java.lang.IllegalArgumentException
    See Also:
    System.getProperty(java.lang.String), SecurityManager.checkPermission(java.security.Permission)
- Method Detail
  - grow_table
```
protected void grow_table(int newLimit)
```
  - size
```
public int size()
```
    The number of simplices that have been interned.
    
    Returns:
    the number of simplices put in the table.
  - limit
```
public int limit()
```
    The number of simplices that can be interned before growing the table.
    
    Returns:
    the number of simplices that can be put in the table before growing it.
  - get
```
public Simplex get(Simplex s)
```
    Get the interned version of the Simplex s.
    Because the CRC hashing -- which we use for simplices -- is good, we just mask the hash code for our initial index. We keep the table sufficiently empty that we don't get a lot of false hits, so we reprobe with increment 1 to improve locality of reference in these (potentially) very large tables.
    
    Parameters:
    s - The simplex for which we want an interned version.
    
    Returns:
    An interned version of s, or null if there is none.
  - put
```
public Simplex put(Simplex s)
```
    Intern a Simplex.
    Intern s in the table. When used by the Persistence algorithm, s should be a Simplex from the SimplexStream, which means that it will the filtration index set. An attempt to intern the same simplex twice throws an exception.
    
    Parameters:
    s - the Simplex to intern
    
    Returns:
    the interned Simplex.
    
    Throws:
    
    java.lang.IllegalStateException - when attempting to grow too big.
    
    java.lang.IllegalArgumentException - when attempting to put a Simplex twice.
  - getInterned
```
public Simplex getInterned(Simplex s)
```
    Return the interned version of a Simplex.
    Like put(), except no error if something is already in the table.
    
    Parameters:
    s - the Simplex key
    
    Returns:
    the interned Simplex.
    
    Throws:
    
    java.lang.IllegalStateException - when attempting to grow too big.
  - iterator
```
public java.util.Iterator<Simplex> iterator()
```
    Make an iterator for the table.
    
    Specified by:
    
    iterator in interface java.lang.Iterable<Simplex>
    
    Returns:
    Iterator instance for the table.
    See Also:
    Iterator

Class SimplexTable

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

size

entry_limit

mask

table

LOAD_FACTOR

MAX_TABLE_SIZE

MAX_ENTRY_LIMIT

Constructor Detail

SimplexTable

SimplexTable

Method Detail

grow_table

size

limit

get

put

getInterned

iterator