net.sf.tweety.math.probability

## Class ProbabilityFunction<T extends java.lang.Comparable<T>>

• java.lang.Object
• net.sf.tweety.math.probability.ProbabilityFunction<T>
• Type Parameters:
`T` - The class of the objects used.
All Implemented Interfaces:
java.util.Map<T,Probability>
Direct Known Subclasses:
ProbabilisticExtension, SubgraphProbabilityFunction

```public class ProbabilityFunction<T extends java.lang.Comparable<T>>
extends java.lang.Object
implements java.util.Map<T,Probability>```
This class represents a probability distribution over some set of objects
Author:
Matthias Thimm

• ### Nested classes/interfaces inherited from interface java.util.Map

`java.util.Map.Entry<K,V>`
• ### Field Summary

Fields
Modifier and Type Field and Description
`private java.util.Map<T,Probability>` `probabilities`
The probabilities of the objects.
`private static java.util.Random` `random`
For random sampling.
• ### Constructor Summary

Constructors
Constructor and Description
`ProbabilityFunction()`
Creates a new probability function.
`ProbabilityFunction(ProbabilityFunction<T> other)`
Creates a new probability function by copying the given one.
• ### Method Summary

All Methods
Modifier and Type Method and Description
`void` `clear()`
`boolean` `containsKey(java.lang.Object key)`
`boolean` `containsValue(java.lang.Object value)`
`static <S extends java.lang.Comparable<S>>ProbabilityFunction<S>` ```convexCombination(double[] factors, ProbabilityFunction<S>[] creators)```
Computes the convex combination of the given probability distributions P1,...,PN with parameters factors, i.e.
`ProbabilityFunction<T>` ```convexCombination(double d, ProbabilityFunction<T> other)```
Computes the convex combination of this P1 and the given probability distribution P2 with parameter d, i.e.
`java.util.Set<java.util.Map.Entry<T,Probability>>` `entrySet()`
`boolean` `equals(java.lang.Object obj)`
`Probability` `get(java.lang.Object key)`
`java.util.Vector<Probability>` `getProbabilityVector()`
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
`java.util.Vector<java.lang.Double>` `getProbabilityVectorAsDoubles()`
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
`static <S extends java.lang.Comparable<S>>ProbabilityFunction<S>` `getUniformDistribution(java.util.Set<S> objects)`
Returns the uniform distribution on the given interpretations.
`int` `hashCode()`
`boolean` `isEmpty()`
`boolean` `isNormalized()`
Checks whether this probability function is normalized, i.e.
`java.util.Set<T>` `keySet()`
`ProbabilityFunction<T>` ```linearCombination(double d1, double d2, ProbabilityFunction<T> other)```
Makes a linear combination of this distribution "p1" and the given distribution "other" and the given parameters, i.e.
`void` `normalize()`
Normalizes this probability function to have mass 1.
`protected static void` `normalize(java.util.List<java.lang.Double> probabilities)`
Normalizes the given list of probabilities, i.e.
`Probability` `probability(java.util.Collection<? extends T> objects)`
Gets the probability of the given object.
`Probability` `probability(T w)`
Gets the probability of the given object.
`Probability` ```put(T key, Probability value)```
`void` `putAll(java.util.Map<? extends T,? extends Probability> m)`
`Probability` `remove(java.lang.Object key)`
`T` `sample()`
Samples one element from the domain of this probability function, depending on its probability.
`T` `sample(java.util.Random random)`
Samples one element from the domain of this probability function, depending on its probability.
`int` `size()`
`java.lang.String` `toString()`
`java.util.Collection<Probability>` `values()`
• ### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`
• ### Methods inherited from interface java.util.Map

`compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll`
• ### Field Detail

• #### random

`private static java.util.Random random`
For random sampling.
• #### probabilities

`private java.util.Map<T extends java.lang.Comparable<T>,Probability> probabilities`
The probabilities of the objects.
• ### Constructor Detail

• #### ProbabilityFunction

`public ProbabilityFunction()`
Creates a new probability function.
• #### ProbabilityFunction

`public ProbabilityFunction(ProbabilityFunction<T> other)`
Creates a new probability function by copying the given one.
• ### Method Detail

• #### probability

```public Probability probability(T w)
throws java.lang.IllegalArgumentException```
Gets the probability of the given object.
Parameters:
`w` - some object.
Returns:
the probability of the given object.
Throws:
`java.lang.IllegalArgumentException`
• #### probability

```public Probability probability(java.util.Collection<? extends T> objects)
throws java.lang.IllegalArgumentException```
Gets the probability of the given object.
Parameters:
`objects` - some object.
Returns:
the probability of the given object.
Throws:
`java.lang.IllegalArgumentException`
• #### normalize

`protected static void normalize(java.util.List<java.lang.Double> probabilities)`
Normalizes the given list of probabilities, i.e. divides each probability by the sum of all probabilities.
• #### isNormalized

