FrequencyVector (de.mpg.mpi-inf:javatools 1.1 API)

java.lang.Object
- javatools.datatypes.FrequencyVector<T,V>

```
public class FrequencyVector<T,V extends Number & Comparable<V>>
extends Object
```
Copyright 2016 Fabian M. Suchanek Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Fabian M. Suchanek, Milan Vojnovic, Dinan Gunawardena "Social Tags: Meaning and Suggestions" (pdf, bib) ACM Conference on Information and Knowledge Management (CIKM 2008) The class represents a vector of terms with their frequencies. See the paper for explanations. Also provides Wilson interval computation.

Author:

Fabian M. Suchanek

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<T,V>`	`data` Holds the vector itself
`protected double`	`max` Holds the maximum value of all elements
`protected double`	`norm` Holds the L2 norm of this vector
`protected List<T>`	`sortedTerms` Holds the terms of the vector sorted by decreasing frequency
`protected double`	`sum` Holds the sum of all elements

Constructor Summary

Constructors
Constructor and Description

FrequencyVector(Map<T,V> applications)
Constructs a frequency vector.

Constructors
Constructor and Description
`FrequencyVector(Map<T,V> applications)` Constructs a frequency vector.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`averagePrecision(Collection<T> groundTruth)` Computes the average precision (MAP)
`double`	`cosine(FrequencyVector<T,?> other)` Computes the cosine to another vector
`double`	`cosine(FrequencyVector<T,?> other, Collection<T> intersection)` Computes the cosine to another vector, if the intersection is already available
`double`	`doubleValueFor(T term)` Returns the frequency for a term as double (or 0)
`boolean`	`equals(Object obj)`
`int`	`firstTiePos()` Returns the first position in sortedTerms that has equal number of applications to its successor
`double`	`fuzzyPrecisionWithRespectTo(FrequencyVector<T,V> trueFrequencies)` Computes the fuzzy Precision
`double`	`fuzzyRecallWithRespectTo(FrequencyVector<T,V> trueFrequencies)` Computes the fuzzy recall
`int`	`hashCode()`
`Set<T>`	`intersection(FrequencyVector<T,?> other)` Computes the common supports
`static void`	`main(String[] args)` Test
`double`	`max()` Returns the maximum of elements
`FrequencyVector<T,Double>`	`maxNormalized()` Max-Normalizes this vector
`double`	`maxNormalizedValueFor(T term)` Returns the frequency for a term, divided by the maximum (or 0)
`double`	`ndcg2WithRespectToGain(FrequencyVector<T,?> trueFrequencies)` Computes the NDCG with respect to a gain, with weighting 2^x
`double`	`ndcgWithRespectToGain(FrequencyVector<T,?> trueFrequencies)` Computes the NDCG with respect to a gain
`double`	`norm()` Returns the L2 norm of elements
`FrequencyVector<T,Double>`	`normalized()` Normalizes this vector
`FrequencyVector<T,Double>`	`normalizedMeanWith(FrequencyVector<T,V> other)` Computes the mean vector of this vector and the other one
`double`	`normalizedValueFor(T term)` Returns the frequency for a term, divided by the sum (or 0)
`int`	`numTerms()` Returns the number of terms in the support
`double`	`optimalAveragePrecision(FrequencyVector<T,?> trueFrequencies)` Computes the average precision, shuffling subsets to get an optimal value
`double`	`precisionAtKWithRespectTo(Collection<T> groundTruth, int k)` Computes the standard precision at k
`double`	`precisionAtKWithRespectTo(FrequencyVector<T,?> groundTruth, int k)` Computes the standard precision at k
`double`	`precisionWithRespectTo(Collection<T> groundTruth)` Computes standard precision
`double`	`precisionWithRespectTo(FrequencyVector<T,?> trueFrequencies)` Computes the standard precision
`double`	`precisionWithRespectToIntersection(Collection<T> intersection)` Computes the standard precision if the intersection is known
`double`	`recallAtKWithRespectTo(Collection<T> groundTruth, int k)` Computes the standard recall at k
`double`	`recallAtKWithRespectTo(FrequencyVector<T,V> trueFrequencies, int k)` Computes the standard recall at k
`double`	`recallWithRespectTo(Collection<T> groundTruth)` Computes the standard recall
`double`	`recallWithRespectTo(Collection<T> trueSet, Collection<T> intersection)` Computes standard recall, if the intersection is already available
`double`	`recallWithRespectTo(FrequencyVector<T,?> trueFrequencies)` Computes standard recall
`double`	`recallWithRespectTo(FrequencyVector<T,?> trueFrequencies, Collection<T> intersection)` Computes standard recall, if the intersection is already available
`double`	`smoothedValueFor(T term)` Returns the frequency for a term, divided by the sum and smoothed
`List<T>`	`sortedTerms()` Returns the terms sorted by decreasing frequency
`protected static <C,V extends Comparable<V>> List<C>`	`sortedTerms(Map<C,V> applications)` Returns the terms of the application data sorted by their number of applications
`double`	`sum()` Returns the sum of elements
`T`	`termAtRank(int i)` Returns the term at rank i
`Collection<T>`	`terms()` Returns the terms.
`Set<T>`	`topKIntersection(FrequencyVector<T,V> trueFrequencies, int k)` Computes the intersection of the top k elements
`String`	`toString()`
`V`	`valueFor(T term)` Returns the frequency for a term (or null)
`double`	`weightedPrecisionAtKWithRespectTo(Collection<T> groundTruth, int k)` Computes the precision at k to a set, weighted with this vector's frequencies
`double`	`weightedPrecisionAtKWithRespectTo(FrequencyVector<T,?> groundTruth, int k)` Computes the weighted precision at k
`double`	`weightedPrecisionWithRespectTo(Collection<T> groundTruth)` Computes the standard precision to a set, weighted with this vector's frequencies
`double`	`weightedPrecisionWithRespectTo(FrequencyVector<T,?> trueFrequencies)` Computes the standard precision to a set, weighted with this vector's frequencies
`double`	`weightedRecallAtKWithRespectTo(FrequencyVector<T,V> trueFrequencies, int k)` Computes the standard recall at k, weighted with the true frequencies
`double`	`weightedRecallWithRespectTo(FrequencyVector<T,V> trueFrequencies)` Computes the standard recall, weighted with the true frequencies
`static double[]`	`wilson(int total, int correct)` Computes the Wilson Interval (see http://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Wilson_score_interval) Given the total number of events and the number of "correct" events, returns in a double-array in the first component the center of the Wilson interval and in the second component the width of the interval.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - norm
```
protected double norm
```
    Holds the L2 norm of this vector
  - sum
```
protected double sum
```
    Holds the sum of all elements
  - max
```
protected double max
```
    Holds the maximum value of all elements
  - data
```
protected Map<T,V extends Number & Comparable<V>> data
```
    Holds the vector itself
  - sortedTerms
```
protected List<T> sortedTerms
```
    Holds the terms of the vector sorted by decreasing frequency
- Constructor Detail
  - FrequencyVector
```
public FrequencyVector(Map<T,V> applications)
```
    Constructs a frequency vector. The frequency vector is backed by the map. ZERO-entries are removed!
- Method Detail
  - firstTiePos
```
public int firstTiePos()
```
    Returns the first position in sortedTerms that has equal number of applications to its successor
  - sum
```
public double sum()
```
    Returns the sum of elements
  - norm
```
public double norm()
```
    Returns the L2 norm of elements
  - max
```
public double max()
```
    Returns the maximum of elements
  - termAtRank
```
public T termAtRank(int i)
```
    Returns the term at rank i
  - numTerms
```
public int numTerms()
```
    Returns the number of terms in the support
  - valueFor
```
public V valueFor(T term)
```
    Returns the frequency for a term (or null)
  - doubleValueFor
```
public double doubleValueFor(T term)
```
    Returns the frequency for a term as double (or 0)
  - normalizedValueFor
```
public double normalizedValueFor(T term)
```
    Returns the frequency for a term, divided by the sum (or 0)
  - maxNormalizedValueFor
```
public double maxNormalizedValueFor(T term)
```
    Returns the frequency for a term, divided by the maximum (or 0)
  - smoothedValueFor
```
public double smoothedValueFor(T term)
```
    Returns the frequency for a term, divided by the sum and smoothed
  - sortedTerms
```
public List<T> sortedTerms()
```
    Returns the terms sorted by decreasing frequency
  - terms
```
public Collection<T> terms()
```
    Returns the terms. This collection may be more efficient for membership checks than the sortedTerms
  - sortedTerms
```
protected static <C,V extends Comparable<V>> List<C> sortedTerms(Map<C,V> applications)
```
    Returns the terms of the application data sorted by their number of applications
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - normalized
```
public FrequencyVector<T,Double> normalized()
```
    Normalizes this vector
  - maxNormalized
```
public FrequencyVector<T,Double> maxNormalized()
```
    Max-Normalizes this vector
  - intersection
```
public Set<T> intersection(FrequencyVector<T,?> other)
```
    Computes the common supports
  - topKIntersection
```
public Set<T> topKIntersection(FrequencyVector<T,V> trueFrequencies,
                               int k)
