Uses of Interface
it.unimi.dsi.fastutil.floats.FloatComparator

Packages that use FloatComparator
it.unimi.dsi.fastutil.floats Provides type-specific classes for float elements or keys. 
 

Uses of FloatComparator in it.unimi.dsi.fastutil.floats
 

Classes in it.unimi.dsi.fastutil.floats that implement FloatComparator
 class AbstractFloatComparator
          An abstract class facilitating the creation of type-specific comparators.
 

Fields in it.unimi.dsi.fastutil.floats declared as FloatComparator
protected  FloatComparator Float2LongAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2LongAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2IntAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2IntAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2BooleanRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2BooleanRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ShortRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ShortRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2BooleanAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2BooleanAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2DoubleAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2DoubleAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ShortAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ShortAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ByteRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ByteRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2CharAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2CharAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ObjectRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ObjectRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2DoubleRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2DoubleRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator FloatRBTreeSet.actualComparator
          This set's actual comparator; it may differ from FloatRBTreeSet.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ByteAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ByteAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2CharRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2CharRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2FloatAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2FloatAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator FloatAVLTreeSet.actualComparator
          This set's actual comparator; it may differ from FloatAVLTreeSet.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ReferenceRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ReferenceRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ReferenceAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ReferenceAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2IntRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2IntRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2FloatRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2FloatRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2ObjectAVLTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2ObjectAVLTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator Float2LongRBTreeMap.actualComparator
          This map's actual comparator; it may differ from Float2LongRBTreeMap.storedComparator because it is always a type-specific comparator, so it could be derived from the former by wrapping.
protected  FloatComparator FloatArrayIndirectPriorityQueue.c
          The type-specific comparator used in this queue.
protected  FloatComparator FloatArrayPriorityQueue.c
          The type-specific comparator used in this queue.
protected  FloatComparator FloatHeapPriorityQueue.c
          The type-specific comparator used in this queue.
protected  FloatComparator FloatHeapSemiIndirectPriorityQueue.c
          The type-specific comparator used in this queue.
protected  FloatComparator Float2LongSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2ShortSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2ObjectSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2IntSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2CharSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2BooleanSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2ReferenceSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2DoubleSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2ByteSortedMaps.Singleton.comparator
           
protected  FloatComparator Float2FloatSortedMaps.Singleton.comparator
           
static FloatComparator FloatComparators.NATURAL_COMPARATOR
          A type-specific comparator mimicking the natural order.
static FloatComparator FloatComparators.OPPOSITE_COMPARATOR
          A type-specific comparator mimicking the opposite of the natural order.
 

