processing.data

## Class FloatDict

- java.lang.Object
- - processing.data.FloatDict

-     public class FloatDict
      extends Object

  A simple table class to use a String as a lookup for an float value.
  See Also:
    `IntDict`, `StringDict`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `FloatDict()`
    `FloatDict(BufferedReader reader)` Read a set of entries from a Reader that has each key/value pair on a single line, separated by a tab.
    `FloatDict(int length)` Create a new lookup with a specific size.
    `FloatDict(Object[][] pairs)` Constructor to allow (more intuitive) inline initialization, e.g.:
    `FloatDict(String[] keys, float[] values)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(String key, float amount)`
    `void` | `clear()` Remove all entries.
    `FloatDict` | `copy()` Returns a duplicate copy of this object.
    `void` | `div(String key, float amount)`
    `float` | `get(String key)` Return a value for the specified key.
    `float` | `get(String key, float alternate)`
    `FloatDict` | `getPercent()` Sum all of the values in this dictionary, then return a new FloatDict of each key, divided by the total sum.
    `boolean` | `hasKey(String key)`
    `int` | `index(String what)`
    `String` | `key(int index)`
    `String[]` | `keyArray()` Return a copy of the internal keys array.
    `String[]` | `keyArray(String[] outgoing)`
    `Iterable<String>` | `keys()`
    `int` | `maxIndex()`
    `String` | `maxKey()` The key for a max value, or null if everything is NaN (no max).
    `float` | `maxValue()` The max value.
    `int` | `minIndex()`
    `String` | `minKey()`
    `float` | `minValue()`
    `void` | `mult(String key, float amount)`
    `void` | `print()`
    `int` | `remove(String key)`
    `String` | `removeIndex(int index)`
    `void` | `set(String key, float amount)`
    `int` | `size()`
    `void` | `sortKeys()` Sort the keys alphabetically (ignoring case).
    `void` | `sortKeysReverse()`
    `void` | `sortValues()` Sort by values in descending order (largest value will be at [0]).
    `void` | `sortValuesReverse()`
    `void` | `sub(String key, float amount)`
    `void` | `swap(int a, int b)`
    `String` | `toString()`
    `float` | `value(int index)`
    `float[]` | `valueArray()` Create a new array and copy each of the values into it.
    `float[]` | `valueArray(float[] array)` Fill an already-allocated array with the values (more efficient than creating a new array each time).
    `Iterable<Float>` | `values()`
    `void` | `write(PrintWriter writer)` Write tab-delimited entries out to

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### FloatDict

          public FloatDict()

    - #### FloatDict

          public FloatDict(int length)

      Create a new lookup with a specific size. This is more efficient than not specifying a size. Use it when you know the rough size of the thing you're creating.

    - #### FloatDict

          public FloatDict(BufferedReader reader)

      Read a set of entries from a Reader that has each key/value pair on a single line, separated by a tab.

    - #### FloatDict

          public FloatDict(Object[][] pairs)

      Constructor to allow (more intuitive) inline initialization, e.g.:

           new FloatDict(new Object[][] {
             { "key1", 1 },
             { "key2", 2 }
           });

    - #### FloatDict

          public FloatDict(String[] keys,
                           float[] values)

  - ### Method Detail

    - #### size

          public int size()

    - #### clear

          public void clear()

      Remove all entries.

    - #### key

          public String key(int index)

    - #### keys

          public Iterable<String> keys()

    - #### keyArray

          public String[] keyArray()

      Return a copy of the internal keys array. This array can be modified.

    - #### keyArray

          public String[] keyArray(String[] outgoing)

    - #### value

          public float value(int index)

    - #### values

          public Iterable<Float> values()

    - #### valueArray

          public float[] valueArray()

      Create a new array and copy each of the values into it.

    - #### valueArray

          public float[] valueArray(float[] array)

      Fill an already-allocated array with the values (more efficient than creating a new array each time). If 'array' is null, or not the same size as the number of values, a new array will be allocated and returned.

    - #### get

          public float get(String key)

      Return a value for the specified key.

    - #### get

          public float get(String key,
                           float alternate)

    - #### set

          public void set(String key,
                          float amount)

    - #### hasKey

          public boolean hasKey(String key)

    - #### add

          public void add(String key,
                          float amount)

    - #### sub

          public void sub(String key,
                          float amount)

    - #### mult

          public void mult(String key,
                           float amount)

    - #### div

          public void div(String key,
                          float amount)

    - #### minIndex

          public int minIndex()

    - #### minKey

          public String minKey()

    - #### minValue

          public float minValue()

    - #### maxIndex

          public int maxIndex()

    - #### maxKey

          public String maxKey()

      The key for a max value, or null if everything is NaN (no max).

    - #### maxValue

          public float maxValue()

      The max value. (Or NaN if they're all NaN.)

    - #### index

          public int index(String what)

    - #### remove

          public int remove(String key)

    - #### removeIndex

          public String removeIndex(int index)

    - #### swap

          public void swap(int a,
                           int b)

    - #### sortKeys

          public void sortKeys()

      Sort the keys alphabetically (ignoring case). Uses the value as a tie-breaker (only really possible with a key that has a case change).

    - #### sortKeysReverse

          public void sortKeysReverse()

    - #### sortValues

          public void sortValues()

      Sort by values in descending order (largest value will be at [0]).

    - #### sortValuesReverse

          public void sortValuesReverse()

    - #### getPercent

          public FloatDict getPercent()

      Sum all of the values in this dictionary, then return a new FloatDict of each key, divided by the total sum. The total for all values will be ~1.0.
      Returns:
        a Dict with the original keys, mapped to their pct of the total

    - #### copy

          public FloatDict copy()

      Returns a duplicate copy of this object.

    - #### print

          public void print()

    - #### write

          public void write(PrintWriter writer)

      Write tab-delimited entries out to
      Parameters:
        `writer` -

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`