Uses of Class
com.ibm.bluej.util.common.MutableDouble

Packages that use MutableDouble

Package	Description
com.ibm.bluej.util.common	Provides utilities for collection reading, normalization, iteration and data handling

Uses of MutableDouble in com.ibm.bluej.util.common

Fields in com.ibm.bluej.util.common declared as MutableDouble

Modifier and Type	Field and Description
MutableDouble	MutableDoubleHashMap.OverlapRecord.val1
MutableDouble	MutableDoubleHashMap.OverlapRecord.val2

Methods in com.ibm.bluej.util.common with type parameters of type MutableDouble

Modifier and Type	Method and Description
static <S,T,M extends java.util.Map<T,MutableDouble>> java.util.Map<T,java.util.ArrayList<S>>	MutableDoubleHashMap.buildKeyDims(java.util.Map<S,M> coOccurrence, int numDims)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.conditionPMI(java.util.Map<S,M> coOccurrence)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	SparseVectors.conditionPMI(java.util.Map<S,M> coOccurrence) every entry in the co-occurrence matrix is replaced by the pointwise mutaul information of the first key and the second key the frequency of the first key is given in firstFreq, the total is in firstTotal so that p(first) is firstFreq.get(first)/firstTotal; similarly for second coTotal is given in the second so that p(first & second) = coOccurrence.get(first).get(second)/coTotal in this version, the coOccurrence matrix is assumed to be complete, so that the firstFreq, secondFreq and all totals can be inferred from coOccurrence
static <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.conditionPMI(java.util.Map<S,M> coOccurrence, double minFirst, double minSecond)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.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 <S,T,M extends java.util.Map<T,MutableDouble>> void	SparseVectors.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) http://en.wikipedia.org/wiki/Pointwise_mutual_information every entry in the co-occurrence matrix is replaced by the pointwise mutual information of the first key and the second key the frequency of the first key is given in firstFreq, the total is in firstTotal so that p(first) is firstFreq.get(first)/firstTotal; similarly for second coTotal is given in the second so that p(first & second) = coOccurrence.get(first).get(second)/coTotal the pmi(x,y) is log(p(x&y) / (p(x) * p(y)) but the matrix gives frequencies
static <S,T,M extends java.util.Map<T,MutableDouble>> double	MutableDoubleHashMap.getDefaultZero(java.util.Map<S,M> map, S key1, T key2)
static <S,T,M extends java.util.Map<T,MutableDouble>> boolean	MutableDoubleHashMap.increase(java.util.Map<S,M> doubleMap, FunVT<M> factory, S key1, T key2, double value)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	MutableDoubleHashMap.thresholds(java.util.Map<S,M> doubleMap, double minValue, double maxValue)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	SparseVectors.thresholds(java.util.Map<S,M> doubleMap, double minValue, double maxValue)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	MutableDoubleHashMap.thresholdsAbs(java.util.Map<S,M> doubleMap, double minValue, double maxValue)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	SparseVectors.thresholdsAbs(java.util.Map<S,M> doubleMap, double minValue, double maxValue)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.trimDimensions2(java.util.Map<S,M> coOccurrence, double retainLength)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	SparseVectors.trimDimensions2(java.util.Map<S,M> coOccurrence, double retainLength)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.trimDouble(java.util.Map<S,M> coOccurrence, double minFirst, double minSecond)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	SparseVectors.trimDouble(java.util.Map<S,M> coOccurrence, double minFirst, double minSecond)
static <S,T,M extends java.util.Map<T,MutableDouble>> int	MutableDoubleHashMap.trimDoubleByThreshold(java.util.Map<S,M> doubleMap, double removeBelow)

Methods in com.ibm.bluej.util.common that return MutableDouble