Methods in it.unimi.dsi.fastutil.floats that return FloatComparator
 FloatComparator Float2ByteSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2LongSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2LongSortedMaps.Singleton.comparator()
           
 FloatComparator Float2LongSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2LongSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2LongLinkedOpenHashMap.comparator()
           
 FloatComparator AbstractFloat2DoubleSortedMap.KeySet.comparator()
           
 FloatComparator Float2ObjectSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator FloatPriorityQueues.SynchronizedPriorityQueue.comparator()
           
 FloatComparator FloatSortedSets.EmptySet.comparator()
           
 FloatComparator FloatSortedSets.Singleton.comparator()
           
 FloatComparator FloatSortedSets.SynchronizedSortedSet.comparator()
           
 FloatComparator FloatSortedSets.UnmodifiableSortedSet.comparator()
           
 FloatComparator AbstractFloat2LongSortedMap.KeySet.comparator()
           
 FloatComparator Float2LongAVLTreeMap.comparator()
           
 FloatComparator Float2IntAVLTreeMap.comparator()
           
 FloatComparator Float2ShortSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2BooleanRBTreeMap.comparator()
           
 FloatComparator Float2FloatSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2ReferenceLinkedOpenHashMap.comparator()
           
 FloatComparator Float2ShortSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2ShortSortedMaps.Singleton.comparator()
           
 FloatComparator Float2ShortSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2ShortSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2ShortRBTreeMap.comparator()
           
 FloatComparator FloatSortedSet.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its elements' natural ordering.
 FloatComparator FloatLinkedOpenHashSet.comparator()
           
 FloatComparator Float2FloatLinkedOpenHashMap.comparator()
           
 FloatComparator Float2IntSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2LongSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2BooleanAVLTreeMap.comparator()
           
 FloatComparator Float2DoubleAVLTreeMap.comparator()
           
 FloatComparator AbstractFloat2ReferenceSortedMap.KeySet.comparator()
           
 FloatComparator Float2ShortAVLTreeMap.comparator()
           
 FloatComparator Float2ByteRBTreeMap.comparator()
           
 FloatComparator Float2CharAVLTreeMap.comparator()
           
 FloatComparator Float2ObjectRBTreeMap.comparator()
           
 FloatComparator Float2ReferenceSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2ByteLinkedOpenHashMap.comparator()
           
 FloatComparator Float2ObjectSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2ObjectSortedMaps.Singleton.comparator()
           
 FloatComparator Float2ObjectSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2ObjectSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator FloatPriorityQueue.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its elements' natural ordering.
 FloatComparator Float2BooleanSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2DoubleRBTreeMap.comparator()
           
 FloatComparator Float2IntSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2IntSortedMaps.Singleton.comparator()
           
 FloatComparator Float2IntSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2IntSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator FloatArrayIndirectPriorityQueue.comparator()
           
 FloatComparator FloatIndirectPriorityQueue.comparator()
          Returns the comparator associated with this queue.
 FloatComparator FloatLinkedOpenCustomHashSet.comparator()
           
 FloatComparator FloatRBTreeSet.comparator()
           
 FloatComparator Float2ObjectLinkedOpenHashMap.comparator()
           
 FloatComparator FloatArrayPriorityQueue.comparator()
           
 FloatComparator Float2ByteAVLTreeMap.comparator()
           
 FloatComparator Float2CharRBTreeMap.comparator()
           
 FloatComparator FloatArrayFIFOQueue.comparator()
          Returns null (FIFO queues have no comparator).
 FloatComparator Float2IntLinkedOpenHashMap.comparator()
           
 FloatComparator Float2FloatAVLTreeMap.comparator()
           
 FloatComparator AbstractFloat2BooleanSortedMap.KeySet.comparator()
           
 FloatComparator Float2CharSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2CharSortedMaps.Singleton.comparator()
           
 FloatComparator Float2CharSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2CharSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator FloatAVLTreeSet.comparator()
           
 FloatComparator AbstractFloat2ObjectSortedMap.KeySet.comparator()
           
 FloatComparator AbstractFloat2ByteSortedMap.KeySet.comparator()
           
 FloatComparator Float2BooleanSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2BooleanSortedMaps.Singleton.comparator()
           
 FloatComparator Float2BooleanSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2BooleanSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2ReferenceSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2ReferenceSortedMaps.Singleton.comparator()
           
 FloatComparator Float2ReferenceSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2ReferenceSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2ReferenceRBTreeMap.comparator()
           
 FloatComparator AbstractFloat2FloatSortedMap.KeySet.comparator()
           
 FloatComparator Float2ReferenceAVLTreeMap.comparator()
           
 FloatComparator FloatHeapPriorityQueue.comparator()
           
 FloatComparator Float2BooleanLinkedOpenHashMap.comparator()
           
 FloatComparator Float2DoubleSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2DoubleSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2DoubleSortedMaps.Singleton.comparator()
           
 FloatComparator Float2DoubleSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2DoubleSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2CharSortedMap.comparator()
          Returns the comparator associated with this sorted set, or null if it uses its keys' natural ordering.
 FloatComparator Float2CharLinkedOpenHashMap.comparator()
           
 FloatComparator Float2DoubleLinkedOpenHashMap.comparator()
           
 FloatComparator AbstractFloat2ShortSortedMap.KeySet.comparator()
           
 FloatComparator Float2IntRBTreeMap.comparator()
           
 FloatComparator FloatHeapSemiIndirectPriorityQueue.comparator()
           
 FloatComparator AbstractFloat2CharSortedMap.KeySet.comparator()
           
 FloatComparator Float2FloatRBTreeMap.comparator()
           
 FloatComparator Float2ObjectAVLTreeMap.comparator()
           
 FloatComparator AbstractFloat2IntSortedMap.KeySet.comparator()
           
 FloatComparator Float2ByteSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2ByteSortedMaps.Singleton.comparator()
           
 FloatComparator Float2ByteSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2ByteSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2FloatSortedMaps.EmptySortedMap.comparator()
           
 FloatComparator Float2FloatSortedMaps.Singleton.comparator()
           
 FloatComparator Float2FloatSortedMaps.SynchronizedSortedMap.comparator()
           
 FloatComparator Float2FloatSortedMaps.UnmodifiableSortedMap.comparator()
           
 FloatComparator Float2ShortLinkedOpenHashMap.comparator()
           
 FloatComparator Float2LongRBTreeMap.comparator()
           