```
    Computes the intersection of the top k elements
  - cosine
```
public double cosine(FrequencyVector<T,?> other,
                     Collection<T> intersection)
```
    Computes the cosine to another vector, if the intersection is already available
  - cosine
```
public double cosine(FrequencyVector<T,?> other)
```
    Computes the cosine to another vector
  - precisionAtKWithRespectTo
```
public double precisionAtKWithRespectTo(Collection<T> groundTruth,
                                        int k)
```
    Computes the standard precision at k
  - weightedPrecisionAtKWithRespectTo
```
public double weightedPrecisionAtKWithRespectTo(Collection<T> groundTruth,
                                                int k)
```
    Computes the precision at k to a set, weighted with this vector's frequencies
  - precisionWithRespectTo
```
public double precisionWithRespectTo(Collection<T> groundTruth)
```
    Computes standard precision
  - precisionWithRespectTo
```
public double precisionWithRespectTo(FrequencyVector<T,?> trueFrequencies)
```
    Computes the standard precision
  - precisionWithRespectToIntersection
```
public double precisionWithRespectToIntersection(Collection<T> intersection)
```
    Computes the standard precision if the intersection is known
  - weightedPrecisionWithRespectTo
```
public double weightedPrecisionWithRespectTo(Collection<T> groundTruth)
```
    Computes the standard precision to a set, weighted with this vector's frequencies
  - weightedPrecisionWithRespectTo
```
public double weightedPrecisionWithRespectTo(FrequencyVector<T,?> trueFrequencies)
```
    Computes the standard precision to a set, weighted with this vector's frequencies
  - precisionAtKWithRespectTo
```
public double precisionAtKWithRespectTo(FrequencyVector<T,?> groundTruth,
                                        int k)
