com.tivoli.twg.libs
Class FloatValueSet

java.lang.Object
  extended bycom.tivoli.twg.libs.FloatValueSet
All Implemented Interfaces:
java.io.Serializable

public class FloatValueSet
extends java.lang.Object
implements java.io.Serializable

Container for a set of float values. This set is optimized for searches and various set operations, including intersection, union, difference, etc. The set is also internally sorted, and allows access to this sorted array. The class also supports optimized bulk insertion of values (which should be used instead of large numbers of single inserts).

See Also:
Serialized Form

Field Summary
static long serialVersionUID
           
 
Constructor Summary
FloatValueSet()
          Construtor for creating an initially empty set.
FloatValueSet(float[] init_values, int start_index, int length)
          Constructor for creating a set initialized with a given range within an array of integers.
FloatValueSet(FloatValueSet init_set)
          Constructor for creating a set initialized by another set
FloatValueSet(int init_size)
          Constructor for creating an empty set with a given initial space allocation.
 
Method Summary
 float[] AccessValues()
          Access internal array containing values in set (read-only)
 boolean contains(FloatValueSet s1)
          Test if all members of a given set are contained in this set.
static FloatValueSet Difference(FloatValueSet s1, FloatValueSet s2)
          Return FloatValueSet equal to difference of set s1 from s2.
static int DifferenceOfArrayFromArray(float[] a1, int a1_start, int a1_len, float[] a2, int a2_start, int a2_len)
          Produce difference of two sorted integer arrays (a1-a2), and save in a1
static float[] DifferenceOfArrays(float[] a1, int a1_len, float[] a2, int a2_len)
          Produce difference of two sorted float arrays (a1-a2)
static float[] DifferenceOfArrays(float[] a1, int a1_start, int a1_len, float[] a2, int a2_start, int a2_len)
          Produce difference of two sorted float arrays (a1-a2)
 boolean DifferenceSet(FloatValueSet s1)
          Subtract given set from set, and save result as new value for set.
static int DropDuplicates(float[] valset, int start, int length)
          Drop duplicate values in a sorted array
 boolean equals(java.lang.Object obj)
          Compare the value of the FloatValueSet with another FloatValueSet
 int Find(float val)
          Return index of given value in set, or -1 if not in set
static int Find(float val, float[] valset, int valset_begin, int valset_len)
          Return index of given value in sorted range of array, or -1 if not in range
 float GetValue(int n)
          Return nth element of set
 float[] GetValues()
          Return array containing copy of all values in set.
 int hashCode()
          Returns a hash code value for the object
 boolean InsertArray(float[] val, int start, int length)
          Insert an array of values into set.
 boolean InsertSet(FloatValueSet insset)
          Insert FloatValueSet into set.
 boolean InsertValue(float val)
          Insert a single value into the set.
static FloatValueSet Intersect(FloatValueSet s1, FloatValueSet s2)
          Return FloatValueSet equal to intersection of set s1 and s2.
static int IntersectArrayIntoArray(float[] a1, int a1_start, int a1_len, float[] a2, int a2_start, int a2_len)
          Intersect two sorted arrays, and store result in first array
static float[] IntersectArrays(float[] a1, int a1_len, float[] a2, int a2_len)
          Produce intersection of two sorted integer arrays.
static float[] IntersectArrays(float[] a1, int a1_start, int a1_len, float[] a2, int a2_start, int a2_len)
          Produce intersection of two sorted integer arrays.
 boolean IntersectSet(FloatValueSet s1)
          Intersect set with given set, and save result as new value for set.
 int Length()
          Return length of set
 boolean RemoveArray(float[] val, int start, int length)
          Remove an array of values from set.
 boolean RemoveValue(float val)
          Remove value from set, if present.
 void reset()
          Empty the contents of the set.
 void setEqual(FloatValueSet s1)
          Set set contents equal to given set
static void Sort(float[] valset, int start, int length)
          Sort a given array of integers, using quicksort
 void sortValues()
          Sort values, if needed.
static boolean TestIfSorted(float[] valset, int start, int length)
          Test if a range in an array is already sorted
static boolean TestIfSortedAndUnique(float[] valset, int start, int length)
          Test if a range in an array is sorted with no duplicates
 java.lang.String toString()
          String representation method (for debug)
static FloatValueSet Union(FloatValueSet s1, FloatValueSet s2)
          Return FloatValueSet equal to union of two FloatValueSets
static float[] UnionArrays(float[] a1, int a1_len, float[] a2, int a2_len)
          Produce union of two sorted integer arrays.
static float[] UnionArrays(float[] a1, int a1_start, int a1_len, float[] a2, int a2_start, int a2_len)
          Produce union of two sorted integer arrays.
 void unsortedInsertValue(float val)
          Unsorted insert : quick way to add value without causing incremental sort.
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 

Field Detail

serialVersionUID

public static final long serialVersionUID
See Also:
Constant Field Values
Constructor Detail