`public boolean isNormalized()`
Checks whether this probability function is normalized, i.e. the sum of all probabilities is 1.
Returns:
"true" if this probability function is normalized.
• #### normalize

`public void normalize()`
Normalizes this probability function to have mass 1.
• #### convexCombination

```public ProbabilityFunction<T> convexCombination(double d,
ProbabilityFunction<T> other)```
Computes the convex combination of this P1 and the given probability distribution P2 with parameter d, i.e. it returns a P with P(i)=d P1(i) + (1-d) P2(i) for every interpretation i.
Parameters:
`d` - a double
`other` - a probability distribution
Returns:
the convex combination of this P1 and the given probability distribution P2 with parameter d.
Throws:
`java.lang.IllegalArgumentException` - if either d is not in [0,1] or this and the given probability distribution are not defined on the same set of interpretations.
• #### linearCombination

```public ProbabilityFunction<T> linearCombination(double d1,
double d2,
ProbabilityFunction<T> other)```
Makes a linear combination of this distribution "p1" and the given distribution "other" and the given parameters, i.e. it returns a P with P(i)=d1 P1(i) + d2 P2(i) for every interpretation i. NOTE: P is normalized after combination.
Parameters:
`d1` - a double.
`d2` - a double.
`other` - a probability distribution.
Returns:
a probability distribution.
• #### convexCombination

```public static <S extends java.lang.Comparable<S>> ProbabilityFunction<S> convexCombination(double[] factors,
ProbabilityFunction<S>[] creators)
throws java.lang.IllegalArgumentException```
Computes the convex combination of the given probability distributions P1,...,PN with parameters factors, i.e. it returns a P with P(i)=d1 P1(i) + d2 P2(i)+ ... + dN PN(i) for every object i (with d1,...,dN=factors).
Type Parameters:
`S` - The object class
Parameters:
`factors` - a vector of doubles.
`creators` - a vector of probability distributions.
Returns:
the convex combination of the given distributions with parameters factors.
Throws:
`java.lang.IllegalArgumentException` - if either the sum of factors d is not in 1, or this and the given probability distributions are not defined on the same set of objects, or the lengths of creators and factors differ.
• #### getUniformDistribution

`public static <S extends java.lang.Comparable<S>> ProbabilityFunction<S> getUniformDistribution(java.util.Set<S> objects)`
Returns the uniform distribution on the given interpretations.
Type Parameters:
`S` - The interpretation class
Parameters:
`objects` - set of interpretations of type S.
Returns:
the uniform distribution on the given interpretations.
• #### sample

`public T sample()`
Samples one element from the domain of this probability function, depending on its probability.
Returns:
a sample from this probability function.
• #### sample

`public T sample(java.util.Random random)`
Samples one element from the domain of this probability function, depending on its probability.
Parameters:
`random` - the number generator used.
Returns:
a sample from this probability function.
• #### toString

`public java.lang.String toString()`
Overrides:
`toString` in class `java.lang.Object`
• #### clear

`public void clear()`
Specified by:
`clear` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### containsKey

`public boolean containsKey(java.lang.Object key)`
Specified by:
`containsKey` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### containsValue

`public boolean containsValue(java.lang.Object value)`
Specified by:
`containsValue` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### entrySet

`public java.util.Set<java.util.Map.Entry<T,Probability>> entrySet()`
Specified by:
`entrySet` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### get

`public Probability get(java.lang.Object key)`
Specified by:
`get` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### isEmpty

`public boolean isEmpty()`
Specified by:
`isEmpty` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### put

```public Probability put(T key,
Probability value)```
Specified by:
`put` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### putAll

`public void putAll(java.util.Map<? extends T,? extends Probability> m)`
Specified by:
`putAll` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### remove

`public Probability remove(java.lang.Object key)`
Specified by:
`remove` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### size

`public int size()`
Specified by:
`size` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### values

`public java.util.Collection<Probability> values()`
Specified by:
`values` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### keySet

`public java.util.Set<T> keySet()`
Specified by:
`keySet` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
• #### hashCode

`public int hashCode()`
Specified by:
`hashCode` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
Overrides:
`hashCode` in class `java.lang.Object`
• #### getProbabilityVector

`public java.util.Vector<Probability> getProbabilityVector()`
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
Returns:
the vector of probabilities
• #### getProbabilityVectorAsDoubles

`public java.util.Vector<java.lang.Double> getProbabilityVectorAsDoubles()`
Returns the vector of probabilities, depending on the order of the domain elements (which can be ordered as they implement Comparable).
Returns:
the vector of probabilities as doubles
• #### equals

`public boolean equals(java.lang.Object obj)`
Specified by:
`equals` in interface `java.util.Map<T extends java.lang.Comparable<T>,Probability>`
Overrides:
`equals` in class `java.lang.Object`