static FloatComparator FloatComparators.oppositeComparator(FloatComparator c)
          Returns a comparator representing the opposite order of the given comparator.
 

Methods in it.unimi.dsi.fastutil.floats with parameters of type FloatComparator
static long FloatBigArrays.binarySearch(float[][] a, float key, FloatComparator c)
          Searches a big array for the specified value using the binary search algorithm and a specified comparator.
static long FloatBigArrays.binarySearch(float[][] a, long from, long to, float key, FloatComparator c)
          Searches a range of the specified big array for the specified value using the binary search algorithm and a specified comparator.
static int FloatArrays.binarySearch(float[] a, float key, FloatComparator c)
          Searches an array for the specified value using the binary search algorithm and a specified comparator.
static int FloatArrays.binarySearch(float[] a, int from, int to, float key, FloatComparator c)
          Searches a range of the specified array for the specified value using the binary search algorithm and a specified comparator.
static int FloatIndirectHeaps.downHeap(float[] refArray, int[] heap, int[] inv, int size, int i, FloatComparator c)
          Moves the given element down into the indirect heap until it reaches the lowest possible position.
static int FloatSemiIndirectHeaps.downHeap(float[] refArray, int[] heap, int size, int i, FloatComparator c)
          Moves the given element down into the semi-indirect heap until it reaches the lowest possible position.
static int FloatHeaps.downHeap(float[] heap, int size, int i, FloatComparator c)
          Moves the given element down into the heap until it reaches the lowest possible position.
static Comparator<? super Map.Entry<Float,?>> Float2LongSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2ShortSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2ObjectSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2IntSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2CharSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2BooleanSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2ReferenceSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2DoubleSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2ByteSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static Comparator<? super Map.Entry<Float,?>> Float2FloatSortedMaps.entryComparator(FloatComparator comparator)
          Returns a comparator for entries based on a given comparator on keys.
static void FloatIndirectHeaps.makeHeap(float[] refArray, int[] heap, int[] inv, int size, FloatComparator c)
          Creates an indirect heap from a given index array.
static void FloatSemiIndirectHeaps.makeHeap(float[] refArray, int[] heap, int size, FloatComparator c)
          Creates a semi-indirect heap from a given index array.
static void FloatHeaps.makeHeap(float[] heap, int size, FloatComparator c)
          Makes an array into a heap.
static int[] FloatSemiIndirectHeaps.makeHeap(float[] refArray, int offset, int length, FloatComparator c)
          Creates a semi-indirect heap, allocating its heap array.
static void FloatSemiIndirectHeaps.makeHeap(float[] refArray, int offset, int length, int[] heap, FloatComparator c)
          Creates a semi-indirect heap in the given array.