FloatValueSet

public FloatValueSet()
Construtor for creating an initially empty set.


FloatValueSet

public FloatValueSet(int init_size)
Constructor for creating an empty set with a given initial space allocation.

Parameters:
init_size - - initial set space allocation (array size)

FloatValueSet

public FloatValueSet(float[] init_values,
                     int start_index,
                     int length)
Constructor for creating a set initialized with a given range within an array of integers.

Parameters:
init_values - - array containing initial values
start_index - - index of start of values in array
length - - number of values

FloatValueSet

public FloatValueSet(FloatValueSet init_set)
Constructor for creating a set initialized by another set

Parameters:
init_set - - set to use for initialization
Method Detail

InsertValue

public boolean InsertValue(float val)
Insert a single value into the set. Use InsertArray() for inserting multiple values.

Parameters:
val - - value to be inserted
Returns:
true if set modified, false if not changed

unsortedInsertValue

public void unsortedInsertValue(float val)
Unsorted insert : quick way to add value without causing incremental sort. No other method calls should be made (other than additional unsortedInsertValue() calls) until sortValues() is called.

Parameters:
val - - value to be inserted

sortValues

public void sortValues()
Sort values, if needed. Only necessary if values inserted using unsortedInsertValue().


InsertArray

public boolean InsertArray(float[] val,
                           int start,
                           int length)
Insert an array of values into set.

Parameters:
val - - array of values
start - - index of start of range of values
length - - length of range of values to be inserted
Returns:
true if set modified, false if not changed

InsertSet

public boolean InsertSet(FloatValueSet insset)
Insert FloatValueSet into set.

Parameters:
insset - - FloatValueSet to be inserted
Returns:
true if set modified, false if not changed

RemoveValue

public boolean RemoveValue(float val)
Remove value from set, if present. Use RemoveArray() for removing multiple values.

Parameters:
val - - value to be removed
Returns:
true if set modified, false if not changed

RemoveArray

public boolean RemoveArray(float[] val,
                           int start,
                           int length)
Remove an array of values from set.

Parameters:
val - - array of values
start - - index of start of range of values
length - - length of range of values to be removed
Returns:
true if set modified, false if not changed

Union

public static FloatValueSet Union(FloatValueSet s1,
                                  FloatValueSet s2)
Return FloatValueSet equal to union of two FloatValueSets

Parameters:
s1 - - first FloatValueSet
s2 - - second FloatValueSet
Returns:
FloatValueSet equal to union(s1, s2)

IntersectSet

public boolean IntersectSet(FloatValueSet s1)
Intersect set with given set, and save result as new value for set. (this = intersect(this, s1))

Parameters:
s1 - - set to be intersected with
Returns:
true if set modified, false if not changed

Intersect

public static FloatValueSet Intersect(FloatValueSet s1,
                                      FloatValueSet s2)
Return FloatValueSet equal to intersection of set s1 and s2.

Parameters:
s1 - - first FloatValueSet
s2 - - second FloatValueSet
Returns:
FloatValueSet equal to intersect(s1, s2)

DifferenceSet

public boolean DifferenceSet(FloatValueSet s1)
Subtract given set from set, and save result as new value for set. (this = difference(this, s1))

Parameters:
s1 - - set to be subtracted
Returns:
true if set modified, false if not changed

Difference

public static FloatValueSet Difference(FloatValueSet s1,
                                       FloatValueSet s2)
Return FloatValueSet equal to difference of set s1 from s2.

Parameters:
s1 - - first FloatValueSet
s2 - - second FloatValueSet
Returns:
FloatValueSet equal to difference(s1, s2)

Find

public final int Find(float val)
Return index of given value in set, or -1 if not in set

Parameters:
val - - value to be found in set

Find

public static final int Find(float val,
                             float[] valset,
                             int valset_begin,
                             int valset_len)
Return index of given value in sorted range of array, or -1 if not in range

Parameters:
val - - value to be found in set
valset - - array containing sorted values to be searched
valset_begin - - beginning of range in valset
valset_len - - length of range in valset

Length

public final int Length()
Return length of set

Returns:
number of elements in set

GetValue

public final float GetValue(int n)
                     throws java.lang.ArrayIndexOutOfBoundsException
Return nth element of set

Parameters:
n - - index (base 0) of element to be returned
Throws:
java.lang.ArrayIndexOutOfBoundsException - if invalid index

GetValues

public final float[] GetValues()
Return array containing copy of all values in set.

Returns:
allocated array containing all values in set

AccessValues

public final float[] AccessValues()
Access internal array containing values in set (read-only)