```
    Computes the standard precision at k
  - weightedPrecisionAtKWithRespectTo
```
public double weightedPrecisionAtKWithRespectTo(FrequencyVector<T,?> groundTruth,
                                                int k)
```
    Computes the weighted precision at k
  - averagePrecision
```
public double averagePrecision(Collection<T> groundTruth)
```
    Computes the average precision (MAP)
  - optimalAveragePrecision
```
public double optimalAveragePrecision(FrequencyVector<T,?> trueFrequencies)
```
    Computes the average precision, shuffling subsets to get an optimal value
  - recallAtKWithRespectTo
```
public double recallAtKWithRespectTo(Collection<T> groundTruth,
                                     int k)
```
    Computes the standard recall at k
  - recallWithRespectTo
```
public double recallWithRespectTo(Collection<T> groundTruth)
```
    Computes the standard recall
  - weightedRecallWithRespectTo
```
public double weightedRecallWithRespectTo(FrequencyVector<T,V> trueFrequencies)
```
    Computes the standard recall, weighted with the true frequencies
  - weightedRecallAtKWithRespectTo
```
public double weightedRecallAtKWithRespectTo(FrequencyVector<T,V> trueFrequencies,
                                             int k)
```
    Computes the standard recall at k, weighted with the true frequencies
  - recallWithRespectTo
```
public double recallWithRespectTo(FrequencyVector<T,?> trueFrequencies)
```
    Computes standard recall
  - recallWithRespectTo
```
public double recallWithRespectTo(Collection<T> trueSet,
                                  Collection<T> intersection)