static void FloatIndirectHeaps.makeHeap(float[] refArray, int offset, int length, int[] heap, int[] inv, FloatComparator c)
          Creates an indirect heap in the given array.
static void FloatArrays.mergeSort(float[] a, FloatComparator comp)
          Sorts an array according to the order induced by the specified comparator using mergesort.
static void FloatArrays.mergeSort(float[] a, int from, int to, FloatComparator comp)
          Sorts the specified range of elements according to the order induced by the specified comparator using mergesort.
static void FloatArrays.mergeSort(float[] a, int from, int to, FloatComparator comp, float[] supp)
          Sorts the specified range of elements according to the order induced by the specified comparator using mergesort, using a given support array.
static FloatComparator FloatComparators.oppositeComparator(FloatComparator c)
          Returns a comparator representing the opposite order of the given comparator.
static void FloatBigArrays.quickSort(float[][] x, FloatComparator comp)
          Sorts the specified big array according to the order induced by the specified comparator using quicksort.
static void FloatBigArrays.quickSort(float[][] x, long from, long to, FloatComparator comp)
          Sorts the specified range of elements according to the order induced by the specified comparator using quicksort.
static void FloatArrays.quickSort(float[] x, FloatComparator comp)
          Sorts an array according to the order induced by the specified comparator using quicksort.
static void FloatArrays.quickSort(float[] x, int from, int to, FloatComparator comp)
          Sorts the specified range of elements according to the order induced by the specified comparator using quicksort.