Modifier and Type	Method and Description
static <K1,K2> MutableDouble	SparseVectors.get(java.util.Map<K1,java.util.HashMap<K2,MutableDouble>> map, K1 key1, K2 key2, double deflt)
static <K> MutableDouble	SparseVectors.get(java.util.Map<K,MutableDouble> map, K key, double deflt)
MutableDouble	SparseVectors.OverlapRecord.getFirst()
MutableDouble	SparseVectors.OverlapRecord.getSecond()
static MutableDouble	MutableDoubleHashMap.maxValue(java.util.Map<?,MutableDouble> map)
static MutableDouble	SparseVectors.maxValue(java.util.Map<?,MutableDouble> map) returns the maximum value, null if empty
static MutableDouble	MutableDoubleHashMap.minValue(java.util.Map<?,MutableDouble> map)
static MutableDouble	SparseVectors.minValue(java.util.Map<?,MutableDouble> map)

Methods in com.ibm.bluej.util.common that return types with arguments of type MutableDouble

Modifier and Type	Method and Description
static <T> java.util.HashMap<T,MutableDouble>	MutableDoubleHashMap.copyValues(java.util.Map<T,MutableDouble> map)
static <T> java.util.HashMap<T,MutableDouble>	SparseVectors.copyValues(java.util.Map<T,MutableDouble> map)
static <T> java.util.HashMap<T,MutableDouble>	MutableDoubleHashMap.fromImmutable(java.util.Map<T,java.lang.Double> im)
static <T> java.util.HashMap<T,MutableDouble>	SparseVectors.fromImmutable(java.util.Map<T,java.lang.Double> im)
static java.util.HashMap<java.lang.String,MutableDouble>	SparseVectors.fromString(java.lang.String map)
static java.util.HashMap<java.lang.String,MutableDouble>	MutableDoubleHashMap.fromTSVString(java.lang.Iterable<java.lang.String> lines, double min)
static java.util.HashMap<java.lang.String,MutableDouble>	SparseVectors.fromTSVString(java.lang.Iterable<java.lang.String> lines, double min)
static java.util.HashMap<java.lang.String,MutableDouble>	MutableDoubleHashMap.fromTSVString(java.lang.String tsv, double min)
static java.util.HashMap<java.lang.String,MutableDouble>	SparseVectors.fromTSVString(java.lang.String tsv, double min)
static <T> java.util.HashMap<T,MutableDouble>	MutableDoubleHashMap.getGrubbsZ(java.util.Map<T,MutableDouble> m, double mean, double variance)
static <T> Pair<T,MutableDouble>	MutableDoubleHashMap.maxEntry(java.util.Map<T,MutableDouble> map)
static <T> Pair<T,MutableDouble>	SparseVectors.maxEntry(java.util.Map<T,MutableDouble> map)
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sorted(java.util.Map<T,MutableDouble> m) least to greatest
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sorted(java.util.Map<T,MutableDouble> m) least to greatest
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp)
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp) returns the sparse vector as a list of pairs, sorted by comp
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sortedReverse(java.util.Map<T,MutableDouble> m) greatest to least
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sortedReverse(java.util.Map<T,MutableDouble> m) greatest to least
static java.util.HashMap<java.lang.Integer,MutableDouble>	DenseVectors.toSparse(double[] v)

Methods in com.ibm.bluej.util.common with parameters of type MutableDouble

Modifier and Type	Method and Description
int	MutableDouble.AbsValueComparator.compare(MutableDouble o1, MutableDouble o2)
int	MutableDouble.compareTo(MutableDouble that)

Method parameters in com.ibm.bluej.util.common with type arguments of type MutableDouble