```
    Computes standard recall, if the intersection is already available
  - recallWithRespectTo
```
public double recallWithRespectTo(FrequencyVector<T,?> trueFrequencies,
                                  Collection<T> intersection)
```
    Computes standard recall, if the intersection is already available
  - recallAtKWithRespectTo
```
public double recallAtKWithRespectTo(FrequencyVector<T,V> trueFrequencies,
                                     int k)
```
    Computes the standard recall at k
  - ndcgWithRespectToGain
```
public double ndcgWithRespectToGain(FrequencyVector<T,?> trueFrequencies)
```
    Computes the NDCG with respect to a gain
  - ndcg2WithRespectToGain
```
public double ndcg2WithRespectToGain(FrequencyVector<T,?> trueFrequencies)
```
    Computes the NDCG with respect to a gain, with weighting 2^x
  - normalizedMeanWith
```
public FrequencyVector<T,Double> normalizedMeanWith(FrequencyVector<T,V> other)
```
    Computes the mean vector of this vector and the other one
  - fuzzyRecallWithRespectTo
```
public double fuzzyRecallWithRespectTo(FrequencyVector<T,V> trueFrequencies)
```
    Computes the fuzzy recall
  - fuzzyPrecisionWithRespectTo
```
public double fuzzyPrecisionWithRespectTo(FrequencyVector<T,V> trueFrequencies)
```
    Computes the fuzzy Precision
  - wilson
```
public static double[] wilson(int total,
                              int correct)
```
    Computes the Wilson Interval (see http://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Wilson_score_interval) Given the total number of events and the number of "correct" events, returns in a double-array in the first component the center of the Wilson interval and in the second component the width of the interval. alpha=95%.
  - main
```
public static void main(String[] args)
```
    Test

Class FrequencyVector<T,V extends Number & Comparable<V>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

norm

sum

max

data

sortedTerms

Constructor Detail

FrequencyVector

Method Detail

firstTiePos

sum

norm

max

termAtRank

numTerms

valueFor

doubleValueFor

normalizedValueFor

maxNormalizedValueFor

smoothedValueFor

sortedTerms

terms

sortedTerms

toString

hashCode

equals

normalized

maxNormalized

intersection

topKIntersection

cosine

cosine

precisionAtKWithRespectTo

weightedPrecisionAtKWithRespectTo

precisionWithRespectTo

precisionWithRespectTo

precisionWithRespectToIntersection

weightedPrecisionWithRespectTo

weightedPrecisionWithRespectTo

precisionAtKWithRespectTo

weightedPrecisionAtKWithRespectTo

averagePrecision

optimalAveragePrecision

recallAtKWithRespectTo

recallWithRespectTo

weightedRecallWithRespectTo

weightedRecallAtKWithRespectTo

recallWithRespectTo

recallWithRespectTo

recallWithRespectTo

recallAtKWithRespectTo

ndcgWithRespectToGain

ndcg2WithRespectToGain

normalizedMeanWith

fuzzyRecallWithRespectTo

fuzzyPrecisionWithRespectTo

wilson

main