Returns:
reference to internal array for set (may be longer than actual amount of data : use Length() to find actual length

Sort

public static final void Sort(float[] valset,
                              int start,
                              int length)
Sort a given array of integers, using quicksort

Parameters:
valset - - Array to be sorted
start - - index of start of data to be sorted
length - - length of data to be sorted

TestIfSorted

public static final boolean TestIfSorted(float[] valset,
                                         int start,
                                         int length)
Test if a range in an array is already sorted

Parameters:
valset - - array containing values
start - - start of range to test
length - - length of range to test
Returns:
true if already sorted, false if not

TestIfSortedAndUnique

public static final boolean TestIfSortedAndUnique(float[] valset,
                                                  int start,
                                                  int length)
Test if a range in an array is sorted with no duplicates

Parameters:
valset - - array containing values
start - - start of range to test
length - - length of range to test
Returns:
true if sorted and contains no duplicates, false if not

UnionArrays

public static final float[] UnionArrays(float[] a1,
                                        int a1_len,
                                        float[] a2,
                                        int a2_len)
Produce union of two sorted integer arrays.

Parameters:
a1 - - first sorted array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_len - - length of valid elements in second array
Returns:
array containing union of two arrays

UnionArrays

public static final float[] UnionArrays(float[] a1,
                                        int a1_start,
                                        int a1_len,
                                        float[] a2,
                                        int a2_start,
                                        int a2_len)
Produce union of two sorted integer arrays.

Parameters:
a1 - - first sorted array
a1_start - - index of start of sorted array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_start - - index of start of sorted array
a2_len - - length of valid elements in second array
Returns:
array containing union of two arrays

IntersectArrays

public static final float[] IntersectArrays(float[] a1,
                                            int a1_len,
                                            float[] a2,
                                            int a2_len)
Produce intersection of two sorted integer arrays.

Parameters:
a1 - - first sorted array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_len - - length of valid elements in second array
Returns:
array containing intersection of two arrays

IntersectArrays

public static final float[] IntersectArrays(float[] a1,
                                            int a1_start,
                                            int a1_len,
                                            float[] a2,
                                            int a2_start,
                                            int a2_len)
Produce intersection of two sorted integer arrays.

Parameters:
a1 - - first sorted array
a1_start - - index of start of first sorted array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_len - - length of valid elements in second array
Returns:
array containing intersection of two arrays

IntersectArrayIntoArray

public static final int IntersectArrayIntoArray(float[] a1,
                                                int a1_start,
                                                int a1_len,
                                                float[] a2,
                                                int a2_start,
                                                int a2_len)
Intersect two sorted arrays, and store result in first array

Parameters:
a1 - - first sorted array
a1_start - - index of start of sorted data
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_start - - index of start of sorted data
a2_len - - length of valid elements in second array
Returns:
number of valid elements in intersection in a1

DifferenceOfArrays

public static final float[] DifferenceOfArrays(float[] a1,
                                               int a1_len,
                                               float[] a2,
                                               int a2_len)
Produce difference of two sorted float arrays (a1-a2)

Parameters:
a1 - - first sorted array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_len - - length of valid elements in second array
Returns:
array containing difference of two arrays

DifferenceOfArrays

public static final float[] DifferenceOfArrays(float[] a1,
                                               int a1_start,
                                               int a1_len,
                                               float[] a2,
                                               int a2_start,
                                               int a2_len)
Produce difference of two sorted float arrays (a1-a2)

Parameters:
a1 - - first sorted array
a1_start - - start of valid elements in first array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_start - - start of valid elements in second array
a2_len - - length of valid elements in second array
Returns:
array containing difference of two arrays

DifferenceOfArrayFromArray

public static final int DifferenceOfArrayFromArray(float[] a1,
                                                   int a1_start,
                                                   int a1_len,
                                                   float[] a2,
                                                   int a2_start,
                                                   int a2_len)
Produce difference of two sorted integer arrays (a1-a2), and save in a1

Parameters:
a1 - - first sorted array
a1_start - - start of valid elements in first array
a1_len - - length of valid elements in first array
a2 - - second sorted array
a2_start - - start of valid elements in second array
a2_len - - length of valid elements in second array
Returns:
number of valid elements in a1

DropDuplicates

public static final int DropDuplicates(float[] valset,
                                       int start,
                                       int length)
Drop duplicate values in a sorted array

Parameters:
valset - - array containing sorted values
start - - index of start of sorted values
length - - length of range of sorted values
Returns:
length of range of sorted values without duplicates

hashCode

public int hashCode()
Returns a hash code value for the object

Returns:
hash code value for this object

equals

public boolean equals(java.lang.Object obj)
Compare the value of the FloatValueSet with another FloatValueSet

Parameters:
obj - - object to be compared with
Returns:
true if sets are equal, false if not

contains

public boolean contains(FloatValueSet s1)
Test if all members of a given set are contained in this set.

Parameters:
s1 - - set to be checked
Returns:
true if this set contains all members of s1

reset

public void reset()
Empty the contents of the set.


setEqual

public void setEqual(FloatValueSet s1)
Set set contents equal to given set

Parameters:
s1 - - set to be copied

toString

public java.lang.String toString()
String representation method (for debug)

Returns:
string representation