Modifier and Type	Method and Description
static <T> void	MutableDoubleHashMap.addTo(java.util.Map<T,MutableDouble> addTo, java.util.Map<T,MutableDouble> toAdd)
static <T> void	MutableDoubleHashMap.addTo(java.util.Map<T,MutableDouble> addTo, java.util.Map<T,MutableDouble> toAdd)
static <T> void	SparseVectors.addTo(java.util.Map<T,MutableDouble> addTo, java.util.Map<T,MutableDouble> toAdd) adds the second sparse vector to the first, modifying the first
static <T> void	SparseVectors.addTo(java.util.Map<T,MutableDouble> addTo, java.util.Map<T,MutableDouble> toAdd) adds the second sparse vector to the first, modifying the first
static <S,T> void	MutableDoubleHashMap.addTo2(java.util.Map<T,java.util.HashMap<S,MutableDouble>> addTo, java.util.Map<T,java.util.HashMap<S,MutableDouble>> toAdd)
static <S,T> void	MutableDoubleHashMap.addTo2(java.util.Map<T,java.util.HashMap<S,MutableDouble>> addTo, java.util.Map<T,java.util.HashMap<S,MutableDouble>> toAdd)
static <S,T> void	SparseVectors.addTo2(java.util.Map<T,java.util.HashMap<S,MutableDouble>> addTo, java.util.Map<T,java.util.HashMap<S,MutableDouble>> toAdd)
static <S,T> void	SparseVectors.addTo2(java.util.Map<T,java.util.HashMap<S,MutableDouble>> addTo, java.util.Map<T,java.util.HashMap<S,MutableDouble>> toAdd)
static <T> void	MutableDoubleHashMap.averageIn(double newSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toAdd, double count)
static <T> void	MutableDoubleHashMap.averageIn(double newSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toAdd, double count)
static <T> void	MutableDoubleHashMap.averageIn(int newSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toAdd)
static <T> void	MutableDoubleHashMap.averageIn(int newSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toAdd)
static <T> void	MutableDoubleHashMap.averageOut(int oldSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toSubtract)
static <T> void	MutableDoubleHashMap.averageOut(int oldSize, java.util.Map<T,MutableDouble> average, java.util.Map<T,MutableDouble> toSubtract)
static double	SparseVectors.binaryJaccard(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static double	SparseVectors.binaryJaccard(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.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 <S,T,M extends java.util.Map<T,MutableDouble>> void	MutableDoubleHashMap.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 <S,T,M extends java.util.Map<T,MutableDouble>> void	SparseVectors.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) http://en.wikipedia.org/wiki/Pointwise_mutual_information every entry in the co-occurrence matrix is replaced by the pointwise mutual information of the first key and the second key the frequency of the first key is given in firstFreq, the total is in firstTotal so that p(first) is firstFreq.get(first)/firstTotal; similarly for second coTotal is given in the second so that p(first & second) = coOccurrence.get(first).get(second)/coTotal the pmi(x,y) is log(p(x&y) / (p(x) * p(y)) but the matrix gives frequencies
static <S,T,M extends java.util.Map<T,MutableDouble>> void	SparseVectors.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) http://en.wikipedia.org/wiki/Pointwise_mutual_information every entry in the co-occurrence matrix is replaced by the pointwise mutual information of the first key and the second key the frequency of the first key is given in firstFreq, the total is in firstTotal so that p(first) is firstFreq.get(first)/firstTotal; similarly for second coTotal is given in the second so that p(first & second) = coOccurrence.get(first).get(second)/coTotal the pmi(x,y) is log(p(x&y) / (p(x) * p(y)) but the matrix gives frequencies
static java.util.HashMap<?,IndexValuePair>	MutableDoubleHashMap.convertToIndex(java.util.Map<?,MutableDouble> hashMap, int firstIndex, double minimum)
static <T> java.util.HashMap<T,MutableDouble>	MutableDoubleHashMap.copyValues(java.util.Map<T,MutableDouble> map)
static <T> java.util.HashMap<T,MutableDouble>	SparseVectors.copyValues(java.util.Map<T,MutableDouble> map)
static <K> double	SparseVectors.cosineSimilarity(java.util.Map<K,MutableDouble> c1, java.util.Map<K,MutableDouble> c2) http://en.wikipedia.org/wiki/Cosine_similarity if it would be NaN, it is instead zero
static <K> double	SparseVectors.cosineSimilarity(java.util.Map<K,MutableDouble> c1, java.util.Map<K,MutableDouble> c2) http://en.wikipedia.org/wiki/Cosine_similarity if it would be NaN, it is instead zero
static <S> double	MutableDoubleHashMap.cosineSimilarity(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <S> double	MutableDoubleHashMap.cosineSimilarity(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <S> double	MutableDoubleHashMap.cosineSimilarity(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty)
static <S> double	MutableDoubleHashMap.cosineSimilarity(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty)
static <S> double	MutableDoubleHashMap.cosineSimilarityAlt(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty)
static <S> double	MutableDoubleHashMap.cosineSimilarityAlt(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2, double sizePenalty)
static <S> double	MutableDoubleHashMap.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 <S> double	MutableDoubleHashMap.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	MutableDoubleHashMap.cosineSimilarityOld(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2, double sizePenalty) Deprecated.
static double	MutableDoubleHashMap.cosineSimilarityOld(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2, double sizePenalty) Deprecated.
static <T> void	MutableDoubleHashMap.divideBy(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	MutableDoubleHashMap.divideBy(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	SparseVectors.divideBy(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	SparseVectors.divideBy(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	MutableDoubleHashMap.divideByAdd1(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	MutableDoubleHashMap.divideByAdd1(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div)
static <T> void	SparseVectors.divideByAdd1(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div) Divides each entry in m by the corresponding entry in div with missing div = 0, adds 1 to each div
static <T> void	SparseVectors.divideByAdd1(java.util.Map<T,MutableDouble> m, java.util.Map<T,MutableDouble> div) Divides each entry in m by the corresponding entry in div with missing div = 0, adds 1 to each div
static <K> double	SparseVectors.dotProduct(java.util.Map<K,MutableDouble> x, java.util.Map<K,MutableDouble> y) "It is just the mathematical notion of dot product, sum of the products of each dimension
static <K> double	SparseVectors.dotProduct(java.util.Map<K,MutableDouble> x, java.util.Map<K,MutableDouble> y) "It is just the mathematical notion of dot product, sum of the products of each dimension
static <S> double	MutableDoubleHashMap.dotProduct(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <S> double	MutableDoubleHashMap.dotProduct(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <T> boolean	MutableDoubleHashMap.equals(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> boolean	MutableDoubleHashMap.equals(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> boolean	SparseVectors.equals(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> boolean	SparseVectors.equals(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <S> double	SparseVectors.euclidean(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <S> double	SparseVectors.euclidean(java.util.Map<S,MutableDouble> c1, java.util.Map<S,MutableDouble> c2)
static <K1,K2> MutableDouble	SparseVectors.get(java.util.Map<K1,java.util.HashMap<K2,MutableDouble>> map, K1 key1, K2 key2, double deflt)
static <K> MutableDouble	SparseVectors.get(java.util.Map<K,MutableDouble> map, K key, double deflt)
static <K> double	MutableDoubleHashMap.getDefaultZero(java.util.Map<K,MutableDouble> m, K key)
static <K> double	SparseVectors.getDefaultZero(java.util.Map<K,MutableDouble> m, K key) gets the value for the dimension key.
static <T> java.util.HashMap<T,MutableDouble>	MutableDoubleHashMap.getGrubbsZ(java.util.Map<T,MutableDouble> m, double mean, double variance)
static int[]	MutableDoubleHashMap.getHisto(java.util.Map<?,MutableDouble> m, double[] thresholds)
static int[]	SparseVectors.getHisto(java.util.Map<?,MutableDouble> m, double[] thresholds) thresholds is assumed sorted least to greatest the length of the returned value is one larger than thresholds the returned value in position i is equal to the number of entries in the sparse vector greater than thresholds[i-1] and less than thresholds[i] at the first position the value is equal to the number of entries in the sparse vector less than any threshold at the final position the value is equal to the number of entries greater than any threshold
static int[]	MutableDoubleHashMap.getHisto2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> m, double[] thresholds)
static <T> java.util.Collection<T>	MutableDoubleHashMap.getKeyDims(java.util.Map<T,MutableDouble> map, int numDims)
static <T> java.util.Collection<T>	SparseVectors.getKeyDims(java.util.Map<T,MutableDouble> map, int numDims) Returns the keys associated with the numDims greatest values
static double	MutableDoubleHashMap.getMean(java.util.Map<?,MutableDouble> m)
static double	SparseVectors.getMean(java.util.Map<?,MutableDouble> m) returns the average value
static double	MutableDoubleHashMap.getNorm(java.util.Map<?,MutableDouble> m)
static double	MutableDoubleHashMap.getOneNorm(java.util.Map<?,MutableDouble> m)
static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>>	MutableDoubleHashMap.getOverlap(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>>	MutableDoubleHashMap.getOverlap(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> java.util.List<SparseVectors.OverlapRecord<T>>	SparseVectors.getOverlap(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2) returns a sorted list with a OverlapRecord for every dimension in which both vectors have a value greater than zero
static <T> java.util.List<SparseVectors.OverlapRecord<T>>	SparseVectors.getOverlap(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2) returns a sorted list with a OverlapRecord for every dimension in which both vectors have a value greater than zero
static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>>	MutableDoubleHashMap.getOverlapDirectional(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static <T> java.util.List<MutableDoubleHashMap.OverlapRecord<T>>	MutableDoubleHashMap.getOverlapDirectional(java.util.Map<T,MutableDouble> m1, java.util.Map<T,MutableDouble> m2)
static double	MutableDoubleHashMap.getTwoNorm(java.util.Map<?,MutableDouble> m) Version of getNorm that doesn't take the square root
static double	MutableDoubleHashMap.getVariance(java.util.Map<?,MutableDouble> m, double mean)
static double	SparseVectors.getVariance(java.util.Map<?,MutableDouble> m, double mean) returns the variance of the values in m, assuming that their mean is 'mean'
static <S,T> boolean	MutableDoubleHashMap.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> boolean	SparseVectors.increase(java.util.Map<S,java.util.HashMap<T,MutableDouble>> doubleMap, S key1, T key2, double value) increase the entry corresponding to key1,key2 by value return true iff the entry was created
static <T> boolean	MutableDoubleHashMap.increase(java.util.Map<T,MutableDouble> map, T key, double value)
static <T> boolean	SparseVectors.increase(java.util.Map<T,MutableDouble> map, T key, double value) increase the entry corresponding to key by value return true iff the entry was created
static double	MutableDoubleHashMap.jaccard(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static double	MutableDoubleHashMap.jaccard(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static <T> void	MutableDoubleHashMap.linearScaleUnitVariance(java.util.Map<T,MutableDouble> m)
static <T> void	SparseVectors.linearScaleUnitVariance(java.util.Map<T,MutableDouble> m)
static <T> Pair<T,MutableDouble>	MutableDoubleHashMap.maxEntry(java.util.Map<T,MutableDouble> map)
static <T> Pair<T,MutableDouble>	SparseVectors.maxEntry(java.util.Map<T,MutableDouble> map)
static <T> T	MutableDoubleHashMap.maxKey(java.util.Map<T,MutableDouble> map)
static <T> T	SparseVectors.maxKey(java.util.Map<T,MutableDouble> map) returns the key for the maximum value, null if empty
static MutableDouble	MutableDoubleHashMap.maxValue(java.util.Map<?,MutableDouble> map)
static MutableDouble	SparseVectors.maxValue(java.util.Map<?,MutableDouble> map) returns the maximum value, null if empty
static MutableDouble	MutableDoubleHashMap.minValue(java.util.Map<?,MutableDouble> map)
static MutableDouble	SparseVectors.minValue(java.util.Map<?,MutableDouble> map)
static double	MutableDoubleHashMap.normalize(java.util.Map<?,MutableDouble> m)
static double	SparseVectors.normalize(java.util.Map<?,MutableDouble> m) scale the vector such that its twoNorm is now 1.0 return the twoNorm before it was scaled
static double	MutableDoubleHashMap.normalizeOne(java.util.Map<?,MutableDouble> m)
static double	SparseVectors.normalizeOne(java.util.Map<?,MutableDouble> m) scale the vector such that its oneNorm is now 1.0 return the oneNorm before it was scaled
static double	SparseVectors.oneNorm(java.util.Map<?,MutableDouble> x) oneNorm = L1 norm = Manhattan norm http://en.wikipedia.org/wiki/Norm_(mathematics)
static <T> java.lang.Double	MutableDoubleHashMap.rank(java.util.Map<T,MutableDouble> map, T key) Rank 1 means key is the maxKey, rank 2 means one entry is greater...
static <T> java.lang.Double	SparseVectors.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	MutableDoubleHashMap.scale(java.util.Map<?,MutableDouble> m, double scalingFactor)
static void	SparseVectors.scale(java.util.Map<?,MutableDouble> m, double scalingFactor) multiply every entry by the scalingFactor
static <T> void	SparseVectors.set(java.util.Map<T,MutableDouble> toSet, java.util.Map<T,MutableDouble> values)
static <T> void	SparseVectors.set(java.util.Map<T,MutableDouble> toSet, java.util.Map<T,MutableDouble> values)
static <T> boolean	SparseVectors.set(java.util.Map<T,MutableDouble> map, T key, double setTo)
static <T> void	MutableDoubleHashMap.setMax(java.util.Map<T,MutableDouble> map, T key, double maybeMax)
static <T> boolean	SparseVectors.setMax(java.util.Map<T,MutableDouble> map, T key, double maybeMax)
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sorted(java.util.Map<T,MutableDouble> m) least to greatest
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sorted(java.util.Map<T,MutableDouble> m) least to greatest
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp)
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp)
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp) returns the sparse vector as a list of pairs, sorted by comp
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sorted(java.util.Map<T,MutableDouble> m, SecondPairComparator<T,MutableDouble> comp) returns the sparse vector as a list of pairs, sorted by comp
static <T> java.util.List<Pair<T,MutableDouble>>	MutableDoubleHashMap.sortedReverse(java.util.Map<T,MutableDouble> m) greatest to least
static <T> java.util.List<Pair<T,MutableDouble>>	SparseVectors.sortedReverse(java.util.Map<T,MutableDouble> m) greatest to least
static <T> void	MutableDoubleHashMap.subtract(java.util.Map<T,MutableDouble> from, java.util.Map<T,MutableDouble> x, boolean newEntries)
static <T> void	MutableDoubleHashMap.subtract(java.util.Map<T,MutableDouble> from, java.util.Map<T,MutableDouble> x, boolean newEntries)
static <T> void	SparseVectors.subtract(java.util.Map<T,MutableDouble> from, java.util.Map<T,MutableDouble> x, boolean newEntries) the values in from are reduced by the corresponding amount in x if newEntries is true, a missing (zero) value in 'from' for 'key' will result in a new entry that is negative x.get(key) only the first sparse vector is modified
static <T> void	SparseVectors.subtract(java.util.Map<T,MutableDouble> from, java.util.Map<T,MutableDouble> x, boolean newEntries) the values in from are reduced by the corresponding amount in x if newEntries is true, a missing (zero) value in 'from' for 'key' will result in a new entry that is negative x.get(key) only the first sparse vector is modified
static double	MutableDoubleHashMap.sum(java.util.Map<?,MutableDouble> c1)
static double	SparseVectors.sum(java.util.Map<?,MutableDouble> c1) return the sum of the entries in the vector
static double	MutableDoubleHashMap.sum2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> c1)
static double	SparseVectors.sum2(java.util.Map<?,? extends java.util.Map<?,MutableDouble>> c1) return the sum of the entries in the matrix
static double[]	MutableDoubleHashMap.toDense(java.util.Map<java.lang.Integer,MutableDouble> m)
static double[]	SparseVectors.toDense(java.util.Map<java.lang.Integer,MutableDouble> m)
static <T> java.util.HashMap<T,java.lang.Double>	MutableDoubleHashMap.toImmutable(java.util.Map<T,MutableDouble> m)
static <T> java.util.HashMap<T,java.lang.Double>	SparseVectors.toImmutable(java.util.Map<T,MutableDouble> m)
static <K> java.lang.String	SparseVectors.toString(java.util.Map<K,MutableDouble> x) for each entry, one per line, it returns the toString of the key, then a space, then the value the entries are sorted by absolute value, greatest to least the toString of the key is padded with spaces on the left so that the keys line up on the right
static <K> java.lang.String	SparseVectors.toString(java.util.Map<K,MutableDouble> x, int topN) for each entry, one per line, it returns the toString of the key, then a space, then the value the topN entries are sorted by absolute value, greatest to least the toString of the key is padded with spaces on the left so that the keys line up on the right
static <T> java.lang.String	MutableDoubleHashMap.toString(java.util.Map<T,MutableDouble> m)
static <T> java.lang.String	MutableDoubleHashMap.toString(java.util.Map<T,MutableDouble> m, int topN)
static <T> java.lang.String	MutableDoubleHashMap.toString(java.util.Map<T,MutableDouble> m, int topN, int width)
static double	MutableDoubleHashMap.totalOverlap(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static double	MutableDoubleHashMap.totalOverlap(java.util.Map<?,MutableDouble> c1, java.util.Map<?,MutableDouble> c2)
static <T> java.lang.String	MutableDoubleHashMap.toTSVString(java.util.Map<T,MutableDouble> m)
static <T> java.lang.String	SparseVectors.toTSVString(java.util.Map<T,MutableDouble> m)
static <T> void	MutableDoubleHashMap.toTSVString(java.util.Map<T,MutableDouble> m, java.lang.String filename)
static <T> void	SparseVectors.toTSVString(java.util.Map<T,MutableDouble> m, java.lang.String filename)
static <K> void	MutableDoubleHashMap.trimByThreshold(java.util.Map<K,MutableDouble> hashMap, double removeBelow)
static <K> void	SparseVectors.trimByThreshold(java.util.Map<K,MutableDouble> map, double removeBelow) emoves all entries less than 'removeBelow
static <K> void	MutableDoubleHashMap.trimByThresholdAbs(java.util.Map<K,MutableDouble> hashMap, double removeBelow)
static <K> void	SparseVectors.trimByThresholdAbs(java.util.Map<K,MutableDouble> hashMap, double removeBelow)
static <T> void	MutableDoubleHashMap.trimDimensions(java.util.Map<T,MutableDouble> map, double retainLength)
static <T> void	SparseVectors.trimDimensions(java.util.Map<T,MutableDouble> map, double retainLength)
static <E> int	SparseVectors.trimDoubleByThreshold(java.util.Map<E,? extends java.util.Map<E,MutableDouble>> doubleMap, double removeBelow) removes all entries less than 'removeBelow', returns total number of entries in the sparse matrix
static <T> void	MutableDoubleHashMap.trimToTopN(java.util.Map<T,MutableDouble> map, int maxSize)
static <T> void	SparseVectors.trimToTopN(java.util.Map<T,MutableDouble> map, int maxSize)
static double	SparseVectors.twoNorm(java.util.Map<?,MutableDouble> x) twoNorm = L2 norm = Euclidean norm http://en.wikipedia.org/wiki/Norm_(mathematics)

Constructors in com.ibm.bluej.util.common with parameters of type MutableDouble

Constructor and Description
MutableDoubleHashMap.OverlapRecord(T key, MutableDouble val1, MutableDouble val2, double overlap)
SparseVectors.OverlapRecord(T key, MutableDouble first, MutableDouble second, double overlap)