static Float2BooleanSortedMap Float2BooleanSortedMaps.singleton(float key, boolean value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2BooleanSortedMap Float2BooleanSortedMaps.singleton(Float key, Boolean value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static Float2ByteSortedMap Float2ByteSortedMaps.singleton(float key, byte value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2ByteSortedMap Float2ByteSortedMaps.singleton(Float key, Byte value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static Float2CharSortedMap Float2CharSortedMaps.singleton(Float key, Character value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static Float2CharSortedMap Float2CharSortedMaps.singleton(float key, char value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2DoubleSortedMap Float2DoubleSortedMaps.singleton(float key, double value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2DoubleSortedMap Float2DoubleSortedMaps.singleton(Float key, Double value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static FloatSortedSet FloatSortedSets.singleton(float element, FloatComparator comparator)
          Returns a type-specific immutable sorted set containing only the specified element, and using a specified comparator.
static Float2FloatSortedMap Float2FloatSortedMaps.singleton(float key, float value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2FloatSortedMap Float2FloatSortedMaps.singleton(Float key, Float value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static Float2IntSortedMap Float2IntSortedMaps.singleton(Float key, Integer value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static Float2IntSortedMap Float2IntSortedMaps.singleton(float key, int value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2LongSortedMap Float2LongSortedMaps.singleton(float key, long value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2LongSortedMap Float2LongSortedMaps.singleton(Float key, Long value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static Float2ShortSortedMap Float2ShortSortedMaps.singleton(float key, short value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static Float2ShortSortedMap Float2ShortSortedMaps.singleton(Float key, Short value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static
<V> Float2ObjectSortedMap<V>
Float2ObjectSortedMaps.singleton(float key, V value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static
<V> Float2ReferenceSortedMap<V>
Float2ReferenceSortedMaps.singleton(float key, V value, FloatComparator comparator)
          Returns a type-specific immutable sorted map containing only the specified pair.
static
<V> Float2ObjectSortedMap<V>
Float2ObjectSortedMaps.singleton(Float key, V value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static
<V> Float2ReferenceSortedMap<V>
Float2ReferenceSortedMaps.singleton(Float key, V value, FloatComparator comparator)
          RETURNS a type-specific immutable sorted map containing only the specified pair.
static FloatSortedSet FloatSortedSets.singleton(Object element, FloatComparator comparator)
          Returns a type-specific immutable sorted set containing only the specified element, and using a specified comparator.
static int FloatIndirectHeaps.upHeap(float[] refArray, int[] heap, int[] inv, int size, int i, FloatComparator c)
          Moves the given element up in the indirect heap until it reaches the highest possible position.
static int FloatSemiIndirectHeaps.upHeap(float[] refArray, int[] heap, int size, int i, FloatComparator c)
          Moves the given element up in the semi-indirect heap until it reaches the highest possible position.
static int FloatHeaps.upHeap(float[] heap, int size, int i, FloatComparator c)
          Moves the given element up in the heap until it reaches the highest possible position.
 

Constructors in it.unimi.dsi.fastutil.floats with parameters of type FloatComparator
Float2BooleanSortedMaps.Singleton(float key, boolean value, FloatComparator comparator)
           
Float2ByteSortedMaps.Singleton(float key, byte value, FloatComparator comparator)
           
Float2CharSortedMaps.Singleton(float key, char value, FloatComparator comparator)
           
Float2DoubleSortedMaps.Singleton(float key, double value, FloatComparator comparator)
           
Float2FloatSortedMaps.Singleton(float key, float value, FloatComparator comparator)
           
Float2IntSortedMaps.Singleton(float key, int value, FloatComparator comparator)
           
Float2LongSortedMaps.Singleton(float key, long value, FloatComparator comparator)
           
Float2ObjectSortedMaps.Singleton(float key, V value, FloatComparator comparator)
           
Float2ReferenceSortedMaps.Singleton(float key, V value, FloatComparator comparator)
           
Float2ShortSortedMaps.Singleton(float key, short value, FloatComparator comparator)
           
FloatArrayIndirectPriorityQueue(float[] refArray, FloatComparator c)
          Creates a new empty queue with capacity equal to the length of the reference array and a given comparator.
FloatArrayIndirectPriorityQueue(float[] refArray, int[] a, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatArrayIndirectPriorityQueue(float[] refArray, int[] a, int size, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatArrayIndirectPriorityQueue(float[] refArray, int capacity, FloatComparator c)
          Creates a new empty queue without elements with a given capacity and comparator.
FloatArrayPriorityQueue(float[] a, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatArrayPriorityQueue(float[] a, int size, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatArrayPriorityQueue(FloatComparator c)
          Creates a new empty queue with a given comparator.
FloatArrayPriorityQueue(int capacity, FloatComparator c)
          Creates a new empty queue with a given capacity and comparator.
FloatHeapIndirectPriorityQueue(float[] refArray, FloatComparator c)
          Creates a new empty queue with capacity equal to the length of the reference array and a given comparator.
FloatHeapIndirectPriorityQueue(float[] refArray, int[] a, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatHeapIndirectPriorityQueue(float[] refArray, int[] a, int size, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatHeapIndirectPriorityQueue(float[] refArray, int capacity, FloatComparator c)
          Creates a new empty queue with a given capacity and comparator.
FloatHeapPriorityQueue(float[] a, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatHeapPriorityQueue(float[] a, int size, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatHeapPriorityQueue(FloatComparator c)
          Creates a new empty queue with a given comparator.
FloatHeapPriorityQueue(int capacity, FloatComparator c)
          Creates a new empty queue with a given capacity and comparator.
FloatHeapSemiIndirectPriorityQueue(float[] refArray, FloatComparator c)
          Creates a new empty queue with capacity equal to the length of the reference array and a given comparator.
FloatHeapSemiIndirectPriorityQueue(float[] refArray, int[] a, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatHeapSemiIndirectPriorityQueue(float[] refArray, int[] a, int size, FloatComparator c)
          Wraps a given array in a queue using a given comparator.
FloatHeapSemiIndirectPriorityQueue(float[] refArray, int capacity, FloatComparator c)
          Creates a new empty queue without elements with a given capacity and comparator.
 



Copyright © 2011. All Rights Reserved.