com.ibm.bluej.util.common

Class MutableDoubleHashMap

java.lang.Object

com.ibm.bluej.util.common.MutableDoubleHashMap

public abstract class MutableDoubleHashMap
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	MutableDoubleHashMap.OverlapRecord<T>

Constructor Summary

Constructors

Constructor and Description
MutableDoubleHashMap()

Method Summary

Methods

Modifier and Type	Method and Description
static <T> void	addTo(java.util.Map<T,MutableDouble> addTo, java.util.Map<T,MutableDouble> toAdd)
static <S,T> void	addTo2(java.util.Map<T,java.util.HashMap<S,MutableDouble>> addTo, java.util.Map<T,java.util.HashMap<S,MutableDouble>> toAdd)
static <T> void	averageIn(double newSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toAdd, double count)
static <T> void	averageIn(int newSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toAdd)
static <T> void	averageOut(int oldSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toSubtract)
static <S,T,M extends java.util.Map<T,MutableDouble>> java.util.Map<T,java.util.ArrayList<S>>	buildKeyDims(java.util.Map<S,M> coOccurrence, int numDims)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	conditionPMI(java.util.Map<S,M> coOccurrence)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	conditionPMI(java.util.Map<S,M> coOccurrence, double minFirst, double minSecond)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	conditionPMI(java.util.Map<S,M> coOccurrence, java.util.Map<S,MutableDouble> firstFreq, java.util.Map<T,MutableDouble> secondFreq, double firstTotal, double secondTotal, double coTotal)
static java.util.HashMap<?,IndexValuePair>	convertToIndex(java.util.Map<?,MutableDouble> hashMap, int firstIndex, double minimum)
static <T> java.util.HashMap<T,MutableDouble>	copyValues(java.util.Map<T,MutableDouble> map)
static <S> double	cosineSimilarity(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <S> double	cosineSimilarity(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty)
static <S> double	cosineSimilarityAlt(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty)
static <S> double	cosineSimilarityFlex(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty, FunST<S,java.lang.Double> weightFun, FunST<java.lang.Double,java.lang.Double> thresholdFun)
static double	cosineSimilarityOld(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2, double sizePenalty) Deprecated.
static <T> void	divideBy(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	divideByAdd1(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <S> double	dotProduct(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <T> boolean	equals(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> java.util.HashMap<T,MutableDouble>	fromImmutable(java.util.Map<T,java.lang.Double> im)
static java.util.HashMap<java.lang.String,MutableDouble>	fromTSVString(java.lang.Iterable<java.lang.String> lines, double min)
static java.util.HashMap<java.lang.String,MutableDouble>	fromTSVString(java.lang.String tsv, double min)
static <K> double	getDefaultZero(java.util.Map<K,MutableDouble> m, K key)
static <S,T,M extends java.util.Map<T,MutableDouble>> double	getDefaultZero(java.util.Map<S,M> map, S key1, T key2)
static <T> java.util.HashMap<T,MutableDouble>	getGrubbsZ(java.util.Map<T,MutableDouble> m, double mean, double variance)
static int[]	getHisto(java.util.Map<?,MutableDouble> m, double[] thresholds)
static int[]	getHisto2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> m, double[] thresholds)
static <T> java.util.Collection<T>	getKeyDims(java.util.Map<T,MutableDouble> map, int numDims)
static double	getMean(java.util.Map<?,MutableDouble> m)
static double	getNorm(java.util.Map<?,MutableDouble> m)
static double	getOneNorm(java.util.Map<?,MutableDouble> m)
static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>>	getOverlap(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>>	getOverlapDirectional(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static double	getTwoNorm(java.util.Map<?,MutableDouble> m) Version of getNorm that doesn't take the square root
static double	getVariance(java.util.Map<?,MutableDouble> m, double mean)
static <S,T> boolean	increase(java.util.Map<S,java.util.HashMap<T,MutableDouble>> doubleMap, S key1, T key2, double value) Increase the key1->key2->v by value
static <S,T,M extends java.util.Map<T,MutableDouble>> boolean	increase(java.util.Map<S,M> doubleMap, FunVT<M> factory, S key1, T key2, double value)
static <T> boolean	increase(java.util.Map<T,MutableDouble> map, T key, double value)
static double	jaccard(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static <T> void	linearScaleUnitVariance(java.util.Map<T,MutableDouble> m)
static <T> Pair<T,MutableDouble>	maxEntry(java.util.Map<T,MutableDouble> map)
static <T> T	maxKey(java.util.Map<T,MutableDouble> map)
static MutableDouble	maxValue(java.util.Map<?,MutableDouble> map)
static MutableDouble	minValue(java.util.Map<?,MutableDouble> map)
static double	normalize(java.util.Map<?,MutableDouble> m)
static double	normalizeOne(java.util.Map<?,MutableDouble> m)
static <T> java.lang.Double	rank(java.util.Map<T,MutableDouble> map, T key) Rank 1 means key is the maxKey, rank 2 means one entry is greater...
static void	scale(java.util.Map<?,MutableDouble> m, double scalingFactor)
static <T> void	setMax(java.util.Map<T,MutableDouble> map, T key, double maybeMax)
static <T> java.util.List<Pair<T,MutableDouble>>	sorted(java.util.Map<T,MutableDouble> m) least to greatest
static <T> java.util.List<Pair<T,MutableDouble>>	sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp)
static <T> java.util.List<Pair<T,MutableDouble>>	sortedReverse(java.util.Map<T,MutableDouble> m) greatest to least
static java.lang.String	stringHisto(double[] thresholds, int[] counts)
static <T> void	subtract(java.util.Map<T,MutableDouble> from, java.util.Map<T,MutableDouble> x, boolean newEntries)
static double	sum(java.util.Map<?,MutableDouble> c1)
static double	sum2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> c1)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	thresholds(java.util.Map<S,M> doubleMap, double minValue, double maxValue)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	thresholdsAbs(java.util.Map<S,M> doubleMap, double minValue, double maxValue)
static double[]	toDense(java.util.Map<java.lang.Integer,MutableDouble> m)
static <T> java.util.HashMap<T,java.lang.Double>	toImmutable(java.util.Map<T,MutableDouble> m)
static <T> java.lang.String	toString(java.util.Map<T,MutableDouble> m)
static <T> java.lang.String	toString(java.util.Map<T,MutableDouble> m, int topN)
static <T> java.lang.String	toString(java.util.Map<T,MutableDouble> m, int topN, int width)
static double	totalOverlap(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static <T> java.lang.String	toTSVString(java.util.Map<T,MutableDouble> m)
static <T> void	toTSVString(java.util.Map<T,MutableDouble> m, java.lang.String filename)
static <K> void	trimByThreshold(java.util.Map<K,MutableDouble> hashMap, double removeBelow)
static <K> void	trimByThresholdAbs(java.util.Map<K,MutableDouble> hashMap, double removeBelow)
static <T> void	trimDimensions(java.util.Map<T,MutableDouble> map, double retainLength)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	trimDimensions2(java.util.Map<S,M> coOccurrence, double retainLength)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	trimDouble(java.util.Map<S,M> coOccurrence, double minFirst, double minSecond)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	trimDoubleByThreshold(java.util.Map<S,M> doubleMap, double removeBelow)
static <T> void	trimToTopN(java.util.Map<T,MutableDouble> map, int maxSize)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MutableDoubleHashMap

public MutableDoubleHashMap()

Method Detail

toTSVString

public static <T> void toTSVString(java.util.Map<T,MutableDouble> m,
                   java.lang.String filename)

toTSVString

public static <T> java.lang.String toTSVString(java.util.Map<T,MutableDouble> m)

fromTSVString

public static java.util.HashMap<java.lang.String,MutableDouble> fromTSVString(java.lang.String tsv,
                                                              double min)

fromTSVString

public static java.util.HashMap<java.lang.String,MutableDouble> fromTSVString(java.lang.Iterable<java.lang.String> lines,
                                                              double min)

equals

public static <T> boolean equals(java.util.Map<T,MutableDouble> m1,
                 java.util.Map<T,MutableDouble> m2)

getOverlap

public static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>> getOverlap(java.util.Map<T,MutableDouble> m1,
                                                                   java.util.Map<T,MutableDouble> m2)

getOverlapDirectional

public static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>> getOverlapDirectional(java.util.Map<T,MutableDouble> m1,
                                                                              java.util.Map<T,MutableDouble> m2)

subtract

public static <T> void subtract(java.util.Map<T,MutableDouble> from,
                java.util.Map<T,MutableDouble> x,
                boolean newEntries)

copyValues

public static <T> java.util.HashMap<T,MutableDouble> copyValues(java.util.Map<T,MutableDouble> map)

sorted

public static <T> java.util.List<Pair<T,MutableDouble>> sorted(java.util.Map<T,MutableDouble> m,
                                               SecondPairComparator<T,MutableDouble> comp)

sorted

public static <T> java.util.List<Pair<T,MutableDouble>> sorted(java.util.Map<T,MutableDouble> m)

least to greatest

Parameters:

m -

Returns:

sortedReverse

public static <T> java.util.List<Pair<T,MutableDouble>> sortedReverse(java.util.Map<T,MutableDouble> m)

greatest to least

Parameters:

m -

Returns:

getGrubbsZ

public static <T> java.util.HashMap<T,MutableDouble> getGrubbsZ(java.util.Map<T,MutableDouble> m,
                                                double mean,
                                                double variance)

getMean

public static double getMean(java.util.Map<?,MutableDouble> m)

getVariance

public static double getVariance(java.util.Map<?,MutableDouble> m,
                 double mean)

getHisto

public static int[] getHisto(java.util.Map<?,MutableDouble> m,
             double[] thresholds)

getHisto2

public static int[] getHisto2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> m,
              double[] thresholds)

stringHisto

public static java.lang.String stringHisto(double[] thresholds,
                           int[] counts)

getDefaultZero

public static <K> double getDefaultZero(java.util.Map<K,MutableDouble> m,
                        K key)

getDefaultZero

public static <S,T,M extends java.util.Map<T,MutableDouble>> double getDefaultZero(java.util.Map<S,M> map,
                                                                   S key1,
                                                                   T key2)

maxEntry

public static <T> Pair<T,MutableDouble> maxEntry(java.util.Map<T,MutableDouble> map)

rank

public static <T> java.lang.Double rank(java.util.Map<T,MutableDouble> map,
                        T key)

Rank 1 means key is the maxKey, rank 2 means one entry is greater... Null when key is not present

Parameters:

map -

key -

Returns:

maxKey

public static <T> T maxKey(java.util.Map<T,MutableDouble> map)

maxValue

public static MutableDouble maxValue(java.util.Map<?,MutableDouble> map)

minValue

public static MutableDouble minValue(java.util.Map<?,MutableDouble> map)

trimDoubleByThreshold

public static <S,T,M extends java.util.Map<T,MutableDouble>> int trimDoubleByThreshold(java.util.Map<S,M> doubleMap,
                                                                       double removeBelow)

thresholds

public static <S,T,M extends java.util.Map<T,MutableDouble>> int thresholds(java.util.Map<S,M> doubleMap,
                                                            double minValue,
                                                            double maxValue)

thresholdsAbs

public static <S,T,M extends java.util.Map<T,MutableDouble>> int thresholdsAbs(java.util.Map<S,M> doubleMap,
                                                               double minValue,
                                                               double maxValue)

trimByThreshold

public static <K> void trimByThreshold(java.util.Map<K,MutableDouble> hashMap,
                       double removeBelow)

trimByThresholdAbs

public static <K> void trimByThresholdAbs(java.util.Map<K,MutableDouble> hashMap,
                          double removeBelow)

setMax

public static <T> void setMax(java.util.Map<T,MutableDouble> map,
              T key,
              double maybeMax)

addTo

public static <T> void addTo(java.util.Map<T,MutableDouble> addTo,
             java.util.Map<T,MutableDouble> toAdd)

addTo2

public static <S,T> void addTo2(java.util.Map<T,java.util.HashMap<S,MutableDouble>> addTo,
                java.util.Map<T,java.util.HashMap<S,MutableDouble>> toAdd)

averageIn

public static <T> void averageIn(int newSize,
                 java.util.Map<T,MutableDouble> average,
                 java.util.Map<T,MutableDouble> toAdd)

averageIn

public static <T> void averageIn(double newSize,
                 java.util.Map<T,MutableDouble> average,
                 java.util.Map<T,MutableDouble> toAdd,
                 double count)

averageOut

public static <T> void averageOut(int oldSize,
                  java.util.Map<T,MutableDouble> average,
                  java.util.Map<T,MutableDouble> toSubtract)

increase

public static <S,T> boolean increase(java.util.Map<S,java.util.HashMap<T,MutableDouble>> doubleMap,
                     S key1,
                     T key2,
                     double value)

Increase the key1->key2->v by value

Parameters:

doubleMap -

key1 -

key2 -

value -

Returns:

true if there was a new entry (key1, key2) previously unseen

increase

public static <S,T,M extends java.util.Map<T,MutableDouble>> boolean increase(java.util.Map<S,M> doubleMap,
                                                              FunVT<M> factory,
                                                              S key1,
                                                              T key2,
                                                              double value)

Parameters:

doubleMap -

factory -

key1 -

key2 -

value -

Returns:

true if it created a new entry

increase

public static <T> boolean increase(java.util.Map<T,MutableDouble> map,
                   T key,
                   double value)

convertToIndex

public static java.util.HashMap<?,IndexValuePair> convertToIndex(java.util.Map<?,MutableDouble> hashMap,
                                                 int firstIndex,
                                                 double minimum)

sum

public static double sum(java.util.Map<?,MutableDouble> c1)

sum2

public static double sum2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> c1)

normalize

public static double normalize(java.util.Map<?,MutableDouble> m)

normalizeOne

public static double normalizeOne(java.util.Map<?,MutableDouble> m)

scale

public static void scale(java.util.Map<?,MutableDouble> m,
         double scalingFactor)

getNorm

public static double getNorm(java.util.Map<?,MutableDouble> m)

getTwoNorm

public static double getTwoNorm(java.util.Map<?,MutableDouble> m)

Version of getNorm that doesn't take the square root

Parameters:

m - a sparse vector

Returns:

The two norm WITHOUT the square root

getOneNorm

public static double getOneNorm(java.util.Map<?,MutableDouble> m)

dotProduct

public static <S> double dotProduct(java.util.Map<S,MutableDouble> c1,
                    java.util.Map<S,MutableDouble> c2)

cosineSimilarityAlt

public static <S> double cosineSimilarityAlt(java.util.Map<S,MutableDouble> c1,
                             java.util.Map<S,MutableDouble> c2,
                             double sizePenalty)

cosineSimilarityFlex

public static <S> double cosineSimilarityFlex(java.util.Map<S,MutableDouble> c1,
                              java.util.Map<S,MutableDouble> c2,
                              double sizePenalty,
                              FunST<S,java.lang.Double> weightFun,
                              FunST<java.lang.Double,java.lang.Double> thresholdFun)

cosineSimilarity

public static <S> double cosineSimilarity(java.util.Map<S,MutableDouble> c1,
                          java.util.Map<S,MutableDouble> c2)

cosineSimilarity

public static <S> double cosineSimilarity(java.util.Map<S,MutableDouble> c1,
                          java.util.Map<S,MutableDouble> c2,
                          double sizePenalty)

cosineSimilarityOld

public static double cosineSimilarityOld(java.util.Map<?,MutableDouble> c1,
                         java.util.Map<?,MutableDouble> c2,
                         double sizePenalty)

Deprecated.

Parameters:

c1 -

c2 -

sizePenalty -

Returns:

jaccard

public static double jaccard(java.util.Map<?,MutableDouble> c1,
             java.util.Map<?,MutableDouble> c2)

totalOverlap

public static double totalOverlap(java.util.Map<?,MutableDouble> c1,
                  java.util.Map<?,MutableDouble> c2)

toString

public static <T> java.lang.String toString(java.util.Map<T,MutableDouble> m)

toString

public static <T> java.lang.String toString(java.util.Map<T,MutableDouble> m,
                            int topN)

toString

public static <T> java.lang.String toString(java.util.Map<T,MutableDouble> m,
                            int topN,
                            int width)

trimDimensions2

public static <S,T,M extends java.util.Map<T,MutableDouble>> void trimDimensions2(java.util.Map<S,M> coOccurrence,
                                                                  double retainLength)

trimDimensions

public static <T> void trimDimensions(java.util.Map<T,MutableDouble> map,
                      double retainLength)

trimToTopN

public static <T> void trimToTopN(java.util.Map<T,MutableDouble> map,
                  int maxSize)

trimDouble

public static <S,T,M extends java.util.Map<T,MutableDouble>> void trimDouble(java.util.Map<S,M> coOccurrence,
                                                             double minFirst,
                                                             double minSecond)

conditionPMI

public static <S,T,M extends java.util.Map<T,MutableDouble>> void conditionPMI(java.util.Map<S,M> coOccurrence,
                                                               double minFirst,
                                                               double minSecond)

toDense

public static double[] toDense(java.util.Map<java.lang.Integer,MutableDouble> m)

fromImmutable

public static <T> java.util.HashMap<T,MutableDouble> fromImmutable(java.util.Map<T,java.lang.Double> im)

toImmutable

public static <T> java.util.HashMap<T,java.lang.Double> toImmutable(java.util.Map<T,MutableDouble> m)

conditionPMI

public static <S,T,M extends java.util.Map<T,MutableDouble>> void conditionPMI(java.util.Map<S,M> coOccurrence)

conditionPMI

public static <S,T,M extends java.util.Map<T,MutableDouble>> void conditionPMI(java.util.Map<S,M> coOccurrence,
                                                               java.util.Map<S,MutableDouble> firstFreq,
                                                               java.util.Map<T,MutableDouble> secondFreq,
                                                               double firstTotal,
                                                               double secondTotal,
                                                               double coTotal)

getKeyDims

public static <T> java.util.Collection<T> getKeyDims(java.util.Map<T,MutableDouble> map,
                                     int numDims)

buildKeyDims

public static <S,T,M extends java.util.Map<T,MutableDouble>> java.util.Map<T,java.util.ArrayList<S>> buildKeyDims(java.util.Map<S,M> coOccurrence,
                                                                                                  int numDims)

divideByAdd1

public static <T> void divideByAdd1(java.util.Map<T,MutableDouble> m,
                    java.util.Map<T,MutableDouble> div)

divideBy

public static <T> void divideBy(java.util.Map<T,MutableDouble> m,
                java.util.Map<T,MutableDouble> div)

linearScaleUnitVariance

public static <T> void linearScaleUnitVariance(java.util.Map<T,MutableDouble> m)